# Generated by Snowball 2.0.0 - https://snowballstem.org/

from .basestemmer import BaseStemmer
from .among import Among


class TamilStemmer(BaseStemmer):
    '''
    This class implements the stemming algorithm defined by a snowball script.
    Generated by Snowball 2.0.0 - https://snowballstem.org/
    '''

    a_0 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B99", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9E", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BA8", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BAE", -1, -1),
        Among(u"\u0BAF", -1, -1),
        Among(u"\u0BB5", -1, -1)
    ]

    a_1 = [
        Among(u"\u0BA8\u0BCD\u0BA4", -1, -1),
        Among(u"\u0BA8\u0BCD\u0BA4\u0BCD", -1, -1),
        Among(u"\u0BA8\u0BCD", -1, -1)
    ]

    a_2 = [
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_3 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9F", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BB1", -1, -1)
    ]

    a_4 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9F", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BB1", -1, -1)
    ]

    a_5 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9F", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BB1", -1, -1)
    ]

    a_6 = [
        Among(u"\u0BAF", -1, -1),
        Among(u"\u0BB0", -1, -1),
        Among(u"\u0BB2", -1, -1),
        Among(u"\u0BB3", -1, -1),
        Among(u"\u0BB4", -1, -1),
        Among(u"\u0BB5", -1, -1)
    ]

    a_7 = [
        Among(u"\u0B99", -1, -1),
        Among(u"\u0B9E", -1, -1),
        Among(u"\u0BA3", -1, -1),
        Among(u"\u0BA8", -1, -1),
        Among(u"\u0BA9", -1, -1),
        Among(u"\u0BAE", -1, -1)
    ]

    a_8 = [
        Among(u"\u0BAF", -1, -1),
        Among(u"\u0BB5", -1, -1),
        Among(u"\u0BB5\u0BCD", -1, -1)
    ]

    a_9 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC1", -1, -1),
        Among(u"\u0BC2", -1, -1),
        Among(u"\u0BC6", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_10 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC1", -1, -1),
        Among(u"\u0BC2", -1, -1),
        Among(u"\u0BC6", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_11 = [
        Among(u"\u0B85", -1, -1),
        Among(u"\u0B87", -1, -1),
        Among(u"\u0B89", -1, -1)
    ]

    a_12 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B99", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9E", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BA8", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BAE", -1, -1),
        Among(u"\u0BAF", -1, -1),
        Among(u"\u0BB5", -1, -1)
    ]

    a_13 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9F", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BB1", -1, -1)
    ]

    a_14 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BCB", -1, -1)
    ]

    a_15 = [
        Among(u"\u0BAA\u0BBF", -1, -1),
        Among(u"\u0BB5\u0BBF", -1, -1)
    ]

    a_16 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC1", -1, -1),
        Among(u"\u0BC2", -1, -1),
        Among(u"\u0BC6", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_17 = [
        Among(u"\u0BAA\u0B9F\u0BCD\u0B9F", -1, -1),
        Among(u"\u0BAA\u0B9F\u0BCD\u0B9F\u0BA3", -1, -1),
        Among(u"\u0BA4\u0BBE\u0BA9", -1, -1),
        Among(u"\u0BAA\u0B9F\u0BBF\u0BA4\u0BBE\u0BA9", 2, -1),
        Among(u"\u0B95\u0BC1\u0BB0\u0BBF\u0BAF", -1, -1),
        Among(u"\u0BAA\u0B9F\u0BBF", -1, -1),
        Among(u"\u0BAA\u0BB1\u0BCD\u0BB1\u0BBF", -1, -1),
        Among(u"\u0BAA\u0B9F\u0BC1", -1, -1),
        Among(u"\u0BB5\u0BBF\u0B9F\u0BC1", -1, -1),
        Among(u"\u0BAA\u0B9F\u0BCD\u0B9F\u0BC1", -1, -1),
        Among(u"\u0BB5\u0BBF\u0B9F\u0BCD\u0B9F\u0BC1", -1, -1),
        Among(u"\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1", -1, -1),
        Among(u"\u0BC6\u0BB2\u0BCD\u0BB2\u0BBE\u0BAE\u0BCD", -1, -1)
    ]

    a_18 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9F", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BB1", -1, -1)
    ]

    a_19 = [
        Among(u"\u0B95", -1, -1),
        Among(u"\u0B9A", -1, -1),
        Among(u"\u0B9F", -1, -1),
        Among(u"\u0BA4", -1, -1),
        Among(u"\u0BAA", -1, -1),
        Among(u"\u0BB1", -1, -1)
    ]

    a_20 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC1", -1, -1),
        Among(u"\u0BC2", -1, -1),
        Among(u"\u0BC6", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_21 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC1", -1, -1),
        Among(u"\u0BC2", -1, -1),
        Among(u"\u0BC6", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_22 = [
        Among(u"\u0BAA\u0B9F\u0BC1", -1, -1),
        Among(u"\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BCD", -1, -1)
    ]

    a_23 = [
        Among(u"\u0B85", -1, -1),
        Among(u"\u0B86", -1, -1),
        Among(u"\u0B87", -1, -1),
        Among(u"\u0B88", -1, -1),
        Among(u"\u0B89", -1, -1),
        Among(u"\u0B8A", -1, -1),
        Among(u"\u0B8E", -1, -1),
        Among(u"\u0B8F", -1, -1),
        Among(u"\u0B90", -1, -1),
        Among(u"\u0B92", -1, -1),
        Among(u"\u0B93", -1, -1),
        Among(u"\u0B94", -1, -1)
    ]

    a_24 = [
        Among(u"\u0BBE", -1, -1),
        Among(u"\u0BBF", -1, -1),
        Among(u"\u0BC0", -1, -1),
        Among(u"\u0BC1", -1, -1),
        Among(u"\u0BC2", -1, -1),
        Among(u"\u0BC6", -1, -1),
        Among(u"\u0BC7", -1, -1),
        Among(u"\u0BC8", -1, -1)
    ]

    a_25 = [
        Among(u"\u0B95\u0BBF\u0BB1", -1, -1),
        Among(u"\u0B95\u0BBF\u0BA9\u0BCD\u0BB1", -1, -1),
        Among(u"\u0BBE\u0BA8\u0BBF\u0BA9\u0BCD\u0BB1", -1, -1),
        Among(u"\u0B95\u0BBF\u0BB1\u0BCD", -1, -1),
        Among(u"\u0B95\u0BBF\u0BA9\u0BCD\u0BB1\u0BCD", -1, -1),
        Among(u"\u0BBE\u0BA8\u0BBF\u0BA9\u0BCD\u0BB1\u0BCD", -1, -1)
    ]

    B_found_vetrumai_urupu = False
    B_found_a_match = False

    def __r_has_min_length(self):
        # (, line 99
        if not len(self.current) > 4:
            return False
        return True

    def __r_fix_va_start(self):
        # (, line 103
        # or, line 104
        try:
            v_1 = self.cursor
            try:
                # (, line 104
                # and, line 104
                v_2 = self.cursor
                # try, line 104
                v_3 = self.cursor
                try:
                    # literal, line 104
                    if not self.eq_s(u"\u0BB5\u0BCB"):
                        self.cursor = v_3
                        raise lab2()
                except lab2: pass
                self.cursor = v_2
                # [, line 104
                self.bra = self.cursor
                # literal, line 104
                if not self.eq_s(u"\u0BB5\u0BCB"):
                    raise lab1()
                # ], line 104
                self.ket = self.cursor
                # <-, line 104
                if not self.slice_from(u"\u0B93"):
                    return False
                raise lab0()
            except lab1: pass
            self.cursor = v_1
            try:
                # (, line 105
                # and, line 105
                v_4 = self.cursor
                # try, line 105
                v_5 = self.cursor
                try:
                    # literal, line 105
                    if not self.eq_s(u"\u0BB5\u0BCA"):
                        self.cursor = v_5
                        raise lab4()
                except lab4: pass
                self.cursor = v_4
                # [, line 105
                self.bra = self.cursor
                # literal, line 105
                if not self.eq_s(u"\u0BB5\u0BCA"):
                    raise lab3()
                # ], line 105
                self.ket = self.cursor
                # <-, line 105
                if not self.slice_from(u"\u0B92"):
                    return False
                raise lab0()
            except lab3: pass
            self.cursor = v_1
            try:
                # (, line 106
                # and, line 106
                v_6 = self.cursor
                # try, line 106
                v_7 = self.cursor
                try:
                    # literal, line 106
                    if not self.eq_s(u"\u0BB5\u0BC1"):
                        self.cursor = v_7
                        raise lab6()
                except lab6: pass
                self.cursor = v_6
                # [, line 106
                self.bra = self.cursor
                # literal, line 106
                if not self.eq_s(u"\u0BB5\u0BC1"):
                    raise lab5()
                # ], line 106
                self.ket = self.cursor
                # <-, line 106
                if not self.slice_from(u"\u0B89"):
                    return False
                raise lab0()
            except lab5: pass
            self.cursor = v_1
            # (, line 107
            # and, line 107
            v_8 = self.cursor
            # try, line 107
            v_9 = self.cursor
            try:
                # literal, line 107
                if not self.eq_s(u"\u0BB5\u0BC2"):
                    self.cursor = v_9
                    raise lab7()
            except lab7: pass
            self.cursor = v_8
            # [, line 107
            self.bra = self.cursor
            # literal, line 107
            if not self.eq_s(u"\u0BB5\u0BC2"):
                return False
            # ], line 107
            self.ket = self.cursor
            # <-, line 107
            if not self.slice_from(u"\u0B8A"):
                return False
        except lab0: pass
        return True

    def __r_fix_endings(self):
        # (, line 110
        # do, line 111
        v_1 = self.cursor
        try:
            # repeat, line 111
            while True:
                v_2 = self.cursor
                try:
                    # call fix_ending, line 111
                    if not self.__r_fix_ending():
                        raise lab1()
                    continue
                except lab1: pass
                self.cursor = v_2
                break
        except lab0: pass
        self.cursor = v_1
        return True

    def __r_remove_question_prefixes(self):
        # (, line 114
        # [, line 115
        self.bra = self.cursor
        # (, line 115
        # literal, line 115
        if not self.eq_s(u"\u0B8E"):
            return False
        # among, line 115
        if self.find_among(TamilStemmer.a_0) == 0:
            return False
        # literal, line 115
        if not self.eq_s(u"\u0BCD"):
            return False
        # ], line 115
        self.ket = self.cursor
        # delete, line 115
        if not self.slice_del():
            return False

        # do, line 116
        v_1 = self.cursor
        # call fix_va_start, line 116
        self.__r_fix_va_start()
        self.cursor = v_1
        return True

    def __r_fix_ending(self):
        # (, line 120
        if not len(self.current) > 3:
            return False
        # backwards, line 122
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 122
        # or, line 124
        try:
            v_1 = self.limit - self.cursor
            try:
                # (, line 123
                # [, line 123
                self.ket = self.cursor
                # among, line 123
                if self.find_among_b(TamilStemmer.a_1) == 0:
                    raise lab1()
                # ], line 123
                self.bra = self.cursor
                # delete, line 123
                if not self.slice_del():
                    return False

                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 125
                # [, line 125
                self.ket = self.cursor
                # literal, line 125
                if not self.eq_s_b(u"\u0BAF\u0BCD"):
                    raise lab2()
                # test, line 125
                v_2 = self.limit - self.cursor
                # among, line 125
                if self.find_among_b(TamilStemmer.a_2) == 0:
                    raise lab2()
                self.cursor = self.limit - v_2
                # ], line 125
                self.bra = self.cursor
                # delete, line 125
                if not self.slice_del():
                    return False

                raise lab0()
            except lab2: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 127
                # [, line 127
                self.ket = self.cursor
                # or, line 127
                try:
                    v_3 = self.limit - self.cursor
                    try:
                        # literal, line 127
                        if not self.eq_s_b(u"\u0B9F\u0BCD\u0BAA\u0BCD"):
                            raise lab5()
                        raise lab4()
                    except lab5: pass
                    self.cursor = self.limit - v_3
                    # literal, line 127
                    if not self.eq_s_b(u"\u0B9F\u0BCD\u0B95\u0BCD"):
                        raise lab3()
                except lab4: pass
                # ], line 127
                self.bra = self.cursor
                # <-, line 127
                if not self.slice_from(u"\u0BB3\u0BCD"):
                    return False
                raise lab0()
            except lab3: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 129
                # [, line 129
                self.ket = self.cursor
                # literal, line 129
                if not self.eq_s_b(u"\u0BA9\u0BCD\u0BB1\u0BCD"):
                    raise lab6()
                # ], line 129
                self.bra = self.cursor
                # <-, line 129
                if not self.slice_from(u"\u0BB2\u0BCD"):
                    return False
                raise lab0()
            except lab6: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 132
                # [, line 132
                self.ket = self.cursor
                # literal, line 132
                if not self.eq_s_b(u"\u0BB1\u0BCD\u0B95\u0BCD"):
                    raise lab7()
                # ], line 132
                self.bra = self.cursor
                # <-, line 132
                if not self.slice_from(u"\u0BB2\u0BCD"):
                    return False
                raise lab0()
            except lab7: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 134
                # [, line 134
                self.ket = self.cursor
                # literal, line 134
                if not self.eq_s_b(u"\u0B9F\u0BCD\u0B9F\u0BCD"):
                    raise lab8()
                # ], line 134
                self.bra = self.cursor
                # <-, line 134
                if not self.slice_from(u"\u0B9F\u0BC1"):
                    return False
                raise lab0()
            except lab8: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 136
                # Boolean test found_vetrumai_urupu, line 136
                if not self.B_found_vetrumai_urupu:
                    raise lab9()
                # [, line 136
                self.ket = self.cursor
                # literal, line 136
                if not self.eq_s_b(u"\u0BA4\u0BCD\u0BA4\u0BCD"):
                    raise lab9()
                # (, line 136
                # test, line 136
                v_4 = self.limit - self.cursor
                # not, line 136
                v_5 = self.limit - self.cursor
                try:
                    # literal, line 136
                    if not self.eq_s_b(u"\u0BC8"):
                        raise lab10()
                    raise lab9()
                except lab10: pass
                self.cursor = self.limit - v_5
                self.cursor = self.limit - v_4
                # ], line 136
                self.bra = self.cursor
                # <-, line 136
                if not self.slice_from(u"\u0BAE\u0BCD"):
                    return False
                # ], line 136
                self.bra = self.cursor
                raise lab0()
            except lab9: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 138
                # [, line 138
                self.ket = self.cursor
                # or, line 138
                try:
                    v_6 = self.limit - self.cursor
                    try:
                        # literal, line 138
                        if not self.eq_s_b(u"\u0BC1\u0B95\u0BCD"):
                            raise lab13()
                        raise lab12()
                    except lab13: pass
                    self.cursor = self.limit - v_6
                    # literal, line 138
                    if not self.eq_s_b(u"\u0BC1\u0B95\u0BCD\u0B95\u0BCD"):
                        raise lab11()
                except lab12: pass
                # ], line 138
                self.bra = self.cursor
                # <-, line 138
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab11: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 140
                # [, line 140
                self.ket = self.cursor
                # literal, line 140
                if not self.eq_s_b(u"\u0BCD"):
                    raise lab14()
                # among, line 140
                if self.find_among_b(TamilStemmer.a_3) == 0:
                    raise lab14()
                # literal, line 140
                if not self.eq_s_b(u"\u0BCD"):
                    raise lab14()
                # among, line 140
                if self.find_among_b(TamilStemmer.a_4) == 0:
                    raise lab14()
                # ], line 140
                self.bra = self.cursor
                # delete, line 140
                if not self.slice_del():
                    return False

                raise lab0()
            except lab14: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 142
                # [, line 142
                self.ket = self.cursor
                # literal, line 142
                if not self.eq_s_b(u"\u0BC1\u0B95\u0BCD"):
                    raise lab15()
                # ], line 142
                self.bra = self.cursor
                # <-, line 142
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab15: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 144
                # [, line 144
                self.ket = self.cursor
                # literal, line 144
                if not self.eq_s_b(u"\u0BCD"):
                    raise lab16()
                # among, line 144
                if self.find_among_b(TamilStemmer.a_5) == 0:
                    raise lab16()
                # ], line 144
                self.bra = self.cursor
                # delete, line 144
                if not self.slice_del():
                    return False

                raise lab0()
            except lab16: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 146
                # [, line 146
                self.ket = self.cursor
                # literal, line 146
                if not self.eq_s_b(u"\u0BCD"):
                    raise lab17()
                # (, line 146
                # or, line 146
                try:
                    v_7 = self.limit - self.cursor
                    try:
                        # among, line 146
                        if self.find_among_b(TamilStemmer.a_6) == 0:
                            raise lab19()
                        raise lab18()
                    except lab19: pass
                    self.cursor = self.limit - v_7
                    # among, line 146
                    if self.find_among_b(TamilStemmer.a_7) == 0:
                        raise lab17()
                except lab18: pass
                # literal, line 146
                if not self.eq_s_b(u"\u0BCD"):
                    raise lab17()
                # ], line 146
                self.bra = self.cursor
                # <-, line 146
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab17: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 148
                # [, line 148
                self.ket = self.cursor
                # among, line 148
                if self.find_among_b(TamilStemmer.a_8) == 0:
                    raise lab20()
                # ], line 148
                self.bra = self.cursor
                # delete, line 148
                if not self.slice_del():
                    return False

                raise lab0()
            except lab20: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 150
                # [, line 150
                self.ket = self.cursor
                # literal, line 150
                if not self.eq_s_b(u"\u0BA9\u0BC1"):
                    raise lab21()
                # (, line 150
                # test, line 150
                v_8 = self.limit - self.cursor
                # not, line 150
                v_9 = self.limit - self.cursor
                try:
                    # among, line 150
                    if self.find_among_b(TamilStemmer.a_9) == 0:
                        raise lab22()
                    raise lab21()
                except lab22: pass
                self.cursor = self.limit - v_9
                self.cursor = self.limit - v_8
                # ], line 150
                self.bra = self.cursor
                # delete, line 150
                if not self.slice_del():
                    return False

                raise lab0()
            except lab21: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 152
                # [, line 152
                self.ket = self.cursor
                # literal, line 152
                if not self.eq_s_b(u"\u0B99\u0BCD"):
                    raise lab23()
                # (, line 152
                # test, line 152
                v_10 = self.limit - self.cursor
                # not, line 152
                v_11 = self.limit - self.cursor
                try:
                    # literal, line 152
                    if not self.eq_s_b(u"\u0BC8"):
                        raise lab24()
                    raise lab23()
                except lab24: pass
                self.cursor = self.limit - v_11
                self.cursor = self.limit - v_10
                # ], line 152
                self.bra = self.cursor
                # <-, line 152
                if not self.slice_from(u"\u0BAE\u0BCD"):
                    return False
                raise lab0()
            except lab23: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 154
                # [, line 154
                self.ket = self.cursor
                # literal, line 154
                if not self.eq_s_b(u"\u0B99\u0BCD"):
                    raise lab25()
                # ], line 154
                self.bra = self.cursor
                # delete, line 154
                if not self.slice_del():
                    return False

                raise lab0()
            except lab25: pass
            self.cursor = self.limit - v_1
            # (, line 156
            # [, line 156
            self.ket = self.cursor
            # literal, line 156
            if not self.eq_s_b(u"\u0BCD"):
                return False
            # (, line 156
            # test, line 156
            v_12 = self.limit - self.cursor
            # (, line 156
            # or, line 156
            try:
                v_13 = self.limit - self.cursor
                try:
                    # among, line 156
                    if self.find_among_b(TamilStemmer.a_10) == 0:
                        raise lab27()
                    raise lab26()
                except lab27: pass
                self.cursor = self.limit - v_13
                # literal, line 156
                if not self.eq_s_b(u"\u0BCD"):
                    return False
            except lab26: pass
            self.cursor = self.limit - v_12
            # ], line 156
            self.bra = self.cursor
            # delete, line 156
            if not self.slice_del():
                return False

        except lab0: pass
        self.cursor = self.limit_backward
        return True

    def __r_remove_pronoun_prefixes(self):
        # (, line 160
        # unset found_a_match, line 161
        self.B_found_a_match = False
        # [, line 162
        self.bra = self.cursor
        # among, line 162
        if self.find_among(TamilStemmer.a_11) == 0:
            return False
        # among, line 162
        if self.find_among(TamilStemmer.a_12) == 0:
            return False
        # literal, line 162
        if not self.eq_s(u"\u0BCD"):
            return False
        # ], line 162
        self.ket = self.cursor
        # delete, line 162
        if not self.slice_del():
            return False

        # (, line 163
        # set found_a_match, line 163
        self.B_found_a_match = True
        # do, line 164
        v_1 = self.cursor
        # call fix_va_start, line 164
        self.__r_fix_va_start()
        self.cursor = v_1
        return True

    def __r_remove_plural_suffix(self):
        # (, line 167
        # unset found_a_match, line 168
        self.B_found_a_match = False
        # backwards, line 169
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 169
        # or, line 170
        try:
            v_1 = self.limit - self.cursor
            try:
                # (, line 170
                # [, line 170
                self.ket = self.cursor
                # literal, line 170
                if not self.eq_s_b(u"\u0BC1\u0B99\u0BCD\u0B95\u0BB3\u0BCD"):
                    raise lab1()
                # (, line 170
                # test, line 170
                v_2 = self.limit - self.cursor
                # not, line 170
                v_3 = self.limit - self.cursor
                try:
                    # among, line 170
                    if self.find_among_b(TamilStemmer.a_13) == 0:
                        raise lab2()
                    raise lab1()
                except lab2: pass
                self.cursor = self.limit - v_3
                self.cursor = self.limit - v_2
                # ], line 170
                self.bra = self.cursor
                # <-, line 170
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 171
                # [, line 171
                self.ket = self.cursor
                # literal, line 171
                if not self.eq_s_b(u"\u0BB1\u0BCD\u0B95\u0BB3\u0BCD"):
                    raise lab3()
                # ], line 171
                self.bra = self.cursor
                # <-, line 171
                if not self.slice_from(u"\u0BB2\u0BCD"):
                    return False
                raise lab0()
            except lab3: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 172
                # [, line 172
                self.ket = self.cursor
                # literal, line 172
                if not self.eq_s_b(u"\u0B9F\u0BCD\u0B95\u0BB3\u0BCD"):
                    raise lab4()
                # ], line 172
                self.bra = self.cursor
                # <-, line 172
                if not self.slice_from(u"\u0BB3\u0BCD"):
                    return False
                raise lab0()
            except lab4: pass
            self.cursor = self.limit - v_1
            # (, line 173
            # [, line 173
            self.ket = self.cursor
            # literal, line 173
            if not self.eq_s_b(u"\u0B95\u0BB3\u0BCD"):
                return False
            # ], line 173
            self.bra = self.cursor
            # delete, line 173
            if not self.slice_del():
                return False

        except lab0: pass
        # (, line 174
        # set found_a_match, line 174
        self.B_found_a_match = True
        self.cursor = self.limit_backward
        return True

    def __r_remove_question_suffixes(self):
        # (, line 178
        # call has_min_length, line 179
        if not self.__r_has_min_length():
            return False
        # unset found_a_match, line 180
        self.B_found_a_match = False
        # backwards, line 181
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 181
        # do, line 182
        v_1 = self.limit - self.cursor
        try:
            # (, line 182
            # [, line 183
            self.ket = self.cursor
            # among, line 183
            if self.find_among_b(TamilStemmer.a_14) == 0:
                raise lab0()
            # ], line 183
            self.bra = self.cursor
            # <-, line 183
            if not self.slice_from(u"\u0BCD"):
                return False
            # (, line 184
            # set found_a_match, line 184
            self.B_found_a_match = True
        except lab0: pass
        self.cursor = self.limit - v_1
        self.cursor = self.limit_backward
        # do, line 187
        # call fix_endings, line 187
        self.__r_fix_endings()
        return True

    def __r_remove_command_suffixes(self):
        # (, line 190
        # call has_min_length, line 191
        if not self.__r_has_min_length():
            return False
        # unset found_a_match, line 192
        self.B_found_a_match = False
        # backwards, line 193
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 193
        # [, line 194
        self.ket = self.cursor
        # among, line 194
        if self.find_among_b(TamilStemmer.a_15) == 0:
            return False
        # ], line 194
        self.bra = self.cursor
        # delete, line 194
        if not self.slice_del():
            return False

        # (, line 195
        # set found_a_match, line 195
        self.B_found_a_match = True
        self.cursor = self.limit_backward
        return True

    def __r_remove_um(self):
        # (, line 199
        # unset found_a_match, line 200
        self.B_found_a_match = False
        # call has_min_length, line 201
        if not self.__r_has_min_length():
            return False
        # backwards, line 202
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 202
        # [, line 202
        self.ket = self.cursor
        # literal, line 202
        if not self.eq_s_b(u"\u0BC1\u0BAE\u0BCD"):
            return False
        # ], line 202
        self.bra = self.cursor
        # <-, line 202
        if not self.slice_from(u"\u0BCD"):
            return False
        # (, line 203
        # set found_a_match, line 203
        self.B_found_a_match = True
        self.cursor = self.limit_backward
        # do, line 205
        v_1 = self.cursor
        # call fix_ending, line 205
        self.__r_fix_ending()
        self.cursor = v_1
        return True

    def __r_remove_common_word_endings(self):
        # (, line 208
        # unset found_a_match, line 212
        self.B_found_a_match = False
        # call has_min_length, line 213
        if not self.__r_has_min_length():
            return False
        # backwards, line 214
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 214
        # or, line 231
        try:
            v_1 = self.limit - self.cursor
            try:
                # test, line 215
                v_2 = self.limit - self.cursor
                # (, line 215
                # [, line 215
                self.ket = self.cursor
                # or, line 215
                try:
                    v_3 = self.limit - self.cursor
                    try:
                        # literal, line 215
                        if not self.eq_s_b(u"\u0BC1\u0B9F\u0BA9\u0BCD"):
                            raise lab3()
                        raise lab2()
                    except lab3: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 216
                        if not self.eq_s_b(u"\u0BBF\u0BB2\u0BCD\u0BB2\u0BC8"):
                            raise lab4()
                        raise lab2()
                    except lab4: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 217
                        if not self.eq_s_b(u"\u0BBF\u0B9F\u0BAE\u0BCD"):
                            raise lab5()
                        raise lab2()
                    except lab5: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 218
                        if not self.eq_s_b(u"\u0BBF\u0BA9\u0BCD\u0BB1\u0BBF"):
                            raise lab6()
                        raise lab2()
                    except lab6: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 219
                        if not self.eq_s_b(u"\u0BBE\u0B95\u0BBF"):
                            raise lab7()
                        raise lab2()
                    except lab7: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 220
                        if not self.eq_s_b(u"\u0BBE\u0B95\u0BBF\u0BAF"):
                            raise lab8()
                        raise lab2()
                    except lab8: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 221
                        if not self.eq_s_b(u"\u0BC6\u0BA9\u0BCD\u0BB1\u0BC1"):
                            raise lab9()
                        raise lab2()
                    except lab9: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 222
                        if not self.eq_s_b(u"\u0BC1\u0BB3\u0BCD\u0BB3"):
                            raise lab10()
                        raise lab2()
                    except lab10: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 223
                        if not self.eq_s_b(u"\u0BC1\u0B9F\u0BC8\u0BAF"):
                            raise lab11()
                        raise lab2()
                    except lab11: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 224
                        if not self.eq_s_b(u"\u0BC1\u0B9F\u0BC8"):
                            raise lab12()
                        raise lab2()
                    except lab12: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 225
                        if not self.eq_s_b(u"\u0BC6\u0BA9\u0BC1\u0BAE\u0BCD"):
                            raise lab13()
                        raise lab2()
                    except lab13: pass
                    self.cursor = self.limit - v_3
                    try:
                        # (, line 226
                        # literal, line 226
                        if not self.eq_s_b(u"\u0BB2\u0BCD\u0BB2"):
                            raise lab14()
                        # test, line 226
                        v_4 = self.limit - self.cursor
                        # (, line 226
                        # not, line 226
                        v_5 = self.limit - self.cursor
                        try:
                            # among, line 226
                            if self.find_among_b(TamilStemmer.a_16) == 0:
                                raise lab15()
                            raise lab14()
                        except lab15: pass
                        self.cursor = self.limit - v_5
                        self.cursor = self.limit - v_4
                        raise lab2()
                    except lab14: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 227
                        if not self.eq_s_b(u"\u0BC6\u0BA9"):
                            raise lab16()
                        raise lab2()
                    except lab16: pass
                    self.cursor = self.limit - v_3
                    # literal, line 228
                    if not self.eq_s_b(u"\u0BBE\u0B95\u0BBF"):
                        raise lab1()
                except lab2: pass
                # ], line 228
                self.bra = self.cursor
                # <-, line 228
                if not self.slice_from(u"\u0BCD"):
                    return False
                # (, line 229
                # set found_a_match, line 229
                self.B_found_a_match = True
                self.cursor = self.limit - v_2
                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            # test, line 232
            v_6 = self.limit - self.cursor
            # (, line 232
            # [, line 232
            self.ket = self.cursor
            # among, line 232
            if self.find_among_b(TamilStemmer.a_17) == 0:
                return False
            # ], line 245
            self.bra = self.cursor
            # delete, line 245
            if not self.slice_del():
                return False

            # (, line 246
            # set found_a_match, line 246
            self.B_found_a_match = True
            self.cursor = self.limit - v_6
        except lab0: pass
        self.cursor = self.limit_backward
        # do, line 249
        # call fix_endings, line 249
        self.__r_fix_endings()
        return True

    def __r_remove_vetrumai_urupukal(self):
        # (, line 252
        # unset found_a_match, line 253
        self.B_found_a_match = False
        # unset found_vetrumai_urupu, line 254
        self.B_found_vetrumai_urupu = False
        # call has_min_length, line 255
        if not self.__r_has_min_length():
            return False
        # backwards, line 256
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 256
        # (, line 257
        # or, line 259
        try:
            v_1 = self.limit - self.cursor
            try:
                # test, line 258
                v_2 = self.limit - self.cursor
                # (, line 258
                # [, line 258
                self.ket = self.cursor
                # literal, line 258
                if not self.eq_s_b(u"\u0BA9\u0BC8"):
                    raise lab1()
                # ], line 258
                self.bra = self.cursor
                # delete, line 258
                if not self.slice_del():
                    return False

                self.cursor = self.limit - v_2
                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            try:
                # test, line 260
                v_3 = self.limit - self.cursor
                # (, line 260
                # [, line 260
                self.ket = self.cursor
                # or, line 261
                try:
                    v_4 = self.limit - self.cursor
                    try:
                        # (, line 260
                        # or, line 260
                        try:
                            v_5 = self.limit - self.cursor
                            try:
                                # literal, line 260
                                if not self.eq_s_b(u"\u0BBF\u0BA9\u0BC8"):
                                    raise lab6()
                                raise lab5()
                            except lab6: pass
                            self.cursor = self.limit - v_5
                            # literal, line 261
                            if not self.eq_s_b(u"\u0BC8"):
                                raise lab4()
                        except lab5: pass
                        # (, line 261
                        # test, line 261
                        v_6 = self.limit - self.cursor
                        # not, line 261
                        v_7 = self.limit - self.cursor
                        try:
                            # among, line 261
                            if self.find_among_b(TamilStemmer.a_18) == 0:
                                raise lab7()
                            raise lab4()
                        except lab7: pass
                        self.cursor = self.limit - v_7
                        self.cursor = self.limit - v_6
                        raise lab3()
                    except lab4: pass
                    self.cursor = self.limit - v_4
                    # (, line 262
                    # literal, line 262
                    if not self.eq_s_b(u"\u0BC8"):
                        raise lab2()
                    # (, line 262
                    # test, line 262
                    v_8 = self.limit - self.cursor
                    # (, line 262
                    # among, line 262
                    if self.find_among_b(TamilStemmer.a_19) == 0:
                        raise lab2()
                    # literal, line 262
                    if not self.eq_s_b(u"\u0BCD"):
                        raise lab2()
                    self.cursor = self.limit - v_8
                except lab3: pass
                # ], line 263
                self.bra = self.cursor
                # <-, line 263
                if not self.slice_from(u"\u0BCD"):
                    return False
                self.cursor = self.limit - v_3
                raise lab0()
            except lab2: pass
            self.cursor = self.limit - v_1
            try:
                # test, line 266
                v_9 = self.limit - self.cursor
                # (, line 266
                # [, line 266
                self.ket = self.cursor
                # or, line 267
                try:
                    v_10 = self.limit - self.cursor
                    try:
                        # literal, line 267
                        if not self.eq_s_b(u"\u0BCA\u0B9F\u0BC1"):
                            raise lab10()
                        raise lab9()
                    except lab10: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 268
                        if not self.eq_s_b(u"\u0BCB\u0B9F\u0BC1"):
                            raise lab11()
                        raise lab9()
                    except lab11: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 269
                        if not self.eq_s_b(u"\u0BBF\u0BB2\u0BCD"):
                            raise lab12()
                        raise lab9()
                    except lab12: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 270
                        if not self.eq_s_b(u"\u0BBF\u0BB1\u0BCD"):
                            raise lab13()
                        raise lab9()
                    except lab13: pass
                    self.cursor = self.limit - v_10
                    try:
                        # (, line 271
                        # literal, line 271
                        if not self.eq_s_b(u"\u0BBF\u0BA9\u0BCD"):
                            raise lab14()
                        # (, line 271
                        # test, line 271
                        v_11 = self.limit - self.cursor
                        # not, line 271
                        v_12 = self.limit - self.cursor
                        try:
                            # literal, line 271
                            if not self.eq_s_b(u"\u0BAE"):
                                raise lab15()
                            raise lab14()
                        except lab15: pass
                        self.cursor = self.limit - v_12
                        self.cursor = self.limit - v_11
                        raise lab9()
                    except lab14: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 272
                        if not self.eq_s_b(u"\u0BBF\u0BA9\u0BCD\u0BB1\u0BC1"):
                            raise lab16()
                        raise lab9()
                    except lab16: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 273
                        if not self.eq_s_b(u"\u0BBF\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4\u0BC1"):
                            raise lab17()
                        raise lab9()
                    except lab17: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 274
                        if not self.eq_s_b(u"\u0BB5\u0BBF\u0B9F"):
                            raise lab18()
                        raise lab9()
                    except lab18: pass
                    self.cursor = self.limit - v_10
                    try:
                        # (, line 275
                        if not len(self.current) >= 7:
                            raise lab19()
                        # literal, line 275
                        if not self.eq_s_b(u"\u0BBF\u0B9F\u0BAE\u0BCD"):
                            raise lab19()
                        raise lab9()
                    except lab19: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 276
                        if not self.eq_s_b(u"\u0BBE\u0BB2\u0BCD"):
                            raise lab20()
                        raise lab9()
                    except lab20: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 277
                        if not self.eq_s_b(u"\u0BC1\u0B9F\u0BC8"):
                            raise lab21()
                        raise lab9()
                    except lab21: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 278
                        if not self.eq_s_b(u"\u0BBE\u0BAE\u0BB2\u0BCD"):
                            raise lab22()
                        raise lab9()
                    except lab22: pass
                    self.cursor = self.limit - v_10
                    try:
                        # (, line 279
                        # literal, line 279
                        if not self.eq_s_b(u"\u0BB2\u0BCD"):
                            raise lab23()
                        # (, line 279
                        # test, line 279
                        v_13 = self.limit - self.cursor
                        # not, line 279
                        v_14 = self.limit - self.cursor
                        try:
                            # among, line 279
                            if self.find_among_b(TamilStemmer.a_20) == 0:
                                raise lab24()
                            raise lab23()
                        except lab24: pass
                        self.cursor = self.limit - v_14
                        self.cursor = self.limit - v_13
                        raise lab9()
                    except lab23: pass
                    self.cursor = self.limit - v_10
                    # literal, line 280
                    if not self.eq_s_b(u"\u0BC1\u0BB3\u0BCD"):
                        raise lab8()
                except lab9: pass
                # ], line 281
                self.bra = self.cursor
                # <-, line 281
                if not self.slice_from(u"\u0BCD"):
                    return False
                self.cursor = self.limit - v_9
                raise lab0()
            except lab8: pass
            self.cursor = self.limit - v_1
            try:
                # test, line 284
                v_15 = self.limit - self.cursor
                # (, line 284
                # [, line 284
                self.ket = self.cursor
                # or, line 285
                try:
                    v_16 = self.limit - self.cursor
                    try:
                        # literal, line 285
                        if not self.eq_s_b(u"\u0B95\u0BA3\u0BCD"):
                            raise lab27()
                        raise lab26()
                    except lab27: pass
                    self.cursor = self.limit - v_16
                    try:
                        # literal, line 286
                        if not self.eq_s_b(u"\u0BAE\u0BC1\u0BA9\u0BCD"):
                            raise lab28()
                        raise lab26()
                    except lab28: pass
                    self.cursor = self.limit - v_16
                    try:
                        # literal, line 287
                        if not self.eq_s_b(u"\u0BAE\u0BC7\u0BB2\u0BCD"):
                            raise lab29()
                        raise lab26()
                    except lab29: pass
                    self.cursor = self.limit - v_16
                    try:
                        # literal, line 288
                        if not self.eq_s_b(u"\u0BAE\u0BC7\u0BB1\u0BCD"):
                            raise lab30()
                        raise lab26()
                    except lab30: pass
                    self.cursor = self.limit - v_16
                    try:
                        # literal, line 289
                        if not self.eq_s_b(u"\u0B95\u0BC0\u0BB4\u0BCD"):
                            raise lab31()
                        raise lab26()
                    except lab31: pass
                    self.cursor = self.limit - v_16
                    try:
                        # literal, line 290
                        if not self.eq_s_b(u"\u0BAA\u0BBF\u0BA9\u0BCD"):
                            raise lab32()
                        raise lab26()
                    except lab32: pass
                    self.cursor = self.limit - v_16
                    # (, line 291
                    # literal, line 291
                    if not self.eq_s_b(u"\u0BA4\u0BC1"):
                        raise lab25()
                    # (, line 291
                    # test, line 291
                    v_17 = self.limit - self.cursor
                    # not, line 291
                    v_18 = self.limit - self.cursor
                    try:
                        # among, line 291
                        if self.find_among_b(TamilStemmer.a_21) == 0:
                            raise lab33()
                        raise lab25()
                    except lab33: pass
                    self.cursor = self.limit - v_18
                    self.cursor = self.limit - v_17
                except lab26: pass
                # ], line 292
                self.bra = self.cursor
                # delete, line 292
                if not self.slice_del():
                    return False

                self.cursor = self.limit - v_15
                raise lab0()
            except lab25: pass
            self.cursor = self.limit - v_1
            # test, line 295
            v_19 = self.limit - self.cursor
            # (, line 295
            # [, line 295
            self.ket = self.cursor
            # literal, line 295
            if not self.eq_s_b(u"\u0BC0"):
                return False
            # ], line 295
            self.bra = self.cursor
            # <-, line 295
            if not self.slice_from(u"\u0BBF"):
                return False
            self.cursor = self.limit - v_19
        except lab0: pass
        # (, line 297
        # set found_a_match, line 297
        self.B_found_a_match = True
        # (, line 298
        # set found_vetrumai_urupu, line 298
        self.B_found_vetrumai_urupu = True
        # do, line 299
        v_20 = self.limit - self.cursor
        try:
            # (, line 299
            # [, line 299
            self.ket = self.cursor
            # literal, line 299
            if not self.eq_s_b(u"\u0BBF\u0BA9\u0BCD"):
                raise lab34()
            # ], line 299
            self.bra = self.cursor
            # <-, line 299
            if not self.slice_from(u"\u0BCD"):
                return False
        except lab34: pass
        self.cursor = self.limit - v_20
        self.cursor = self.limit_backward
        # do, line 301
        # call fix_endings, line 301
        self.__r_fix_endings()
        return True

    def __r_remove_tense_suffixes(self):
        # (, line 304
        # set found_a_match, line 305
        self.B_found_a_match = True
        # repeat, line 306
        while True:
            v_1 = self.cursor
            try:
                # (, line 306
                # Boolean test found_a_match, line 306
                if not self.B_found_a_match:
                    raise lab0()
                # (, line 306
                # do, line 306
                v_2 = self.cursor
                # call remove_tense_suffix, line 306
                self.__r_remove_tense_suffix()
                self.cursor = v_2
                continue
            except lab0: pass
            self.cursor = v_1
            break
        return True

    def __r_remove_tense_suffix(self):
        # (, line 309
        # unset found_a_match, line 310
        self.B_found_a_match = False
        # call has_min_length, line 311
        if not self.__r_has_min_length():
            return False
        # backwards, line 312
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 312
        # do, line 313
        v_1 = self.limit - self.cursor
        try:
            # (, line 313
            # or, line 320
            try:
                v_2 = self.limit - self.cursor
                try:
                    # test, line 314
                    v_3 = self.limit - self.cursor
                    # (, line 314
                    # [, line 314
                    self.ket = self.cursor
                    # among, line 314
                    if self.find_among_b(TamilStemmer.a_22) == 0:
                        raise lab2()
                    # ], line 317
                    self.bra = self.cursor
                    # delete, line 317
                    if not self.slice_del():
                        return False

                    # (, line 318
                    # set found_a_match, line 318
                    self.B_found_a_match = True
                    self.cursor = self.limit - v_3
                    raise lab1()
                except lab2: pass
                self.cursor = self.limit - v_2
                try:
                    # test, line 321
                    v_4 = self.limit - self.cursor
                    # (, line 321
                    # [, line 321
                    self.ket = self.cursor
                    # or, line 322
                    try:
                        v_5 = self.limit - self.cursor
                        try:
                            # literal, line 322
                            if not self.eq_s_b(u"\u0BAE\u0BBE\u0BB0\u0BCD"):
                                raise lab5()
                            raise lab4()
                        except lab5: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 323
                            if not self.eq_s_b(u"\u0BAE\u0BBF\u0BA9\u0BCD"):
                                raise lab6()
                            raise lab4()
                        except lab6: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 324
                            if not self.eq_s_b(u"\u0BA9\u0BA9\u0BCD"):
                                raise lab7()
                            raise lab4()
                        except lab7: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 325
                            if not self.eq_s_b(u"\u0BA9\u0BBE\u0BA9\u0BCD"):
                                raise lab8()
                            raise lab4()
                        except lab8: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 326
                            if not self.eq_s_b(u"\u0BA9\u0BBE\u0BB3\u0BCD"):
                                raise lab9()
                            raise lab4()
                        except lab9: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 327
                            if not self.eq_s_b(u"\u0BA9\u0BBE\u0BB0\u0BCD"):
                                raise lab10()
                            raise lab4()
                        except lab10: pass
                        self.cursor = self.limit - v_5
                        try:
                            # (, line 328
                            # literal, line 328
                            if not self.eq_s_b(u"\u0BB5\u0BA9\u0BCD"):
                                raise lab11()
                            # test, line 328
                            v_6 = self.limit - self.cursor
                            # (, line 328
                            # not, line 328
                            v_7 = self.limit - self.cursor
                            try:
                                # among, line 328
                                if self.find_among_b(TamilStemmer.a_23) == 0:
                                    raise lab12()
                                raise lab11()
                            except lab12: pass
                            self.cursor = self.limit - v_7
                            self.cursor = self.limit - v_6
                            raise lab4()
                        except lab11: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 329
                            if not self.eq_s_b(u"\u0BA9\u0BB3\u0BCD"):
                                raise lab13()
                            raise lab4()
                        except lab13: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 330
                            if not self.eq_s_b(u"\u0BB5\u0BB3\u0BCD"):
                                raise lab14()
                            raise lab4()
                        except lab14: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 331
                            if not self.eq_s_b(u"\u0BA9\u0BB0\u0BCD"):
                                raise lab15()
                            raise lab4()
                        except lab15: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 332
                            if not self.eq_s_b(u"\u0BB5\u0BB0\u0BCD"):
                                raise lab16()
                            raise lab4()
                        except lab16: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 333
                            if not self.eq_s_b(u"\u0BA9"):
                                raise lab17()
                            raise lab4()
                        except lab17: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 333
                            if not self.eq_s_b(u"\u0BAA"):
                                raise lab18()
                            raise lab4()
                        except lab18: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 333
                            if not self.eq_s_b(u"\u0B95"):
                                raise lab19()
                            raise lab4()
                        except lab19: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 333
                            if not self.eq_s_b(u"\u0BA4"):
                                raise lab20()
                            raise lab4()
                        except lab20: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 333
                            if not self.eq_s_b(u"\u0BAF"):
                                raise lab21()
                            raise lab4()
                        except lab21: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 334
                            if not self.eq_s_b(u"\u0BAA\u0BA9\u0BCD"):
                                raise lab22()
                            raise lab4()
                        except lab22: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 335
                            if not self.eq_s_b(u"\u0BAA\u0BB3\u0BCD"):
                                raise lab23()
                            raise lab4()
                        except lab23: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 336
                            if not self.eq_s_b(u"\u0BAA\u0BB0\u0BCD"):
                                raise lab24()
                            raise lab4()
                        except lab24: pass
                        self.cursor = self.limit - v_5
                        try:
                            # (, line 337
                            # literal, line 337
                            if not self.eq_s_b(u"\u0BA4\u0BC1"):
                                raise lab25()
                            # (, line 337
                            # test, line 337
                            v_8 = self.limit - self.cursor
                            # not, line 337
                            v_9 = self.limit - self.cursor
                            try:
                                # among, line 337
                                if self.find_among_b(TamilStemmer.a_24) == 0:
                                    raise lab26()
                                raise lab25()
                            except lab26: pass
                            self.cursor = self.limit - v_9
                            self.cursor = self.limit - v_8
                            raise lab4()
                        except lab25: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 338
                            if not self.eq_s_b(u"\u0BBF\u0BB1\u0BCD\u0BB1\u0BC1"):
                                raise lab27()
                            raise lab4()
                        except lab27: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 339
                            if not self.eq_s_b(u"\u0BAA\u0BAE\u0BCD"):
                                raise lab28()
                            raise lab4()
                        except lab28: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 340
                            if not self.eq_s_b(u"\u0BA9\u0BAE\u0BCD"):
                                raise lab29()
                            raise lab4()
                        except lab29: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 341
                            if not self.eq_s_b(u"\u0BA4\u0BC1\u0BAE\u0BCD"):
                                raise lab30()
                            raise lab4()
                        except lab30: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 342
                            if not self.eq_s_b(u"\u0BB1\u0BC1\u0BAE\u0BCD"):
                                raise lab31()
                            raise lab4()
                        except lab31: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 343
                            if not self.eq_s_b(u"\u0B95\u0BC1\u0BAE\u0BCD"):
                                raise lab32()
                            raise lab4()
                        except lab32: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 344
                            if not self.eq_s_b(u"\u0BA9\u0BC6\u0BA9\u0BCD"):
                                raise lab33()
                            raise lab4()
                        except lab33: pass
                        self.cursor = self.limit - v_5
                        try:
                            # literal, line 345
                            if not self.eq_s_b(u"\u0BA9\u0BC8"):
                                raise lab34()
                            raise lab4()
                        except lab34: pass
                        self.cursor = self.limit - v_5
                        # literal, line 346
                        if not self.eq_s_b(u"\u0BB5\u0BC8"):
                            raise lab3()
                    except lab4: pass
                    # ], line 347
                    self.bra = self.cursor
                    # delete, line 347
                    if not self.slice_del():
                        return False

                    # (, line 348
                    # set found_a_match, line 348
                    self.B_found_a_match = True
                    self.cursor = self.limit - v_4
                    raise lab1()
                except lab3: pass
                self.cursor = self.limit - v_2
                try:
                    # test, line 351
                    v_10 = self.limit - self.cursor
                    # (, line 351
                    # [, line 351
                    self.ket = self.cursor
                    # or, line 352
                    try:
                        v_11 = self.limit - self.cursor
                        try:
                            # (, line 352
                            # literal, line 352
                            if not self.eq_s_b(u"\u0BBE\u0BA9\u0BCD"):
                                raise lab37()
                            # test, line 352
                            v_12 = self.limit - self.cursor
                            # (, line 352
                            # not, line 352
                            v_13 = self.limit - self.cursor
                            try:
                                # literal, line 352
                                if not self.eq_s_b(u"\u0B9A"):
                                    raise lab38()
                                raise lab37()
                            except lab38: pass
                            self.cursor = self.limit - v_13
                            self.cursor = self.limit - v_12
                            raise lab36()
                        except lab37: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 353
                            if not self.eq_s_b(u"\u0BBE\u0BB3\u0BCD"):
                                raise lab39()
                            raise lab36()
                        except lab39: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 354
                            if not self.eq_s_b(u"\u0BBE\u0BB0\u0BCD"):
                                raise lab40()
                            raise lab36()
                        except lab40: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 355
                            if not self.eq_s_b(u"\u0BC7\u0BA9\u0BCD"):
                                raise lab41()
                            raise lab36()
                        except lab41: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 356
                            if not self.eq_s_b(u"\u0BBE"):
                                raise lab42()
                            raise lab36()
                        except lab42: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 357
                            if not self.eq_s_b(u"\u0BBE\u0BAE\u0BCD"):
                                raise lab43()
                            raise lab36()
                        except lab43: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 358
                            if not self.eq_s_b(u"\u0BC6\u0BAE\u0BCD"):
                                raise lab44()
                            raise lab36()
                        except lab44: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 359
                            if not self.eq_s_b(u"\u0BC7\u0BAE\u0BCD"):
                                raise lab45()
                            raise lab36()
                        except lab45: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 360
                            if not self.eq_s_b(u"\u0BCB\u0BAE\u0BCD"):
                                raise lab46()
                            raise lab36()
                        except lab46: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 361
                            if not self.eq_s_b(u"\u0B95\u0BC1\u0BAE\u0BCD"):
                                raise lab47()
                            raise lab36()
                        except lab47: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 362
                            if not self.eq_s_b(u"\u0BA4\u0BC1\u0BAE\u0BCD"):
                                raise lab48()
                            raise lab36()
                        except lab48: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 363
                            if not self.eq_s_b(u"\u0B9F\u0BC1\u0BAE\u0BCD"):
                                raise lab49()
                            raise lab36()
                        except lab49: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 364
                            if not self.eq_s_b(u"\u0BB1\u0BC1\u0BAE\u0BCD"):
                                raise lab50()
                            raise lab36()
                        except lab50: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 365
                            if not self.eq_s_b(u"\u0BBE\u0BAF\u0BCD"):
                                raise lab51()
                            raise lab36()
                        except lab51: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 366
                            if not self.eq_s_b(u"\u0BA9\u0BC6\u0BA9\u0BCD"):
                                raise lab52()
                            raise lab36()
                        except lab52: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 367
                            if not self.eq_s_b(u"\u0BA9\u0BBF\u0BB0\u0BCD"):
                                raise lab53()
                            raise lab36()
                        except lab53: pass
                        self.cursor = self.limit - v_11
                        try:
                            # literal, line 368
                            if not self.eq_s_b(u"\u0BC0\u0BB0\u0BCD"):
                                raise lab54()
                            raise lab36()
                        except lab54: pass
                        self.cursor = self.limit - v_11
                        # literal, line 369
                        if not self.eq_s_b(u"\u0BC0\u0BAF\u0BB0\u0BCD"):
                            raise lab35()
                    except lab36: pass
                    # ], line 370
                    self.bra = self.cursor
                    # <-, line 370
                    if not self.slice_from(u"\u0BCD"):
                        return False
                    # (, line 371
                    # set found_a_match, line 371
                    self.B_found_a_match = True
                    self.cursor = self.limit - v_10
                    raise lab1()
                except lab35: pass
                self.cursor = self.limit - v_2
                # test, line 374
                v_14 = self.limit - self.cursor
                # (, line 374
                # (, line 374
                # [, line 374
                self.ket = self.cursor
                # or, line 374
                try:
                    v_15 = self.limit - self.cursor
                    try:
                        # literal, line 374
                        if not self.eq_s_b(u"\u0B95\u0BC1"):
                            raise lab56()
                        raise lab55()
                    except lab56: pass
                    self.cursor = self.limit - v_15
                    # literal, line 374
                    if not self.eq_s_b(u"\u0BA4\u0BC1"):
                        raise lab0()
                except lab55: pass
                # (, line 374
                # test, line 374
                v_16 = self.limit - self.cursor
                # literal, line 374
                if not self.eq_s_b(u"\u0BCD"):
                    raise lab0()
                self.cursor = self.limit - v_16
                # ], line 374
                self.bra = self.cursor
                # delete, line 374
                if not self.slice_del():
                    return False

                # (, line 375
                # set found_a_match, line 375
                self.B_found_a_match = True
                self.cursor = self.limit - v_14
            except lab1: pass
        except lab0: pass
        self.cursor = self.limit - v_1
        # do, line 378
        v_17 = self.limit - self.cursor
        try:
            # (, line 378
            # [, line 378
            self.ket = self.cursor
            # among, line 378
            if self.find_among_b(TamilStemmer.a_25) == 0:
                raise lab57()
            # ], line 385
            self.bra = self.cursor
            # delete, line 385
            if not self.slice_del():
                return False

            # (, line 386
            # set found_a_match, line 386
            self.B_found_a_match = True
        except lab57: pass
        self.cursor = self.limit - v_17
        self.cursor = self.limit_backward
        # do, line 389
        # call fix_endings, line 389
        self.__r_fix_endings()
        return True

    def _stem(self):
        # (, line 392
        # unset found_vetrumai_urupu, line 393
        self.B_found_vetrumai_urupu = False
        # do, line 394
        v_1 = self.cursor
        # call fix_ending, line 394
        self.__r_fix_ending()
        self.cursor = v_1
        # call has_min_length, line 395
        if not self.__r_has_min_length():
            return False
        # do, line 396
        v_2 = self.cursor
        # call remove_question_prefixes, line 396
        self.__r_remove_question_prefixes()
        self.cursor = v_2
        # do, line 397
        v_3 = self.cursor
        # call remove_pronoun_prefixes, line 397
        self.__r_remove_pronoun_prefixes()
        self.cursor = v_3
        # do, line 398
        v_4 = self.cursor
        # call remove_question_suffixes, line 398
        self.__r_remove_question_suffixes()
        self.cursor = v_4
        # do, line 399
        v_5 = self.cursor
        # call remove_um, line 399
        self.__r_remove_um()
        self.cursor = v_5
        # do, line 400
        v_6 = self.cursor
        # call remove_common_word_endings, line 400
        self.__r_remove_common_word_endings()
        self.cursor = v_6
        # do, line 401
        v_7 = self.cursor
        # call remove_vetrumai_urupukal, line 401
        self.__r_remove_vetrumai_urupukal()
        self.cursor = v_7
        # do, line 402
        v_8 = self.cursor
        # call remove_plural_suffix, line 402
        self.__r_remove_plural_suffix()
        self.cursor = v_8
        # do, line 403
        v_9 = self.cursor
        # call remove_command_suffixes, line 403
        self.__r_remove_command_suffixes()
        self.cursor = v_9
        # do, line 404
        v_10 = self.cursor
        # call remove_tense_suffixes, line 404
        self.__r_remove_tense_suffixes()
        self.cursor = v_10
        return True


class lab0(BaseException): pass


class lab1(BaseException): pass


class lab2(BaseException): pass


class lab3(BaseException): pass


class lab4(BaseException): pass


class lab5(BaseException): pass


class lab6(BaseException): pass


class lab7(BaseException): pass


class lab8(BaseException): pass


class lab9(BaseException): pass


class lab10(BaseException): pass


class lab11(BaseException): pass


class lab12(BaseException): pass


class lab13(BaseException): pass


class lab14(BaseException): pass


class lab15(BaseException): pass


class lab16(BaseException): pass


class lab17(BaseException): pass


class lab18(BaseException): pass


class lab19(BaseException): pass


class lab20(BaseException): pass


class lab21(BaseException): pass


class lab22(BaseException): pass


class lab23(BaseException): pass


class lab24(BaseException): pass


class lab25(BaseException): pass


class lab26(BaseException): pass


class lab27(BaseException): pass


class lab28(BaseException): pass


class lab29(BaseException): pass


class lab30(BaseException): pass


class lab31(BaseException): pass


class lab32(BaseException): pass


class lab33(BaseException): pass


class lab34(BaseException): pass


class lab35(BaseException): pass


class lab36(BaseException): pass


class lab37(BaseException): pass


class lab38(BaseException): pass


class lab39(BaseException): pass


class lab40(BaseException): pass


class lab41(BaseException): pass


class lab42(BaseException): pass


class lab43(BaseException): pass


class lab44(BaseException): pass


class lab45(BaseException): pass


class lab46(BaseException): pass


class lab47(BaseException): pass


class lab48(BaseException): pass


class lab49(BaseException): pass


class lab50(BaseException): pass


class lab51(BaseException): pass


class lab52(BaseException): pass


class lab53(BaseException): pass


class lab54(BaseException): pass


class lab55(BaseException): pass


class lab56(BaseException): pass


class lab57(BaseException): pass
