# This file automatically generated from the python code generator of
# snowball project at  https://github.com/shibukawa/snowball by Yoshiki Shibukawa
# using the Tamil stemmer description of Damodharan Rajalingam at https://github.com/rdamodharan/tamil-stemmer
#
# Copyright (c) 2013, Damodharan Rajalingam
#

# self file was generated automatically by the Snowball to Python interpreter

from .basestemmer import BaseStemmer
from .among import Among


class TamilStemmer(BaseStemmer):
    '''
    self class was automatically generated by a Snowball to Python interpreter
    It implements the stemming algorithm defined by a snowball script.
    '''
    serialVersionUID = 1

    g_q_suffixes = [1, 34]

    g_word_starter = [49, 130, 40, 6, 1]

    g_suttezhuthu = [21]

    g_vallinam = [33, 132, 32, 16]

    g_mellinam = [33, 132, 33]

    g_itaiyinam = [123]

    g_vowel_signs = [31, 7]

    g_uyir = [63, 238]

    I_length = 0
    B_was_stripped = False
    B_found_wrong_ending = False
    B_found_vetrumai_urupu = False
    B_found_a_match = False
    B_found_vallinam_doubling = False
    I_mark2 = 0
    I_mark = 0

    def copy_from(self, other):
        self.I_length = other.I_length
        self.B_was_stripped = other.B_was_stripped
        self.B_found_wrong_ending = other.B_found_wrong_ending
        self.B_found_vetrumai_urupu = other.B_found_vetrumai_urupu
        self.B_found_a_match = other.B_found_a_match
        self.B_found_vallinam_doubling = other.B_found_vallinam_doubling
        self.I_mark2 = other.I_mark2
        self.I_mark = other.I_mark
        super.copy_from(other)
    

    def r_strlen(self):
        # (, line 130
        self.I_length = 0;
        # do, line 134
        v_1 = self.cursor
        try:
            # repeat, line 134
            try:
                while True:
                    try:
                        try:
                            # (, line 134
                            # next, line 134
                            if self.cursor >= self.limit:
                                raise lab3()
                            self.cursor += 1
                            # (, line 134
                            self.I_length = (self.I_length + 1);
                            raise lab2()
                        except lab3: pass
                        raise lab1()
                    except lab2: pass
            except lab1: pass
        except lab0: pass
        self.cursor = v_1
        return True

    def r_has_min_length(self):
        # (, line 136
        # call strlen, line 137
        if not self.r_strlen():
            return False
        if not self.I_length > 4:
            return False
        return True

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

    def r_fix_endings(self):
        # (, line 146
        # set found_wrong_ending, line 147
        self.B_found_wrong_ending = True
        # repeat, line 148
        try:
            while True:
                try:
                    v_1 = self.cursor
                    try:
                        # (, line 148
                        # Boolean test found_wrong_ending, line 148
                        if not self.B_found_wrong_ending:
                            raise lab2()
                        # (, line 148
                        # do, line 148
                        v_2 = self.cursor
                        try:
                            # call fix_ending, line 148
                            if not self.r_fix_ending():
                                raise lab3()
                        except lab3: pass
                        self.cursor = v_2
                        raise lab1()
                    except lab2: pass
                    self.cursor = v_1
                    raise lab0()
                except lab1: pass
        except lab0: pass
        return True

    def r_remove_question_prefixes(self):
        # (, line 150
        # [, line 151
        self.bra = self.cursor
        # (, line 151
        # literal, line 151
        if not self.eq_s(1, u"\u0B8E"):
            return False
        # (, line 151
        # or, line 151
        try:
            v_1 = self.cursor
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0B95"):
                    raise lab1()
                raise lab0()
            except lab1: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0B9A"):
                    raise lab2()
                raise lab0()
            except lab2: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0BA4"):
                    raise lab3()
                raise lab0()
            except lab3: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0BB5"):
                    raise lab4()
                raise lab0()
            except lab4: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0BA8"):
                    raise lab5()
                raise lab0()
            except lab5: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0BAA"):
                    raise lab6()
                raise lab0()
            except lab6: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0BAE"):
                    raise lab7()
                raise lab0()
            except lab7: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0BAF"):
                    raise lab8()
                raise lab0()
            except lab8: pass
            self.cursor = v_1
            try:
                # literal, line 151
                if not self.eq_s(1, u"\u0B99"):
                    raise lab9()
                raise lab0()
            except lab9: pass
            self.cursor = v_1
            # literal, line 151
            if not self.eq_s(1, u"\u0B9E"):
                return False
        except lab0: pass
        # literal, line 151
        if not self.eq_s(1, u"\u0BCD"):
            return False
        # ], line 151
        self.ket = self.cursor
        # delete, line 151
        if not self.slice_del():
            return False

        # do, line 152
        v_2 = self.cursor
        try:
            # call fix_va_start, line 152
            if not self.r_fix_va_start():
                raise lab10()
        except lab10: pass
        self.cursor = v_2
        return True

    def r_fix_ending(self):
        # (, line 154
        # unset found_wrong_ending, line 155
        self.B_found_wrong_ending = False
        # call strlen, line 156
        if not self.r_strlen():
            return False
        if not self.I_length > 3:
            return False
        # backwards, line 158
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 158
        # or, line 160
        try:
            v_1 = self.limit - self.cursor
            try:
                # (, line 159
                # [, line 159
                self.ket = self.cursor
                # or, line 159
                try:
                    v_2 = self.limit - self.cursor
                    try:
                        # literal, line 159
                        if not self.eq_s_b(2, u"\u0BA8\u0BCD"):
                            raise lab3()
                        raise lab2()
                    except lab3: pass
                    self.cursor = self.limit - v_2
                    try:
                        # literal, line 159
                        if not self.eq_s_b(3, u"\u0BA8\u0BCD\u0BA4"):
                            raise lab4()
                        raise lab2()
                    except lab4: pass
                    self.cursor = self.limit - v_2
                    # literal, line 159
                    if not self.eq_s_b(4, u"\u0BA8\u0BCD\u0BA4\u0BCD"):
                        raise lab1()
                except lab2: pass
                # ], line 159
                self.bra = self.cursor
                # delete, line 159
                if not self.slice_del():
                    return False

                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 161
                # [, line 161
                self.ket = self.cursor
                # literal, line 161
                if not self.eq_s_b(2, u"\u0BAF\u0BCD"):
                    raise lab5()
                # test, line 161
                v_3 = self.limit - self.cursor
                # (, line 161
                # or, line 161
                try:
                    v_4 = self.limit - self.cursor
                    try:
                        # literal, line 161
                        if not self.eq_s_b(1, u"\u0BC8"):
                            raise lab7()
                        raise lab6()
                    except lab7: pass
                    self.cursor = self.limit - v_4
                    try:
                        # literal, line 161
                        if not self.eq_s_b(1, u"\u0BBF"):
                            raise lab8()
                        raise lab6()
                    except lab8: pass
                    self.cursor = self.limit - v_4
                    # literal, line 161
                    if not self.eq_s_b(1, u"\u0BC0"):
                        raise lab5()
                except lab6: pass
                self.cursor = self.limit - v_3
                # ], line 161
                self.bra = self.cursor
                # delete, line 161
                if not self.slice_del():
                    return False

                raise lab0()
            except lab5: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 163
                # [, line 163
                self.ket = self.cursor
                # or, line 163
                try:
                    v_5 = self.limit - self.cursor
                    try:
                        # literal, line 163
                        if not self.eq_s_b(4, u"\u0B9F\u0BCD\u0BAA\u0BCD"):
                            raise lab11()
                        raise lab10()
                    except lab11: pass
                    self.cursor = self.limit - v_5
                    # literal, line 163
                    if not self.eq_s_b(4, u"\u0B9F\u0BCD\u0B95\u0BCD"):
                        raise lab9()
                except lab10: pass
                # ], line 163
                self.bra = self.cursor
                # <-, line 163
                if not self.slice_from(u"\u0BB3\u0BCD"):
                    return False
                raise lab0()
            except lab9: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 165
                # [, line 165
                self.ket = self.cursor
                # literal, line 165
                if not self.eq_s_b(4, u"\u0BA9\u0BCD\u0BB1\u0BCD"):
                    raise lab12()
                # ], line 165
                self.bra = self.cursor
                # <-, line 165
                if not self.slice_from(u"\u0BB2\u0BCD"):
                    return False
                raise lab0()
            except lab12: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 168
                # [, line 168
                self.ket = self.cursor
                # literal, line 168
                if not self.eq_s_b(4, u"\u0BB1\u0BCD\u0B95\u0BCD"):
                    raise lab13()
                # ], line 168
                self.bra = self.cursor
                # <-, line 168
                if not self.slice_from(u"\u0BB2\u0BCD"):
                    return False
                raise lab0()
            except lab13: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 170
                # [, line 170
                self.ket = self.cursor
                # literal, line 170
                if not self.eq_s_b(4, u"\u0B9F\u0BCD\u0B9F\u0BCD"):
                    raise lab14()
                # ], line 170
                self.bra = self.cursor
                # <-, line 170
                if not self.slice_from(u"\u0B9F\u0BC1"):
                    return False
                raise lab0()
            except lab14: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 172
                # Boolean test found_vetrumai_urupu, line 172
                if not self.B_found_vetrumai_urupu:
                    raise lab15()
                # [, line 172
                self.ket = self.cursor
                # literal, line 172
                if not self.eq_s_b(4, u"\u0BA4\u0BCD\u0BA4\u0BCD"):
                    raise lab15()
                # (, line 172
                # test, line 172
                v_6 = self.limit - self.cursor
                # not, line 172
                v_7 = self.limit - self.cursor
                try:
                    # literal, line 172
                    if not self.eq_s_b(1, u"\u0BC8"):
                        raise lab16()
                    raise lab15()
                except lab16: pass
                self.cursor = self.limit - v_7
                self.cursor = self.limit - v_6
                # ], line 172
                self.bra = self.cursor
                # <-, line 172
                if not self.slice_from(u"\u0BAE\u0BCD"):
                    return False
                # ], line 172
                self.bra = self.cursor
                raise lab0()
            except lab15: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 174
                # [, line 174
                self.ket = self.cursor
                # or, line 174
                try:
                    v_8 = self.limit - self.cursor
                    try:
                        # literal, line 174
                        if not self.eq_s_b(3, u"\u0BC1\u0B95\u0BCD"):
                            raise lab19()
                        raise lab18()
                    except lab19: pass
                    self.cursor = self.limit - v_8
                    # literal, line 174
                    if not self.eq_s_b(5, u"\u0BC1\u0B95\u0BCD\u0B95\u0BCD"):
                        raise lab17()
                except lab18: pass
                # ], line 174
                self.bra = self.cursor
                # <-, line 174
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab17: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 176
                # [, line 176
                self.ket = self.cursor
                # literal, line 176
                if not self.eq_s_b(1, u"\u0BCD"):
                    raise lab20()
                # (, line 176
                # or, line 176
                try:
                    v_9 = self.limit - self.cursor
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0B95"):
                            raise lab22()
                        raise lab21()
                    except lab22: pass
                    self.cursor = self.limit - v_9
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0B9A"):
                            raise lab23()
                        raise lab21()
                    except lab23: pass
                    self.cursor = self.limit - v_9
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0B9F"):
                            raise lab24()
                        raise lab21()
                    except lab24: pass
                    self.cursor = self.limit - v_9
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0BA4"):
                            raise lab25()
                        raise lab21()
                    except lab25: pass
                    self.cursor = self.limit - v_9
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0BAA"):
                            raise lab26()
                        raise lab21()
                    except lab26: pass
                    self.cursor = self.limit - v_9
                    # literal, line 176
                    if not self.eq_s_b(1, u"\u0BB1"):
                        raise lab20()
                except lab21: pass
                # literal, line 176
                if not self.eq_s_b(1, u"\u0BCD"):
                    raise lab20()
                # (, line 176
                # or, line 176
                try:
                    v_10 = self.limit - self.cursor
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0B95"):
                            raise lab28()
                        raise lab27()
                    except lab28: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0B9A"):
                            raise lab29()
                        raise lab27()
                    except lab29: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0B9F"):
                            raise lab30()
                        raise lab27()
                    except lab30: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0BA4"):
                            raise lab31()
                        raise lab27()
                    except lab31: pass
                    self.cursor = self.limit - v_10
                    try:
                        # literal, line 176
                        if not self.eq_s_b(1, u"\u0BAA"):
                            raise lab32()
                        raise lab27()
                    except lab32: pass
                    self.cursor = self.limit - v_10
                    # literal, line 176
                    if not self.eq_s_b(1, u"\u0BB1"):
                        raise lab20()
                except lab27: pass
                # ], line 176
                self.bra = self.cursor
                # delete, line 176
                if not self.slice_del():
                    return False

                raise lab0()
            except lab20: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 178
                # [, line 178
                self.ket = self.cursor
                # literal, line 178
                if not self.eq_s_b(3, u"\u0BC1\u0B95\u0BCD"):
                    raise lab33()
                # ], line 178
                self.bra = self.cursor
                # <-, line 178
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab33: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 180
                # [, line 180
                self.ket = self.cursor
                # literal, line 180
                if not self.eq_s_b(1, u"\u0BCD"):
                    raise lab34()
                # (, line 180
                # or, line 180
                try:
                    v_11 = self.limit - self.cursor
                    try:
                        # literal, line 180
                        if not self.eq_s_b(1, u"\u0B95"):
                            raise lab36()
                        raise lab35()
                    except lab36: pass
                    self.cursor = self.limit - v_11
                    try:
                        # literal, line 180
                        if not self.eq_s_b(1, u"\u0B9A"):
                            raise lab37()
                        raise lab35()
                    except lab37: pass
                    self.cursor = self.limit - v_11
                    try:
                        # literal, line 180
                        if not self.eq_s_b(1, u"\u0B9F"):
                            raise lab38()
                        raise lab35()
                    except lab38: pass
                    self.cursor = self.limit - v_11
                    try:
                        # literal, line 180
                        if not self.eq_s_b(1, u"\u0BA4"):
                            raise lab39()
                        raise lab35()
                    except lab39: pass
                    self.cursor = self.limit - v_11
                    try:
                        # literal, line 180
                        if not self.eq_s_b(1, u"\u0BAA"):
                            raise lab40()
                        raise lab35()
                    except lab40: pass
                    self.cursor = self.limit - v_11
                    # literal, line 180
                    if not self.eq_s_b(1, u"\u0BB1"):
                        raise lab34()
                except lab35: pass
                # ], line 180
                self.bra = self.cursor
                # delete, line 180
                if not self.slice_del():
                    return False

                raise lab0()
            except lab34: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 182
                # [, line 182
                self.ket = self.cursor
                # literal, line 182
                if not self.eq_s_b(1, u"\u0BCD"):
                    raise lab41()
                # (, line 182
                # or, line 182
                try:
                    v_12 = self.limit - self.cursor
                    try:
                        # (, line 182
                        # or, line 182
                        try:
                            v_13 = self.limit - self.cursor
                            try:
                                # literal, line 182
                                if not self.eq_s_b(1, u"\u0BAF"):
                                    raise lab45()
                                raise lab44()
                            except lab45: pass
                            self.cursor = self.limit - v_13
                            try:
                                # literal, line 182
                                if not self.eq_s_b(1, u"\u0BB0"):
                                    raise lab46()
                                raise lab44()
                            except lab46: pass
                            self.cursor = self.limit - v_13
                            try:
                                # literal, line 182
                                if not self.eq_s_b(1, u"\u0BB2"):
                                    raise lab47()
                                raise lab44()
                            except lab47: pass
                            self.cursor = self.limit - v_13
                            try:
                                # literal, line 182
                                if not self.eq_s_b(1, u"\u0BB5"):
                                    raise lab48()
                                raise lab44()
                            except lab48: pass
                            self.cursor = self.limit - v_13
                            try:
                                # literal, line 182
                                if not self.eq_s_b(1, u"\u0BB4"):
                                    raise lab49()
                                raise lab44()
                            except lab49: pass
                            self.cursor = self.limit - v_13
                            # literal, line 182
                            if not self.eq_s_b(1, u"\u0BB3"):
                                raise lab43()
                        except lab44: pass
                        raise lab42()
                    except lab43: pass
                    self.cursor = self.limit - v_12
                    # (, line 182
                    # or, line 182
                    try:
                        v_14 = self.limit - self.cursor
                        try:
                            # literal, line 182
                            if not self.eq_s_b(1, u"\u0B99"):
                                raise lab51()
                            raise lab50()
                        except lab51: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 182
                            if not self.eq_s_b(1, u"\u0B9E"):
                                raise lab52()
                            raise lab50()
                        except lab52: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 182
                            if not self.eq_s_b(1, u"\u0BA3"):
                                raise lab53()
                            raise lab50()
                        except lab53: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 182
                            if not self.eq_s_b(1, u"\u0BA8"):
                                raise lab54()
                            raise lab50()
                        except lab54: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 182
                            if not self.eq_s_b(1, u"\u0BAE"):
                                raise lab55()
                            raise lab50()
                        except lab55: pass
                        self.cursor = self.limit - v_14
                        # literal, line 182
                        if not self.eq_s_b(1, u"\u0BA9"):
                            raise lab41()
                    except lab50: pass
                except lab42: pass
                # literal, line 182
                if not self.eq_s_b(1, u"\u0BCD"):
                    raise lab41()
                # ], line 182
                self.bra = self.cursor
                # <-, line 182
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab41: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 184
                # [, line 184
                self.ket = self.cursor
                # or, line 184
                try:
                    v_15 = self.limit - self.cursor
                    try:
                        # literal, line 184
                        if not self.eq_s_b(1, u"\u0BB5"):
                            raise lab58()
                        raise lab57()
                    except lab58: pass
                    self.cursor = self.limit - v_15
                    try:
                        # literal, line 184
                        if not self.eq_s_b(1, u"\u0BAF"):
                            raise lab59()
                        raise lab57()
                    except lab59: pass
                    self.cursor = self.limit - v_15
                    # literal, line 184
                    if not self.eq_s_b(2, u"\u0BB5\u0BCD"):
                        raise lab56()
                except lab57: pass
                # ], line 184
                self.bra = self.cursor
                # delete, line 184
                if not self.slice_del():
                    return False

                raise lab0()
            except lab56: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 186
                # [, line 186
                self.ket = self.cursor
                # literal, line 186
                if not self.eq_s_b(2, u"\u0BA9\u0BC1"):
                    raise lab60()
                # (, line 186
                # test, line 186
                v_16 = self.limit - self.cursor
                # not, line 186
                v_17 = self.limit - self.cursor
                try:
                    # (, line 186
                    # or, line 186
                    try:
                        v_18 = self.limit - self.cursor
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BBE"):
                                raise lab63()
                            raise lab62()
                        except lab63: pass
                        self.cursor = self.limit - v_18
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BBF"):
                                raise lab64()
                            raise lab62()
                        except lab64: pass
                        self.cursor = self.limit - v_18
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BC0"):
                                raise lab65()
                            raise lab62()
                        except lab65: pass
                        self.cursor = self.limit - v_18
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BC6"):
                                raise lab66()
                            raise lab62()
                        except lab66: pass
                        self.cursor = self.limit - v_18
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BC7"):
                                raise lab67()
                            raise lab62()
                        except lab67: pass
                        self.cursor = self.limit - v_18
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BC1"):
                                raise lab68()
                            raise lab62()
                        except lab68: pass
                        self.cursor = self.limit - v_18
                        try:
                            # literal, line 186
                            if not self.eq_s_b(1, u"\u0BC2"):
                                raise lab69()
                            raise lab62()
                        except lab69: pass
                        self.cursor = self.limit - v_18
                        # literal, line 186
                        if not self.eq_s_b(1, u"\u0BC8"):
                            raise lab61()
                    except lab62: pass
                    raise lab60()
                except lab61: pass
                self.cursor = self.limit - v_17
                self.cursor = self.limit - v_16
                # ], line 186
                self.bra = self.cursor
                # delete, line 186
                if not self.slice_del():
                    return False

                raise lab0()
            except lab60: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 188
                # [, line 188
                self.ket = self.cursor
                # literal, line 188
                if not self.eq_s_b(2, u"\u0B99\u0BCD"):
                    raise lab70()
                # (, line 188
                # test, line 188
                v_19 = self.limit - self.cursor
                # not, line 188
                v_20 = self.limit - self.cursor
                try:
                    # literal, line 188
                    if not self.eq_s_b(1, u"\u0BC8"):
                        raise lab71()
                    raise lab70()
                except lab71: pass
                self.cursor = self.limit - v_20
                self.cursor = self.limit - v_19
                # ], line 188
                self.bra = self.cursor
                # <-, line 188
                if not self.slice_from(u"\u0BAE\u0BCD"):
                    return False
                raise lab0()
            except lab70: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 190
                # [, line 190
                self.ket = self.cursor
                # literal, line 190
                if not self.eq_s_b(2, u"\u0B99\u0BCD"):
                    raise lab72()
                # ], line 190
                self.bra = self.cursor
                # delete, line 190
                if not self.slice_del():
                    return False

                raise lab0()
            except lab72: pass
            self.cursor = self.limit - v_1
            # (, line 192
            # [, line 192
            self.ket = self.cursor
            # literal, line 192
            if not self.eq_s_b(1, u"\u0BCD"):
                return False
            # (, line 192
            # test, line 192
            v_21 = self.limit - self.cursor
            # (, line 192
            # or, line 192
            try:
                v_22 = self.limit - self.cursor
                try:
                    # (, line 192
                    # or, line 192
                    try:
                        v_23 = self.limit - self.cursor
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BBE"):
                                raise lab76()
                            raise lab75()
                        except lab76: pass
                        self.cursor = self.limit - v_23
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BBF"):
                                raise lab77()
                            raise lab75()
                        except lab77: pass
                        self.cursor = self.limit - v_23
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BC0"):
                                raise lab78()
                            raise lab75()
                        except lab78: pass
                        self.cursor = self.limit - v_23
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BC6"):
                                raise lab79()
                            raise lab75()
                        except lab79: pass
                        self.cursor = self.limit - v_23
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BC7"):
                                raise lab80()
                            raise lab75()
                        except lab80: pass
                        self.cursor = self.limit - v_23
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BC1"):
                                raise lab81()
                            raise lab75()
                        except lab81: pass
                        self.cursor = self.limit - v_23
                        try:
                            # literal, line 192
                            if not self.eq_s_b(1, u"\u0BC2"):
                                raise lab82()
                            raise lab75()
                        except lab82: pass
                        self.cursor = self.limit - v_23
                        # literal, line 192
                        if not self.eq_s_b(1, u"\u0BC8"):
                            raise lab74()
                    except lab75: pass
                    raise lab73()
                except lab74: pass
                self.cursor = self.limit - v_22
                # literal, line 192
                if not self.eq_s_b(1, u"\u0BCD"):
                    return False
            except lab73: pass
            self.cursor = self.limit - v_21
            # ], line 192
            self.bra = self.cursor
            # delete, line 192
            if not self.slice_del():
                return False

        except lab0: pass
        self.cursor = self.limit_backward
        # set found_wrong_ending, line 195
        self.B_found_wrong_ending = True
        return True

    def r_remove_pronoun_prefixes(self):
        # (, line 197
        # unset found_a_match, line 198
        self.B_found_a_match = False
        # [, line 199
        self.bra = self.cursor
        # (, line 199
        # or, line 199
        try:
            v_1 = self.cursor
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0B85"):
                    raise lab1()
                raise lab0()
            except lab1: pass
            self.cursor = v_1
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0B87"):
                    raise lab2()
                raise lab0()
            except lab2: pass
            self.cursor = v_1
            # literal, line 199
            if not self.eq_s(1, u"\u0B89"):
                return False
        except lab0: pass
        # (, line 199
        # or, line 199
        try:
            v_2 = self.cursor
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0B95"):
                    raise lab4()
                raise lab3()
            except lab4: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0B9A"):
                    raise lab5()
                raise lab3()
            except lab5: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0BA4"):
                    raise lab6()
                raise lab3()
            except lab6: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0BB5"):
                    raise lab7()
                raise lab3()
            except lab7: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0BA8"):
                    raise lab8()
                raise lab3()
            except lab8: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0BAA"):
                    raise lab9()
                raise lab3()
            except lab9: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0BAE"):
                    raise lab10()
                raise lab3()
            except lab10: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0BAF"):
                    raise lab11()
                raise lab3()
            except lab11: pass
            self.cursor = v_2
            try:
                # literal, line 199
                if not self.eq_s(1, u"\u0B99"):
                    raise lab12()
                raise lab3()
            except lab12: pass
            self.cursor = v_2
            # literal, line 199
            if not self.eq_s(1, u"\u0B9E"):
                return False
        except lab3: pass
        # literal, line 199
        if not self.eq_s(1, u"\u0BCD"):
            return False
        # ], line 199
        self.ket = self.cursor
        # delete, line 199
        if not self.slice_del():
            return False

        # (, line 200
        # set found_a_match, line 200
        self.B_found_a_match = True
        # do, line 201
        v_3 = self.cursor
        try:
            # call fix_va_start, line 201
            if not self.r_fix_va_start():
                raise lab13()
        except lab13: pass
        self.cursor = v_3
        return True

    def r_remove_plural_suffix(self):
        # (, line 203
        # unset found_a_match, line 204
        self.B_found_a_match = False
        # backwards, line 205
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 205
        # or, line 206
        try:
            v_1 = self.limit - self.cursor
            try:
                # (, line 206
                # [, line 206
                self.ket = self.cursor
                # literal, line 206
                if not self.eq_s_b(6, u"\u0BC1\u0B99\u0BCD\u0B95\u0BB3\u0BCD"):
                    raise lab1()
                # (, line 206
                # test, line 206
                v_2 = self.limit - self.cursor
                # not, line 206
                v_3 = self.limit - self.cursor
                try:
                    # (, line 206
                    # or, line 206
                    try:
                        v_4 = self.limit - self.cursor
                        try:
                            # literal, line 206
                            if not self.eq_s_b(1, u"\u0B95"):
                                raise lab4()
                            raise lab3()
                        except lab4: pass
                        self.cursor = self.limit - v_4
                        try:
                            # literal, line 206
                            if not self.eq_s_b(1, u"\u0B9A"):
                                raise lab5()
                            raise lab3()
                        except lab5: pass
                        self.cursor = self.limit - v_4
                        try:
                            # literal, line 206
                            if not self.eq_s_b(1, u"\u0B9F"):
                                raise lab6()
                            raise lab3()
                        except lab6: pass
                        self.cursor = self.limit - v_4
                        try:
                            # literal, line 206
                            if not self.eq_s_b(1, u"\u0BA4"):
                                raise lab7()
                            raise lab3()
                        except lab7: pass
                        self.cursor = self.limit - v_4
                        try:
                            # literal, line 206
                            if not self.eq_s_b(1, u"\u0BAA"):
                                raise lab8()
                            raise lab3()
                        except lab8: pass
                        self.cursor = self.limit - v_4
                        # literal, line 206
                        if not self.eq_s_b(1, u"\u0BB1"):
                            raise lab2()
                    except lab3: pass
                    raise lab1()
                except lab2: pass
                self.cursor = self.limit - v_3
                self.cursor = self.limit - v_2
                # ], line 206
                self.bra = self.cursor
                # <-, line 206
                if not self.slice_from(u"\u0BCD"):
                    return False
                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 207
                # [, line 207
                self.ket = self.cursor
                # literal, line 207
                if not self.eq_s_b(5, u"\u0BB1\u0BCD\u0B95\u0BB3\u0BCD"):
                    raise lab9()
                # ], line 207
                self.bra = self.cursor
                # <-, line 207
                if not self.slice_from(u"\u0BB2\u0BCD"):
                    return False
                raise lab0()
            except lab9: pass
            self.cursor = self.limit - v_1
            try:
                # (, line 208
                # [, line 208
                self.ket = self.cursor
                # literal, line 208
                if not self.eq_s_b(5, u"\u0B9F\u0BCD\u0B95\u0BB3\u0BCD"):
                    raise lab10()
                # ], line 208
                self.bra = self.cursor
                # <-, line 208
                if not self.slice_from(u"\u0BB3\u0BCD"):
                    return False
                raise lab0()
            except lab10: pass
            self.cursor = self.limit - v_1
            # (, line 209
            # [, line 209
            self.ket = self.cursor
            # literal, line 209
            if not self.eq_s_b(3, u"\u0B95\u0BB3\u0BCD"):
                return False
            # ], line 209
            self.bra = self.cursor
            # delete, line 209
            if not self.slice_del():
                return False

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

    def r_remove_question_suffixes(self):
        # (, line 214
        # call has_min_length, line 215
        if not self.r_has_min_length():
            return False
        # unset found_a_match, line 216
        self.B_found_a_match = False
        # backwards, line 217
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 217
        # do, line 218
        v_1 = self.limit - self.cursor
        try:
            # (, line 218
            # [, line 219
            self.ket = self.cursor
            # (, line 219
            # or, line 219
            try:
                v_2 = self.limit - self.cursor
                try:
                    # literal, line 219
                    if not self.eq_s_b(1, u"\u0BCB"):
                        raise lab2()
                    raise lab1()
                except lab2: pass
                self.cursor = self.limit - v_2
                try:
                    # literal, line 219
                    if not self.eq_s_b(1, u"\u0BC7"):
                        raise lab3()
                    raise lab1()
                except lab3: pass
                self.cursor = self.limit - v_2
                # literal, line 219
                if not self.eq_s_b(1, u"\u0BBE"):
                    raise lab0()
            except lab1: pass
            # ], line 219
            self.bra = self.cursor
            # <-, line 219
            if not self.slice_from(u"\u0BCD"):
                return False
            # (, line 220
            # set found_a_match, line 220
            self.B_found_a_match = True
        except lab0: pass
        self.cursor = self.limit - v_1
        self.cursor = self.limit_backward
        # do, line 224
        v_3 = self.cursor
        try:
            # call fix_endings, line 224
            if not self.r_fix_endings():
                raise lab4()
        except lab4: pass
        self.cursor = v_3
        return True

    def r_remove_command_suffixes(self):
        # (, line 226
        # call has_min_length, line 227
        if not self.r_has_min_length():
            return False
        # unset found_a_match, line 228
        self.B_found_a_match = False
        # backwards, line 229
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 229
        # [, line 230
        self.ket = self.cursor
        # (, line 230
        # or, line 230
        try:
            v_1 = self.limit - self.cursor
            try:
                # literal, line 230
                if not self.eq_s_b(2, u"\u0BAA\u0BBF"):
                    raise lab1()
                raise lab0()
            except lab1: pass
            self.cursor = self.limit - v_1
            # literal, line 230
            if not self.eq_s_b(2, u"\u0BB5\u0BBF"):
                return False
        except lab0: pass
        # ], line 230
        self.bra = self.cursor
        # delete, line 230
        if not self.slice_del():
            return False

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

    def r_remove_um(self):
        # (, line 235
        # unset found_a_match, line 236
        self.B_found_a_match = False
        # call has_min_length, line 237
        if not self.r_has_min_length():
            return False
        # backwards, line 238
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 238
        # [, line 238
        self.ket = self.cursor
        # literal, line 238
        if not self.eq_s_b(3, u"\u0BC1\u0BAE\u0BCD"):
            return False
        # ], line 238
        self.bra = self.cursor
        # <-, line 238
        if not self.slice_from(u"\u0BCD"):
            return False
        # (, line 239
        # set found_a_match, line 239
        self.B_found_a_match = True
        self.cursor = self.limit_backward
        # do, line 241
        v_1 = self.cursor
        try:
            # call fix_ending, line 241
            if not self.r_fix_ending():
                raise lab0()
        except lab0: pass
        self.cursor = v_1
        return True

    def r_remove_common_word_endings(self):
        # (, line 243
        # unset found_a_match, line 248
        self.B_found_a_match = False
        # call has_min_length, line 249
        if not self.r_has_min_length():
            return False
        # backwards, line 250
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 250
        # or, line 262
        try:
            v_1 = self.limit - self.cursor
            try:
                # test, line 251
                v_2 = self.limit - self.cursor
                # (, line 251
                # [, line 251
                self.ket = self.cursor
                # or, line 251
                try:
                    v_3 = self.limit - self.cursor
                    try:
                        # literal, line 251
                        if not self.eq_s_b(4, u"\u0BC1\u0B9F\u0BA9\u0BCD"):
                            raise lab3()
                        raise lab2()
                    except lab3: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 252
                        if not self.eq_s_b(5, u"\u0BBF\u0BB2\u0BCD\u0BB2\u0BC8"):
                            raise lab4()
                        raise lab2()
                    except lab4: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 253
                        if not self.eq_s_b(4, u"\u0BBF\u0B9F\u0BAE\u0BCD"):
                            raise lab5()
                        raise lab2()
                    except lab5: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 253
                        if not self.eq_s_b(5, u"\u0BBF\u0BA9\u0BCD\u0BB1\u0BBF"):
                            raise lab6()
                        raise lab2()
                    except lab6: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 254
                        if not self.eq_s_b(3, u"\u0BBE\u0B95\u0BBF"):
                            raise lab7()
                        raise lab2()
                    except lab7: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 254
                        if not self.eq_s_b(4, u"\u0BBE\u0B95\u0BBF\u0BAF"):
                            raise lab8()
                        raise lab2()
                    except lab8: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 255
                        if not self.eq_s_b(5, u"\u0BC6\u0BA9\u0BCD\u0BB1\u0BC1"):
                            raise lab9()
                        raise lab2()
                    except lab9: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 255
                        if not self.eq_s_b(4, u"\u0BC1\u0BB3\u0BCD\u0BB3"):
                            raise lab10()
                        raise lab2()
                    except lab10: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 256
                        if not self.eq_s_b(4, u"\u0BC1\u0B9F\u0BC8\u0BAF"):
                            raise lab11()
                        raise lab2()
                    except lab11: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 256
                        if not self.eq_s_b(3, u"\u0BC1\u0B9F\u0BC8"):
                            raise lab12()
                        raise lab2()
                    except lab12: pass
                    self.cursor = self.limit - v_3
                    try:
                        # literal, line 257
                        if not self.eq_s_b(5, u"\u0BC6\u0BA9\u0BC1\u0BAE\u0BCD"):
                            raise lab13()
                        raise lab2()
                    except lab13: pass
                    self.cursor = self.limit - v_3
                    try:
                        # (, line 258
                        # literal, line 258
                        if not self.eq_s_b(3, u"\u0BB2\u0BCD\u0BB2"):
                            raise lab14()
                        # test, line 258
                        v_4 = self.limit - self.cursor
                        # (, line 258
                        # not, line 258
                        v_5 = self.limit - self.cursor
                        try:
                            # (, line 258
                            # or, line 258
                            try:
                                v_6 = self.limit - self.cursor
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BBE"):
                                        raise lab17()
                                    raise lab16()
                                except lab17: pass
                                self.cursor = self.limit - v_6
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BBF"):
                                        raise lab18()
                                    raise lab16()
                                except lab18: pass
                                self.cursor = self.limit - v_6
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BC0"):
                                        raise lab19()
                                    raise lab16()
                                except lab19: pass
                                self.cursor = self.limit - v_6
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BC6"):
                                        raise lab20()
                                    raise lab16()
                                except lab20: pass
                                self.cursor = self.limit - v_6
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BC7"):
                                        raise lab21()
                                    raise lab16()
                                except lab21: pass
                                self.cursor = self.limit - v_6
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BC1"):
                                        raise lab22()
                                    raise lab16()
                                except lab22: pass
                                self.cursor = self.limit - v_6
                                try:
                                    # literal, line 258
                                    if not self.eq_s_b(1, u"\u0BC2"):
                                        raise lab23()
                                    raise lab16()
                                except lab23: pass
                                self.cursor = self.limit - v_6
                                # literal, line 258
                                if not self.eq_s_b(1, u"\u0BC8"):
                                    raise lab15()
                            except lab16: pass
                            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 259
                        if not self.eq_s_b(2, u"\u0BC6\u0BA9"):
                            raise lab24()
                        raise lab2()
                    except lab24: pass
                    self.cursor = self.limit - v_3
                    # literal, line 259
                    if not self.eq_s_b(3, u"\u0BBE\u0B95\u0BBF"):
                        raise lab1()
                except lab2: pass
                # ], line 259
                self.bra = self.cursor
                # <-, line 259
                if not self.slice_from(u"\u0BCD"):
                    return False
                # (, line 260
                # set found_a_match, line 260
                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 263
            v_7 = self.limit - self.cursor
            # (, line 263
            # [, line 263
            self.ket = self.cursor
            # or, line 263
            try:
                v_8 = self.limit - self.cursor
                try:
                    # literal, line 263
                    if not self.eq_s_b(3, u"\u0BAA\u0B9F\u0BC1"):
                        raise lab26()
                    raise lab25()
                except lab26: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 264
                    if not self.eq_s_b(4, u"\u0BAA\u0B9F\u0BCD\u0B9F"):
                        raise lab27()
                    raise lab25()
                except lab27: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 264
                    if not self.eq_s_b(5, u"\u0BAA\u0B9F\u0BCD\u0B9F\u0BC1"):
                        raise lab28()
                    raise lab25()
                except lab28: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 265
                    if not self.eq_s_b(6, u"\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1"):
                        raise lab29()
                    raise lab25()
                except lab29: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 266
                    if not self.eq_s_b(5, u"\u0BAA\u0B9F\u0BCD\u0B9F\u0BA3"):
                        raise lab30()
                    raise lab25()
                except lab30: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 266
                    if not self.eq_s_b(5, u"\u0B95\u0BC1\u0BB0\u0BBF\u0BAF"):
                        raise lab31()
                    raise lab25()
                except lab31: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 267
                    if not self.eq_s_b(5, u"\u0B95\u0BC1\u0BB0\u0BBF\u0BAF"):
                        raise lab32()
                    raise lab25()
                except lab32: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 267
                    if not self.eq_s_b(5, u"\u0BAA\u0BB1\u0BCD\u0BB1\u0BBF"):
                        raise lab33()
                    raise lab25()
                except lab33: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 268
                    if not self.eq_s_b(4, u"\u0BB5\u0BBF\u0B9F\u0BC1"):
                        raise lab34()
                    raise lab25()
                except lab34: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 268
                    if not self.eq_s_b(6, u"\u0BB5\u0BBF\u0B9F\u0BCD\u0B9F\u0BC1"):
                        raise lab35()
                    raise lab25()
                except lab35: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 269
                    if not self.eq_s_b(6, u"\u0BAA\u0B9F\u0BBF\u0BA4\u0BBE\u0BA9"):
                        raise lab36()
                    raise lab25()
                except lab36: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 270
                    if not self.eq_s_b(3, u"\u0BAA\u0B9F\u0BBF"):
                        raise lab37()
                    raise lab25()
                except lab37: pass
                self.cursor = self.limit - v_8
                try:
                    # literal, line 270
                    if not self.eq_s_b(3, u"\u0BA4\u0BBE\u0BA9"):
                        raise lab38()
                    raise lab25()
                except lab38: pass
                self.cursor = self.limit - v_8
                # literal, line 271
                if not self.eq_s_b(7, u"\u0BC6\u0BB2\u0BCD\u0BB2\u0BBE\u0BAE\u0BCD"):
                    return False
            except lab25: pass
            # ], line 272
            self.bra = self.cursor
            # delete, line 272
            if not self.slice_del():
                return False

            # (, line 273
            # set found_a_match, line 273
            self.B_found_a_match = True
            self.cursor = self.limit - v_7
        except lab0: pass
        self.cursor = self.limit_backward
        # do, line 276
        v_9 = self.cursor
        try:
            # call fix_endings, line 276
            if not self.r_fix_endings():
                raise lab39()
        except lab39: pass
        self.cursor = v_9
        return True

    def r_remove_vetrumai_urupukal(self):
        # (, line 278
        # unset found_a_match, line 279
        self.B_found_a_match = False
        # unset found_vetrumai_urupu, line 280
        self.B_found_vetrumai_urupu = False
        # call has_min_length, line 281
        if not self.r_has_min_length():
            return False
        # backwards, line 282
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 282
        # (, line 283
        # or, line 285
        try:
            v_1 = self.limit - self.cursor
            try:
                # test, line 284
                v_2 = self.limit - self.cursor
                # (, line 284
                # [, line 284
                self.ket = self.cursor
                # literal, line 284
                if not self.eq_s_b(2, u"\u0BA9\u0BC8"):
                    raise lab1()
                # ], line 284
                self.bra = self.cursor
                # delete, line 284
                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 286
                v_3 = self.limit - self.cursor
                # (, line 286
                # [, line 286
                self.ket = self.cursor
                # or, line 287
                try:
                    v_4 = self.limit - self.cursor
                    try:
                        # (, line 286
                        # or, line 286
                        try:
                            v_5 = self.limit - self.cursor
                            try:
                                # literal, line 286
                                if not self.eq_s_b(3, u"\u0BBF\u0BA9\u0BC8"):
                                    raise lab6()
                                raise lab5()
                            except lab6: pass
                            self.cursor = self.limit - v_5
                            # literal, line 287
                            if not self.eq_s_b(1, u"\u0BC8"):
                                raise lab4()
                        except lab5: pass
                        # (, line 287
                        # test, line 287
                        v_6 = self.limit - self.cursor
                        # not, line 287
                        v_7 = self.limit - self.cursor
                        try:
                            # (, line 287
                            # or, line 287
                            try:
                                v_8 = self.limit - self.cursor
                                try:
                                    # literal, line 287
                                    if not self.eq_s_b(1, u"\u0B95"):
                                        raise lab9()
                                    raise lab8()
                                except lab9: pass
                                self.cursor = self.limit - v_8
                                try:
                                    # literal, line 287
                                    if not self.eq_s_b(1, u"\u0B9A"):
                                        raise lab10()
                                    raise lab8()
                                except lab10: pass
                                self.cursor = self.limit - v_8
                                try:
                                    # literal, line 287
                                    if not self.eq_s_b(1, u"\u0B9F"):
                                        raise lab11()
                                    raise lab8()
                                except lab11: pass
                                self.cursor = self.limit - v_8
                                try:
                                    # literal, line 287
                                    if not self.eq_s_b(1, u"\u0BA4"):
                                        raise lab12()
                                    raise lab8()
                                except lab12: pass
                                self.cursor = self.limit - v_8
                                try:
                                    # literal, line 287
                                    if not self.eq_s_b(1, u"\u0BAA"):
                                        raise lab13()
                                    raise lab8()
                                except lab13: pass
                                self.cursor = self.limit - v_8
                                # literal, line 287
                                if not self.eq_s_b(1, u"\u0BB1"):
                                    raise lab7()
                            except lab8: pass
                            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 288
                    # literal, line 288
                    if not self.eq_s_b(1, u"\u0BC8"):
                        raise lab2()
                    # (, line 288
                    # test, line 288
                    v_9 = self.limit - self.cursor
                    # (, line 288
                    # (, line 288
                    # or, line 288
                    try:
                        v_10 = self.limit - self.cursor
                        try:
                            # literal, line 288
                            if not self.eq_s_b(1, u"\u0B95"):
                                raise lab15()
                            raise lab14()
                        except lab15: pass
                        self.cursor = self.limit - v_10
                        try:
                            # literal, line 288
                            if not self.eq_s_b(1, u"\u0B9A"):
                                raise lab16()
                            raise lab14()
                        except lab16: pass
                        self.cursor = self.limit - v_10
                        try:
                            # literal, line 288
                            if not self.eq_s_b(1, u"\u0B9F"):
                                raise lab17()
                            raise lab14()
                        except lab17: pass
                        self.cursor = self.limit - v_10
                        try:
                            # literal, line 288
                            if not self.eq_s_b(1, u"\u0BA4"):
                                raise lab18()
                            raise lab14()
                        except lab18: pass
                        self.cursor = self.limit - v_10
                        try:
                            # literal, line 288
                            if not self.eq_s_b(1, u"\u0BAA"):
                                raise lab19()
                            raise lab14()
                        except lab19: pass
                        self.cursor = self.limit - v_10
                        # literal, line 288
                        if not self.eq_s_b(1, u"\u0BB1"):
                            raise lab2()
                    except lab14: pass
                    # literal, line 288
                    if not self.eq_s_b(1, u"\u0BCD"):
                        raise lab2()
                    self.cursor = self.limit - v_9
                except lab3: pass
                # ], line 289
                self.bra = self.cursor
                # <-, line 289
                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 293
                v_11 = self.limit - self.cursor
                # (, line 293
                # [, line 293
                self.ket = self.cursor
                # or, line 293
                try:
                    v_12 = self.limit - self.cursor
                    try:
                        # literal, line 293
                        if not self.eq_s_b(3, u"\u0BCA\u0B9F\u0BC1"):
                            raise lab22()
                        raise lab21()
                    except lab22: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 293
                        if not self.eq_s_b(3, u"\u0BCB\u0B9F\u0BC1"):
                            raise lab23()
                        raise lab21()
                    except lab23: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 294
                        if not self.eq_s_b(3, u"\u0BBF\u0BB2\u0BCD"):
                            raise lab24()
                        raise lab21()
                    except lab24: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 294
                        if not self.eq_s_b(3, u"\u0BBF\u0BB1\u0BCD"):
                            raise lab25()
                        raise lab21()
                    except lab25: pass
                    self.cursor = self.limit - v_12
                    try:
                        # (, line 295
                        # literal, line 295
                        if not self.eq_s_b(3, u"\u0BBF\u0BA9\u0BCD"):
                            raise lab26()
                        # (, line 295
                        # test, line 295
                        v_13 = self.limit - self.cursor
                        # not, line 295
                        v_14 = self.limit - self.cursor
                        try:
                            # literal, line 295
                            if not self.eq_s_b(1, u"\u0BAE"):
                                raise lab27()
                            raise lab26()
                        except lab27: pass
                        self.cursor = self.limit - v_14
                        self.cursor = self.limit - v_13
                        raise lab21()
                    except lab26: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 296
                        if not self.eq_s_b(5, u"\u0BBF\u0BA9\u0BCD\u0BB1\u0BC1"):
                            raise lab28()
                        raise lab21()
                    except lab28: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 297
                        if not self.eq_s_b(7, u"\u0BBF\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4\u0BC1"):
                            raise lab29()
                        raise lab21()
                    except lab29: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 298
                        if not self.eq_s_b(3, u"\u0BB5\u0BBF\u0B9F"):
                            raise lab30()
                        raise lab21()
                    except lab30: pass
                    self.cursor = self.limit - v_12
                    try:
                        # (, line 298
                        if not self.I_length >= 7:
                            raise lab31()
                        # literal, line 298
                        if not self.eq_s_b(4, u"\u0BBF\u0B9F\u0BAE\u0BCD"):
                            raise lab31()
                        raise lab21()
                    except lab31: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 299
                        if not self.eq_s_b(3, u"\u0BBE\u0BB2\u0BCD"):
                            raise lab32()
                        raise lab21()
                    except lab32: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 299
                        if not self.eq_s_b(3, u"\u0BC1\u0B9F\u0BC8"):
                            raise lab33()
                        raise lab21()
                    except lab33: pass
                    self.cursor = self.limit - v_12
                    try:
                        # literal, line 300
                        if not self.eq_s_b(4, u"\u0BBE\u0BAE\u0BB2\u0BCD"):
                            raise lab34()
                        raise lab21()
                    except lab34: pass
                    self.cursor = self.limit - v_12
                    try:
                        # (, line 301
                        # literal, line 301
                        if not self.eq_s_b(2, u"\u0BB2\u0BCD"):
                            raise lab35()
                        # (, line 301
                        # test, line 301
                        v_15 = self.limit - self.cursor
                        # not, line 301
                        v_16 = self.limit - self.cursor
                        try:
                            # (, line 301
                            # or, line 301
                            try:
                                v_17 = self.limit - self.cursor
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BBE"):
                                        raise lab38()
                                    raise lab37()
                                except lab38: pass
                                self.cursor = self.limit - v_17
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BBF"):
                                        raise lab39()
                                    raise lab37()
                                except lab39: pass
                                self.cursor = self.limit - v_17
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BC0"):
                                        raise lab40()
                                    raise lab37()
                                except lab40: pass
                                self.cursor = self.limit - v_17
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BC6"):
                                        raise lab41()
                                    raise lab37()
                                except lab41: pass
                                self.cursor = self.limit - v_17
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BC7"):
                                        raise lab42()
                                    raise lab37()
                                except lab42: pass
                                self.cursor = self.limit - v_17
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BC1"):
                                        raise lab43()
                                    raise lab37()
                                except lab43: pass
                                self.cursor = self.limit - v_17
                                try:
                                    # literal, line 301
                                    if not self.eq_s_b(1, u"\u0BC2"):
                                        raise lab44()
                                    raise lab37()
                                except lab44: pass
                                self.cursor = self.limit - v_17
                                # literal, line 301
                                if not self.eq_s_b(1, u"\u0BC8"):
                                    raise lab36()
                            except lab37: pass
                            raise lab35()
                        except lab36: pass
                        self.cursor = self.limit - v_16
                        self.cursor = self.limit - v_15
                        raise lab21()
                    except lab35: pass
                    self.cursor = self.limit - v_12
                    # literal, line 302
                    if not self.eq_s_b(3, u"\u0BC1\u0BB3\u0BCD"):
                        raise lab20()
                except lab21: pass
                # ], line 302
                self.bra = self.cursor
                # <-, line 302
                if not self.slice_from(u"\u0BCD"):
                    return False
                self.cursor = self.limit - v_11
                raise lab0()
            except lab20: pass
            self.cursor = self.limit - v_1
            try:
                # test, line 306
                v_18 = self.limit - self.cursor
                # (, line 306
                # [, line 306
                self.ket = self.cursor
                # or, line 306
                try:
                    v_19 = self.limit - self.cursor
                    try:
                        # literal, line 306
                        if not self.eq_s_b(3, u"\u0B95\u0BA3\u0BCD"):
                            raise lab47()
                        raise lab46()
                    except lab47: pass
                    self.cursor = self.limit - v_19
                    try:
                        # literal, line 306
                        if not self.eq_s_b(4, u"\u0BAE\u0BC1\u0BA9\u0BCD"):
                            raise lab48()
                        raise lab46()
                    except lab48: pass
                    self.cursor = self.limit - v_19
                    try:
                        # literal, line 307
                        if not self.eq_s_b(4, u"\u0BAE\u0BC7\u0BB2\u0BCD"):
                            raise lab49()
                        raise lab46()
                    except lab49: pass
                    self.cursor = self.limit - v_19
                    try:
                        # literal, line 307
                        if not self.eq_s_b(4, u"\u0BAE\u0BC7\u0BB1\u0BCD"):
                            raise lab50()
                        raise lab46()
                    except lab50: pass
                    self.cursor = self.limit - v_19
                    try:
                        # literal, line 308
                        if not self.eq_s_b(4, u"\u0B95\u0BC0\u0BB4\u0BCD"):
                            raise lab51()
                        raise lab46()
                    except lab51: pass
                    self.cursor = self.limit - v_19
                    try:
                        # literal, line 308
                        if not self.eq_s_b(4, u"\u0BAA\u0BBF\u0BA9\u0BCD"):
                            raise lab52()
                        raise lab46()
                    except lab52: pass
                    self.cursor = self.limit - v_19
                    # (, line 309
                    # literal, line 309
                    if not self.eq_s_b(2, u"\u0BA4\u0BC1"):
                        raise lab45()
                    # (, line 309
                    # test, line 309
                    v_20 = self.limit - self.cursor
                    # not, line 309
                    v_21 = self.limit - self.cursor
                    try:
                        # (, line 309
                        # or, line 309
                        try:
                            v_22 = self.limit - self.cursor
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BBE"):
                                    raise lab55()
                                raise lab54()
                            except lab55: pass
                            self.cursor = self.limit - v_22
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BBF"):
                                    raise lab56()
                                raise lab54()
                            except lab56: pass
                            self.cursor = self.limit - v_22
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BC0"):
                                    raise lab57()
                                raise lab54()
                            except lab57: pass
                            self.cursor = self.limit - v_22
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BC6"):
                                    raise lab58()
                                raise lab54()
                            except lab58: pass
                            self.cursor = self.limit - v_22
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BC7"):
                                    raise lab59()
                                raise lab54()
                            except lab59: pass
                            self.cursor = self.limit - v_22
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BC1"):
                                    raise lab60()
                                raise lab54()
                            except lab60: pass
                            self.cursor = self.limit - v_22
                            try:
                                # literal, line 309
                                if not self.eq_s_b(1, u"\u0BC2"):
                                    raise lab61()
                                raise lab54()
                            except lab61: pass
                            self.cursor = self.limit - v_22
                            # literal, line 309
                            if not self.eq_s_b(1, u"\u0BC8"):
                                raise lab53()
                        except lab54: pass
                        raise lab45()
                    except lab53: pass
                    self.cursor = self.limit - v_21
                    self.cursor = self.limit - v_20
                except lab46: pass
                # ], line 309
                self.bra = self.cursor
                # delete, line 309
                if not self.slice_del():
                    return False

                self.cursor = self.limit - v_18
                raise lab0()
            except lab45: pass
            self.cursor = self.limit - v_1
            # test, line 313
            v_23 = self.limit - self.cursor
            # (, line 313
            # [, line 313
            self.ket = self.cursor
            # literal, line 313
            if not self.eq_s_b(1, u"\u0BC0"):
                return False
            # ], line 313
            self.bra = self.cursor
            # <-, line 313
            if not self.slice_from(u"\u0BBF"):
                return False
            self.cursor = self.limit - v_23
        except lab0: pass
        # (, line 317
        # set found_a_match, line 317
        self.B_found_a_match = True
        # (, line 318
        # set found_vetrumai_urupu, line 318
        self.B_found_vetrumai_urupu = True
        # do, line 319
        v_24 = self.limit - self.cursor
        try:
            # (, line 319
            # [, line 319
            self.ket = self.cursor
            # literal, line 319
            if not self.eq_s_b(3, u"\u0BBF\u0BA9\u0BCD"):
                raise lab62()
            # ], line 319
            self.bra = self.cursor
            # <-, line 319
            if not self.slice_from(u"\u0BCD"):
                return False
        except lab62: pass
        self.cursor = self.limit - v_24
        self.cursor = self.limit_backward
        # do, line 321
        v_25 = self.cursor
        try:
            # call fix_endings, line 321
            if not self.r_fix_endings():
                raise lab63()
        except lab63: pass
        self.cursor = v_25
        return True

    def r_remove_tense_suffixes(self):
        # (, line 323
        # set found_a_match, line 324
        self.B_found_a_match = True
        # repeat, line 325
        try:
            while True:
                try:
                    v_1 = self.cursor
                    try:
                        # (, line 325
                        # Boolean test found_a_match, line 325
                        if not self.B_found_a_match:
                            raise lab2()
                        # (, line 325
                        # do, line 325
                        v_2 = self.cursor
                        try:
                            # call remove_tense_suffix, line 325
                            if not self.r_remove_tense_suffix():
                                raise lab3()
                        except lab3: pass
                        self.cursor = v_2
                        raise lab1()
                    except lab2: pass
                    self.cursor = v_1
                    raise lab0()
                except lab1: pass
        except lab0: pass
        return True

    def r_remove_tense_suffix(self):
        # (, line 327
        # unset found_a_match, line 328
        self.B_found_a_match = False
        # call has_min_length, line 329
        if not self.r_has_min_length():
            return False
        # backwards, line 330
        self.limit_backward = self.cursor
        self.cursor = self.limit
        # (, line 330
        # do, line 331
        v_1 = self.limit - self.cursor
        try:
            # (, line 331
            # or, line 337
            try:
                v_2 = self.limit - self.cursor
                try:
                    # test, line 332
                    v_3 = self.limit - self.cursor
                    # (, line 332
                    # [, line 332
                    self.ket = self.cursor
                    # or, line 332
                    try:
                        v_4 = self.limit - self.cursor
                        try:
                            # literal, line 332
                            if not self.eq_s_b(8, u"\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BCD"):
                                raise lab4()
                            raise lab3()
                        except lab4: pass
                        self.cursor = self.limit - v_4
                        # literal, line 333
                        if not self.eq_s_b(3, u"\u0BAA\u0B9F\u0BC1"):
                            raise lab2()
                    except lab3: pass
                    # ], line 333
                    self.bra = self.cursor
                    # delete, line 334
                    if not self.slice_del():
                        return False

                    # (, line 335
                    # set found_a_match, line 335
                    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 338
                    v_5 = self.limit - self.cursor
                    # (, line 338
                    # [, line 338
                    self.ket = self.cursor
                    # or, line 339
                    try:
                        v_6 = self.limit - self.cursor
                        try:
                            # literal, line 339
                            if not self.eq_s_b(4, u"\u0BAE\u0BBE\u0BB0\u0BCD"):
                                raise lab7()
                            raise lab6()
                        except lab7: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 339
                            if not self.eq_s_b(4, u"\u0BAE\u0BBF\u0BA9\u0BCD"):
                                raise lab8()
                            raise lab6()
                        except lab8: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 340
                            if not self.eq_s_b(3, u"\u0BA9\u0BA9\u0BCD"):
                                raise lab9()
                            raise lab6()
                        except lab9: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 340
                            if not self.eq_s_b(4, u"\u0BA9\u0BBE\u0BA9\u0BCD"):
                                raise lab10()
                            raise lab6()
                        except lab10: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 341
                            if not self.eq_s_b(4, u"\u0BA9\u0BBE\u0BB3\u0BCD"):
                                raise lab11()
                            raise lab6()
                        except lab11: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 341
                            if not self.eq_s_b(4, u"\u0BA9\u0BBE\u0BB0\u0BCD"):
                                raise lab12()
                            raise lab6()
                        except lab12: pass
                        self.cursor = self.limit - v_6
                        try:
                            # (, line 342
                            # literal, line 342
                            if not self.eq_s_b(3, u"\u0BB5\u0BA9\u0BCD"):
                                raise lab13()
                            # test, line 342
                            v_7 = self.limit - self.cursor
                            # (, line 342
                            # not, line 342
                            v_8 = self.limit - self.cursor
                            try:
                                # (, line 342
                                # or, line 342
                                try:
                                    v_9 = self.limit - self.cursor
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B85"):
                                            raise lab16()
                                        raise lab15()
                                    except lab16: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B86"):
                                            raise lab17()
                                        raise lab15()
                                    except lab17: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B87"):
                                            raise lab18()
                                        raise lab15()
                                    except lab18: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B88"):
                                            raise lab19()
                                        raise lab15()
                                    except lab19: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B89"):
                                            raise lab20()
                                        raise lab15()
                                    except lab20: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B8A"):
                                            raise lab21()
                                        raise lab15()
                                    except lab21: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B8E"):
                                            raise lab22()
                                        raise lab15()
                                    except lab22: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B8F"):
                                            raise lab23()
                                        raise lab15()
                                    except lab23: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B90"):
                                            raise lab24()
                                        raise lab15()
                                    except lab24: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B92"):
                                            raise lab25()
                                        raise lab15()
                                    except lab25: pass
                                    self.cursor = self.limit - v_9
                                    try:
                                        # literal, line 342
                                        if not self.eq_s_b(1, u"\u0B93"):
                                            raise lab26()
                                        raise lab15()
                                    except lab26: pass
                                    self.cursor = self.limit - v_9
                                    # literal, line 342
                                    if not self.eq_s_b(1, u"\u0B94"):
                                        raise lab14()
                                except lab15: pass
                                raise lab13()
                            except lab14: pass
                            self.cursor = self.limit - v_8
                            self.cursor = self.limit - v_7
                            raise lab6()
                        except lab13: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 343
                            if not self.eq_s_b(3, u"\u0BA9\u0BB3\u0BCD"):
                                raise lab27()
                            raise lab6()
                        except lab27: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 343
                            if not self.eq_s_b(3, u"\u0BB5\u0BB3\u0BCD"):
                                raise lab28()
                            raise lab6()
                        except lab28: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 344
                            if not self.eq_s_b(3, u"\u0BA9\u0BB0\u0BCD"):
                                raise lab29()
                            raise lab6()
                        except lab29: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 344
                            if not self.eq_s_b(3, u"\u0BB5\u0BB0\u0BCD"):
                                raise lab30()
                            raise lab6()
                        except lab30: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 345
                            if not self.eq_s_b(1, u"\u0BA9"):
                                raise lab31()
                            raise lab6()
                        except lab31: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 345
                            if not self.eq_s_b(1, u"\u0BAA"):
                                raise lab32()
                            raise lab6()
                        except lab32: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 345
                            if not self.eq_s_b(1, u"\u0B95"):
                                raise lab33()
                            raise lab6()
                        except lab33: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 345
                            if not self.eq_s_b(1, u"\u0BA4"):
                                raise lab34()
                            raise lab6()
                        except lab34: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 345
                            if not self.eq_s_b(1, u"\u0BAF"):
                                raise lab35()
                            raise lab6()
                        except lab35: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 346
                            if not self.eq_s_b(3, u"\u0BAA\u0BA9\u0BCD"):
                                raise lab36()
                            raise lab6()
                        except lab36: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 346
                            if not self.eq_s_b(3, u"\u0BAA\u0BB3\u0BCD"):
                                raise lab37()
                            raise lab6()
                        except lab37: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 347
                            if not self.eq_s_b(3, u"\u0BAA\u0BB0\u0BCD"):
                                raise lab38()
                            raise lab6()
                        except lab38: pass
                        self.cursor = self.limit - v_6
                        try:
                            # (, line 348
                            # literal, line 348
                            if not self.eq_s_b(2, u"\u0BA4\u0BC1"):
                                raise lab39()
                            # (, line 348
                            # test, line 348
                            v_10 = self.limit - self.cursor
                            # not, line 348
                            v_11 = self.limit - self.cursor
                            try:
                                # (, line 348
                                # or, line 348
                                try:
                                    v_12 = self.limit - self.cursor
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BBE"):
                                            raise lab42()
                                        raise lab41()
                                    except lab42: pass
                                    self.cursor = self.limit - v_12
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BBF"):
                                            raise lab43()
                                        raise lab41()
                                    except lab43: pass
                                    self.cursor = self.limit - v_12
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BC0"):
                                            raise lab44()
                                        raise lab41()
                                    except lab44: pass
                                    self.cursor = self.limit - v_12
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BC6"):
                                            raise lab45()
                                        raise lab41()
                                    except lab45: pass
                                    self.cursor = self.limit - v_12
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BC7"):
                                            raise lab46()
                                        raise lab41()
                                    except lab46: pass
                                    self.cursor = self.limit - v_12
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BC1"):
                                            raise lab47()
                                        raise lab41()
                                    except lab47: pass
                                    self.cursor = self.limit - v_12
                                    try:
                                        # literal, line 348
                                        if not self.eq_s_b(1, u"\u0BC2"):
                                            raise lab48()
                                        raise lab41()
                                    except lab48: pass
                                    self.cursor = self.limit - v_12
                                    # literal, line 348
                                    if not self.eq_s_b(1, u"\u0BC8"):
                                        raise lab40()
                                except lab41: pass
                                raise lab39()
                            except lab40: pass
                            self.cursor = self.limit - v_11
                            self.cursor = self.limit - v_10
                            raise lab6()
                        except lab39: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 349
                            if not self.eq_s_b(5, u"\u0BBF\u0BB1\u0BCD\u0BB1\u0BC1"):
                                raise lab49()
                            raise lab6()
                        except lab49: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 350
                            if not self.eq_s_b(3, u"\u0BAA\u0BAE\u0BCD"):
                                raise lab50()
                            raise lab6()
                        except lab50: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 350
                            if not self.eq_s_b(3, u"\u0BA9\u0BAE\u0BCD"):
                                raise lab51()
                            raise lab6()
                        except lab51: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 351
                            if not self.eq_s_b(4, u"\u0BA4\u0BC1\u0BAE\u0BCD"):
                                raise lab52()
                            raise lab6()
                        except lab52: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 351
                            if not self.eq_s_b(4, u"\u0BB1\u0BC1\u0BAE\u0BCD"):
                                raise lab53()
                            raise lab6()
                        except lab53: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 352
                            if not self.eq_s_b(4, u"\u0B95\u0BC1\u0BAE\u0BCD"):
                                raise lab54()
                            raise lab6()
                        except lab54: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 352
                            if not self.eq_s_b(4, u"\u0BA9\u0BC6\u0BA9\u0BCD"):
                                raise lab55()
                            raise lab6()
                        except lab55: pass
                        self.cursor = self.limit - v_6
                        try:
                            # literal, line 353
                            if not self.eq_s_b(2, u"\u0BA9\u0BC8"):
                                raise lab56()
                            raise lab6()
                        except lab56: pass
                        self.cursor = self.limit - v_6
                        # literal, line 353
                        if not self.eq_s_b(2, u"\u0BB5\u0BC8"):
                            raise lab5()
                    except lab6: pass
                    # ], line 354
                    self.bra = self.cursor
                    # delete, line 354
                    if not self.slice_del():
                        return False

                    # (, line 355
                    # set found_a_match, line 355
                    self.B_found_a_match = True
                    self.cursor = self.limit - v_5
                    raise lab1()
                except lab5: pass
                self.cursor = self.limit - v_2
                try:
                    # test, line 358
                    v_13 = self.limit - self.cursor
                    # (, line 358
                    # [, line 358
                    self.ket = self.cursor
                    # or, line 358
                    try:
                        v_14 = self.limit - self.cursor
                        try:
                            # (, line 358
                            # literal, line 358
                            if not self.eq_s_b(3, u"\u0BBE\u0BA9\u0BCD"):
                                raise lab59()
                            # test, line 358
                            v_15 = self.limit - self.cursor
                            # (, line 358
                            # not, line 358
                            v_16 = self.limit - self.cursor
                            try:
                                # literal, line 358
                                if not self.eq_s_b(1, u"\u0B9A"):
                                    raise lab60()
                                raise lab59()
                            except lab60: pass
                            self.cursor = self.limit - v_16
                            self.cursor = self.limit - v_15
                            raise lab58()
                        except lab59: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 359
                            if not self.eq_s_b(3, u"\u0BBE\u0BB3\u0BCD"):
                                raise lab61()
                            raise lab58()
                        except lab61: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 360
                            if not self.eq_s_b(3, u"\u0BBE\u0BB0\u0BCD"):
                                raise lab62()
                            raise lab58()
                        except lab62: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 361
                            if not self.eq_s_b(3, u"\u0BC7\u0BA9\u0BCD"):
                                raise lab63()
                            raise lab58()
                        except lab63: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 361
                            if not self.eq_s_b(1, u"\u0BBE"):
                                raise lab64()
                            raise lab58()
                        except lab64: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 362
                            if not self.eq_s_b(3, u"\u0BBE\u0BAE\u0BCD"):
                                raise lab65()
                            raise lab58()
                        except lab65: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 362
                            if not self.eq_s_b(3, u"\u0BC6\u0BAE\u0BCD"):
                                raise lab66()
                            raise lab58()
                        except lab66: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 363
                            if not self.eq_s_b(3, u"\u0BC7\u0BAE\u0BCD"):
                                raise lab67()
                            raise lab58()
                        except lab67: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 363
                            if not self.eq_s_b(3, u"\u0BCB\u0BAE\u0BCD"):
                                raise lab68()
                            raise lab58()
                        except lab68: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 364
                            if not self.eq_s_b(4, u"\u0B95\u0BC1\u0BAE\u0BCD"):
                                raise lab69()
                            raise lab58()
                        except lab69: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 364
                            if not self.eq_s_b(4, u"\u0BA4\u0BC1\u0BAE\u0BCD"):
                                raise lab70()
                            raise lab58()
                        except lab70: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 365
                            if not self.eq_s_b(4, u"\u0B9F\u0BC1\u0BAE\u0BCD"):
                                raise lab71()
                            raise lab58()
                        except lab71: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 365
                            if not self.eq_s_b(4, u"\u0BB1\u0BC1\u0BAE\u0BCD"):
                                raise lab72()
                            raise lab58()
                        except lab72: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 366
                            if not self.eq_s_b(3, u"\u0BBE\u0BAF\u0BCD"):
                                raise lab73()
                            raise lab58()
                        except lab73: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 366
                            if not self.eq_s_b(4, u"\u0BA9\u0BC6\u0BA9\u0BCD"):
                                raise lab74()
                            raise lab58()
                        except lab74: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 367
                            if not self.eq_s_b(4, u"\u0BA9\u0BBF\u0BB0\u0BCD"):
                                raise lab75()
                            raise lab58()
                        except lab75: pass
                        self.cursor = self.limit - v_14
                        try:
                            # literal, line 367
                            if not self.eq_s_b(3, u"\u0BC0\u0BB0\u0BCD"):
                                raise lab76()
                            raise lab58()
                        except lab76: pass
                        self.cursor = self.limit - v_14
                        # literal, line 368
                        if not self.eq_s_b(4, u"\u0BC0\u0BAF\u0BB0\u0BCD"):
                            raise lab57()
                    except lab58: pass
                    # ], line 368
                    self.bra = self.cursor
                    # <-, line 368
                    if not self.slice_from(u"\u0BCD"):
                        return False
                    # (, line 369
                    # set found_a_match, line 369
                    self.B_found_a_match = True
                    self.cursor = self.limit - v_13
                    raise lab1()
                except lab57: pass
                self.cursor = self.limit - v_2
                # test, line 372
                v_17 = self.limit - self.cursor
                # (, line 372
                # (, line 372
                # [, line 372
                self.ket = self.cursor
                # or, line 372
                try:
                    v_18 = self.limit - self.cursor
                    try:
                        # literal, line 372
                        if not self.eq_s_b(2, u"\u0B95\u0BC1"):
                            raise lab78()
                        raise lab77()
                    except lab78: pass
                    self.cursor = self.limit - v_18
                    # literal, line 372
                    if not self.eq_s_b(2, u"\u0BA4\u0BC1"):
                        raise lab0()
                except lab77: pass
                # (, line 372
                # test, line 372
                v_19 = self.limit - self.cursor
                # literal, line 372
                if not self.eq_s_b(1, u"\u0BCD"):
                    raise lab0()
                self.cursor = self.limit - v_19
                # ], line 372
                self.bra = self.cursor
                # delete, line 372
                if not self.slice_del():
                    return False

                # (, line 373
                # set found_a_match, line 373
                self.B_found_a_match = True
                self.cursor = self.limit - v_17
            except lab1: pass
        except lab0: pass
        self.cursor = self.limit - v_1
        # do, line 376
        v_20 = self.limit - self.cursor
        try:
            # (, line 376
            # [, line 376
            self.ket = self.cursor
            # or, line 376
            try:
                v_21 = self.limit - self.cursor
                try:
                    # literal, line 376
                    if not self.eq_s_b(6, u"\u0BBE\u0BA8\u0BBF\u0BA9\u0BCD\u0BB1"):
                        raise lab81()
                    raise lab80()
                except lab81: pass
                self.cursor = self.limit - v_21
                try:
                    # literal, line 377
                    if not self.eq_s_b(7, u"\u0BBE\u0BA8\u0BBF\u0BA9\u0BCD\u0BB1\u0BCD"):
                        raise lab82()
                    raise lab80()
                except lab82: pass
                self.cursor = self.limit - v_21
                try:
                    # literal, line 378
                    if not self.eq_s_b(5, u"\u0B95\u0BBF\u0BA9\u0BCD\u0BB1"):
                        raise lab83()
                    raise lab80()
                except lab83: pass
                self.cursor = self.limit - v_21
                try:
                    # literal, line 379
                    if not self.eq_s_b(6, u"\u0B95\u0BBF\u0BA9\u0BCD\u0BB1\u0BCD"):
                        raise lab84()
                    raise lab80()
                except lab84: pass
                self.cursor = self.limit - v_21
                try:
                    # literal, line 380
                    if not self.eq_s_b(3, u"\u0B95\u0BBF\u0BB1"):
                        raise lab85()
                    raise lab80()
                except lab85: pass
                self.cursor = self.limit - v_21
                # literal, line 381
                if not self.eq_s_b(4, u"\u0B95\u0BBF\u0BB1\u0BCD"):
                    raise lab79()
            except lab80: pass
            # ], line 381
            self.bra = self.cursor
            # delete, line 381
            if not self.slice_del():
                return False

            # (, line 382
            # set found_a_match, line 382
            self.B_found_a_match = True
        except lab79: pass
        self.cursor = self.limit - v_20
        self.cursor = self.limit_backward
        # do, line 385
        v_22 = self.cursor
        try:
            # call fix_endings, line 385
            if not self.r_fix_endings():
                raise lab86()
        except lab86: pass
        self.cursor = v_22
        return True

    def _stem(self):
        # (, line 387
        # do, line 389
        v_1 = self.cursor
        try:
            # call fix_ending, line 389
            if not self.r_fix_ending():
                raise lab0()
        except lab0: pass
        self.cursor = v_1
        # call has_min_length, line 390
        if not self.r_has_min_length():
            return False
        # do, line 391
        v_2 = self.cursor
        try:
            # call remove_question_prefixes, line 391
            if not self.r_remove_question_prefixes():
                raise lab1()
        except lab1: pass
        self.cursor = v_2
        # do, line 392
        v_3 = self.cursor
        try:
            # call remove_pronoun_prefixes, line 392
            if not self.r_remove_pronoun_prefixes():
                raise lab2()
        except lab2: pass
        self.cursor = v_3
        # do, line 393
        v_4 = self.cursor
        try:
            # call remove_question_suffixes, line 393
            if not self.r_remove_question_suffixes():
                raise lab3()
        except lab3: pass
        self.cursor = v_4
        # do, line 394
        v_5 = self.cursor
        try:
            # call remove_um, line 394
            if not self.r_remove_um():
                raise lab4()
        except lab4: pass
        self.cursor = v_5
        # do, line 395
        v_6 = self.cursor
        try:
            # call remove_common_word_endings, line 395
            if not self.r_remove_common_word_endings():
                raise lab5()
        except lab5: pass
        self.cursor = v_6
        # do, line 396
        v_7 = self.cursor
        try:
            # call remove_vetrumai_urupukal, line 396
            if not self.r_remove_vetrumai_urupukal():
                raise lab6()
        except lab6: pass
        self.cursor = v_7
        # do, line 397
        v_8 = self.cursor
        try:
            # call remove_plural_suffix, line 397
            if not self.r_remove_plural_suffix():
                raise lab7()
        except lab7: pass
        self.cursor = v_8
        # do, line 398
        v_9 = self.cursor
        try:
            # call remove_command_suffixes, line 398
            if not self.r_remove_command_suffixes():
                raise lab8()
        except lab8: pass
        self.cursor = v_9
        # do, line 399
        v_10 = self.cursor
        try:
            # call remove_tense_suffixes, line 399
            if not self.r_remove_tense_suffixes():
                raise lab9()
        except lab9: pass
        self.cursor = v_10
        return True

    def equals(self, o):
        return isinstance(o, TamilStemmer)

    def hashCode(self):
        return hash("TamilStemmer")
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
class lab58(BaseException): pass
class lab59(BaseException): pass
class lab60(BaseException): pass
class lab61(BaseException): pass
class lab62(BaseException): pass
class lab63(BaseException): pass
class lab64(BaseException): pass
class lab65(BaseException): pass
class lab66(BaseException): pass
class lab67(BaseException): pass
class lab68(BaseException): pass
class lab69(BaseException): pass
class lab70(BaseException): pass
class lab71(BaseException): pass
class lab72(BaseException): pass
class lab73(BaseException): pass
class lab74(BaseException): pass
class lab75(BaseException): pass
class lab76(BaseException): pass
class lab77(BaseException): pass
class lab78(BaseException): pass
class lab79(BaseException): pass
class lab80(BaseException): pass
class lab81(BaseException): pass
class lab82(BaseException): pass
class lab83(BaseException): pass
class lab84(BaseException): pass
class lab85(BaseException): pass
class lab86(BaseException): pass
