//! This file was generated automatically by the Snowball to Rust compiler
//! http://snowballstem.org/

#![allow(non_upper_case_globals)]
#![allow(non_snake_case)]
#![allow(unused_variables)]
#![allow(unused_mut)]
use snowball::SnowballEnv;
use snowball::Among;

static A_0: &'static [Among<Context>; 10] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B99}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9E}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BA8}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BAE}", -1, -1, None),
    Among("\u{0BAF}", -1, -1, None),
    Among("\u{0BB5}", -1, -1, None),
];

static A_1: &'static [Among<Context>; 3] = &[
    Among("\u{0BA8}\u{0BCD}\u{0BA4}\u{0BCD}", -1, -1, None),
    Among("\u{0BA8}\u{0BCD}", -1, -1, None),
    Among("\u{0BA8}\u{0BCD}\u{0BA4}", -1, -1, None),
];

static A_2: &'static [Among<Context>; 3] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_3: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9F}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BB1}", -1, -1, None),
];

static A_4: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9F}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BB1}", -1, -1, None),
];

static A_5: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9F}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BB1}", -1, -1, None),
];

static A_6: &'static [Among<Context>; 6] = &[
    Among("\u{0BAF}", -1, -1, None),
    Among("\u{0BB0}", -1, -1, None),
    Among("\u{0BB2}", -1, -1, None),
    Among("\u{0BB3}", -1, -1, None),
    Among("\u{0BB4}", -1, -1, None),
    Among("\u{0BB5}", -1, -1, None),
];

static A_7: &'static [Among<Context>; 6] = &[
    Among("\u{0B99}", -1, -1, None),
    Among("\u{0B9E}", -1, -1, None),
    Among("\u{0BA3}", -1, -1, None),
    Among("\u{0BA8}", -1, -1, None),
    Among("\u{0BA9}", -1, -1, None),
    Among("\u{0BAE}", -1, -1, None),
];

static A_8: &'static [Among<Context>; 3] = &[
    Among("\u{0BB5}\u{0BCD}", -1, -1, None),
    Among("\u{0BAF}", -1, -1, None),
    Among("\u{0BB5}", -1, -1, None),
];

static A_9: &'static [Among<Context>; 8] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC1}", -1, -1, None),
    Among("\u{0BC2}", -1, -1, None),
    Among("\u{0BC6}", -1, -1, None),
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_10: &'static [Among<Context>; 8] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC1}", -1, -1, None),
    Among("\u{0BC2}", -1, -1, None),
    Among("\u{0BC6}", -1, -1, None),
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_11: &'static [Among<Context>; 3] = &[
    Among("\u{0B85}", -1, -1, None),
    Among("\u{0B87}", -1, -1, None),
    Among("\u{0B89}", -1, -1, None),
];

static A_12: &'static [Among<Context>; 10] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B99}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9E}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BA8}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BAE}", -1, -1, None),
    Among("\u{0BAF}", -1, -1, None),
    Among("\u{0BB5}", -1, -1, None),
];

static A_13: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9F}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BB1}", -1, -1, None),
];

static A_14: &'static [Among<Context>; 3] = &[
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BCB}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
];

static A_15: &'static [Among<Context>; 2] = &[
    Among("\u{0BAA}\u{0BBF}", -1, -1, None),
    Among("\u{0BB5}\u{0BBF}", -1, -1, None),
];

static A_16: &'static [Among<Context>; 8] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC1}", -1, -1, None),
    Among("\u{0BC2}", -1, -1, None),
    Among("\u{0BC6}", -1, -1, None),
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_17: &'static [Among<Context>; 13] = &[
    Among("\u{0BAA}\u{0B9F}\u{0BCD}\u{0B9F}\u{0BC1}", -1, -1, None),
    Among("\u{0BB5}\u{0BBF}\u{0B9F}\u{0BCD}\u{0B9F}\u{0BC1}", -1, -1, None),
    Among("\u{0BAA}\u{0B9F}\u{0BC1}", -1, -1, None),
    Among("\u{0BB5}\u{0BBF}\u{0B9F}\u{0BC1}", -1, -1, None),
    Among("\u{0BAA}\u{0B9F}\u{0BCD}\u{0B9F}\u{0BA4}\u{0BC1}", -1, -1, None),
    Among("\u{0BC6}\u{0BB2}\u{0BCD}\u{0BB2}\u{0BBE}\u{0BAE}\u{0BCD}", -1, -1, None),
    Among("\u{0BAA}\u{0B9F}\u{0BCD}\u{0B9F}", -1, -1, None),
    Among("\u{0BAA}\u{0B9F}\u{0BCD}\u{0B9F}\u{0BA3}", -1, -1, None),
    Among("\u{0BA4}\u{0BBE}\u{0BA9}", -1, -1, None),
    Among("\u{0BAA}\u{0B9F}\u{0BBF}\u{0BA4}\u{0BBE}\u{0BA9}", 8, -1, None),
    Among("\u{0B95}\u{0BC1}\u{0BB0}\u{0BBF}\u{0BAF}", -1, -1, None),
    Among("\u{0BAA}\u{0B9F}\u{0BBF}", -1, -1, None),
    Among("\u{0BAA}\u{0BB1}\u{0BCD}\u{0BB1}\u{0BBF}", -1, -1, None),
];

static A_18: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9F}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BB1}", -1, -1, None),
];

static A_19: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}", -1, -1, None),
    Among("\u{0B9A}", -1, -1, None),
    Among("\u{0B9F}", -1, -1, None),
    Among("\u{0BA4}", -1, -1, None),
    Among("\u{0BAA}", -1, -1, None),
    Among("\u{0BB1}", -1, -1, None),
];

static A_20: &'static [Among<Context>; 8] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC1}", -1, -1, None),
    Among("\u{0BC2}", -1, -1, None),
    Among("\u{0BC6}", -1, -1, None),
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_21: &'static [Among<Context>; 8] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC1}", -1, -1, None),
    Among("\u{0BC2}", -1, -1, None),
    Among("\u{0BC6}", -1, -1, None),
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_22: &'static [Among<Context>; 2] = &[
    Among("\u{0BAA}\u{0B9F}\u{0BC1}", -1, -1, None),
    Among("\u{0B95}\u{0BCA}\u{0BA3}\u{0BCD}\u{0B9F}\u{0BBF}\u{0BB0}\u{0BCD}", -1, -1, None),
];

static A_23: &'static [Among<Context>; 12] = &[
    Among("\u{0B85}", -1, -1, None),
    Among("\u{0B86}", -1, -1, None),
    Among("\u{0B87}", -1, -1, None),
    Among("\u{0B88}", -1, -1, None),
    Among("\u{0B89}", -1, -1, None),
    Among("\u{0B8A}", -1, -1, None),
    Among("\u{0B8E}", -1, -1, None),
    Among("\u{0B8F}", -1, -1, None),
    Among("\u{0B90}", -1, -1, None),
    Among("\u{0B92}", -1, -1, None),
    Among("\u{0B93}", -1, -1, None),
    Among("\u{0B94}", -1, -1, None),
];

static A_24: &'static [Among<Context>; 8] = &[
    Among("\u{0BC0}", -1, -1, None),
    Among("\u{0BC1}", -1, -1, None),
    Among("\u{0BC2}", -1, -1, None),
    Among("\u{0BC6}", -1, -1, None),
    Among("\u{0BC7}", -1, -1, None),
    Among("\u{0BC8}", -1, -1, None),
    Among("\u{0BBE}", -1, -1, None),
    Among("\u{0BBF}", -1, -1, None),
];

static A_25: &'static [Among<Context>; 6] = &[
    Among("\u{0B95}\u{0BBF}\u{0BA9}\u{0BCD}\u{0BB1}\u{0BCD}", -1, -1, None),
    Among("\u{0BBE}\u{0BA8}\u{0BBF}\u{0BA9}\u{0BCD}\u{0BB1}\u{0BCD}", -1, -1, None),
    Among("\u{0B95}\u{0BBF}\u{0BB1}\u{0BCD}", -1, -1, None),
    Among("\u{0B95}\u{0BBF}\u{0BA9}\u{0BCD}\u{0BB1}", -1, -1, None),
    Among("\u{0BBE}\u{0BA8}\u{0BBF}\u{0BA9}\u{0BCD}\u{0BB1}", -1, -1, None),
    Among("\u{0B95}\u{0BBF}\u{0BB1}", -1, -1, None),
];

#[derive(Clone)]
struct Context {
    i_length: usize,
    b_found_wrong_ending: bool,
    b_found_vetrumai_urupu: bool,
    b_found_a_match: bool,
}

fn r_has_min_length(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 104
    context.i_length = env.current.chars().count();
    if !(context.i_length > 4){
        return false;
    }
    return true;
}

fn r_fix_va_start(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 109
    // or, line 110
    'lab0: loop {
        let v_1 = env.cursor;
        'lab1: loop {
            // (, line 110
            // and, line 110
            let v_2 = env.cursor;
            // try, line 110
            let v_3 = env.cursor;
            'lab2: loop {
                // literal, line 110
                if !env.eq_s(&"\u{0BB5}\u{0BCB}") {
                    env.cursor = v_3;
                    break 'lab2;
                }
                break 'lab2;
            }
            env.cursor = v_2;
            // [, line 110
            env.bra = env.cursor;
            // literal, line 110
            if !env.eq_s(&"\u{0BB5}\u{0BCB}") {
                break 'lab1;
            }
            // ], line 110
            env.ket = env.cursor;
            // <-, line 110
            if !env.slice_from("\u{0B93}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = v_1;
        'lab3: loop {
            // (, line 111
            // and, line 111
            let v_4 = env.cursor;
            // try, line 111
            let v_5 = env.cursor;
            'lab4: loop {
                // literal, line 111
                if !env.eq_s(&"\u{0BB5}\u{0BCA}") {
                    env.cursor = v_5;
                    break 'lab4;
                }
                break 'lab4;
            }
            env.cursor = v_4;
            // [, line 111
            env.bra = env.cursor;
            // literal, line 111
            if !env.eq_s(&"\u{0BB5}\u{0BCA}") {
                break 'lab3;
            }
            // ], line 111
            env.ket = env.cursor;
            // <-, line 111
            if !env.slice_from("\u{0B92}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = v_1;
        'lab5: loop {
            // (, line 112
            // and, line 112
            let v_6 = env.cursor;
            // try, line 112
            let v_7 = env.cursor;
            'lab6: loop {
                // literal, line 112
                if !env.eq_s(&"\u{0BB5}\u{0BC1}") {
                    env.cursor = v_7;
                    break 'lab6;
                }
                break 'lab6;
            }
            env.cursor = v_6;
            // [, line 112
            env.bra = env.cursor;
            // literal, line 112
            if !env.eq_s(&"\u{0BB5}\u{0BC1}") {
                break 'lab5;
            }
            // ], line 112
            env.ket = env.cursor;
            // <-, line 112
            if !env.slice_from("\u{0B89}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = v_1;
        // (, line 113
        // and, line 113
        let v_8 = env.cursor;
        // try, line 113
        let v_9 = env.cursor;
        'lab7: loop {
            // literal, line 113
            if !env.eq_s(&"\u{0BB5}\u{0BC2}") {
                env.cursor = v_9;
                break 'lab7;
            }
            break 'lab7;
        }
        env.cursor = v_8;
        // [, line 113
        env.bra = env.cursor;
        // literal, line 113
        if !env.eq_s(&"\u{0BB5}\u{0BC2}") {
            return false;
        }
        // ], line 113
        env.ket = env.cursor;
        // <-, line 113
        if !env.slice_from("\u{0B8A}") {
            return false;
        }
        break 'lab0;
    }
    return true;
}

fn r_fix_endings(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 116
    // set found_wrong_ending, line 117
    context.b_found_wrong_ending = true;
    // repeat, line 118
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 118
            // Boolean test found_wrong_ending, line 118
            if !context.b_found_wrong_ending {
                break 'lab1;
            }
            // (, line 118
            // do, line 118
            let v_2 = env.cursor;
            'lab2: loop {
                // call fix_ending, line 118
                if !r_fix_ending(env, context) {
                    break 'lab2;
                }
                break 'lab2;
            }
            env.cursor = v_2;
            continue 'replab0;
        }
        env.cursor = v_1;
        break 'replab0;
    }
    return true;
}

fn r_remove_question_prefixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 121
    // [, line 122
    env.bra = env.cursor;
    // (, line 122
    // literal, line 122
    if !env.eq_s(&"\u{0B8E}") {
        return false;
    }
    // among, line 122
    if env.find_among(A_0, context) == 0 {
        return false;
    }
    // literal, line 122
    if !env.eq_s(&"\u{0BCD}") {
        return false;
    }
    // ], line 122
    env.ket = env.cursor;
    // delete, line 122
    if !env.slice_del() {
        return false;
    }
    // do, line 123
    let v_1 = env.cursor;
    'lab0: loop {
        // call fix_va_start, line 123
        if !r_fix_va_start(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    return true;
}

fn r_fix_ending(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 126
    // unset found_wrong_ending, line 127
    context.b_found_wrong_ending = false;
    context.i_length = env.current.chars().count();
    if !(context.i_length > 3){
        return false;
    }
    // backwards, line 130
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 130
    // or, line 132
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 131
            // [, line 131
            env.ket = env.cursor;
            // among, line 131
            if env.find_among_b(A_1, context) == 0 {
                break 'lab1;
            }
            // ], line 131
            env.bra = env.cursor;
            // delete, line 131
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab2: loop {
            // (, line 133
            // [, line 133
            env.ket = env.cursor;
            // literal, line 133
            if !env.eq_s_b(&"\u{0BAF}\u{0BCD}") {
                break 'lab2;
            }
            // test, line 133
            let v_2 = env.limit - env.cursor;
            // among, line 133
            if env.find_among_b(A_2, context) == 0 {
                break 'lab2;
            }
            env.cursor = env.limit - v_2;
            // ], line 133
            env.bra = env.cursor;
            // delete, line 133
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab3: loop {
            // (, line 135
            // [, line 135
            env.ket = env.cursor;
            // or, line 135
            'lab4: loop {
                let v_3 = env.limit - env.cursor;
                'lab5: loop {
                    // literal, line 135
                    if !env.eq_s_b(&"\u{0B9F}\u{0BCD}\u{0BAA}\u{0BCD}") {
                        break 'lab5;
                    }
                    break 'lab4;
                }
                env.cursor = env.limit - v_3;
                // literal, line 135
                if !env.eq_s_b(&"\u{0B9F}\u{0BCD}\u{0B95}\u{0BCD}") {
                    break 'lab3;
                }
                break 'lab4;
            }
            // ], line 135
            env.bra = env.cursor;
            // <-, line 135
            if !env.slice_from("\u{0BB3}\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab6: loop {
            // (, line 137
            // [, line 137
            env.ket = env.cursor;
            // literal, line 137
            if !env.eq_s_b(&"\u{0BA9}\u{0BCD}\u{0BB1}\u{0BCD}") {
                break 'lab6;
            }
            // ], line 137
            env.bra = env.cursor;
            // <-, line 137
            if !env.slice_from("\u{0BB2}\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab7: loop {
            // (, line 140
            // [, line 140
            env.ket = env.cursor;
            // literal, line 140
            if !env.eq_s_b(&"\u{0BB1}\u{0BCD}\u{0B95}\u{0BCD}") {
                break 'lab7;
            }
            // ], line 140
            env.bra = env.cursor;
            // <-, line 140
            if !env.slice_from("\u{0BB2}\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab8: loop {
            // (, line 142
            // [, line 142
            env.ket = env.cursor;
            // literal, line 142
            if !env.eq_s_b(&"\u{0B9F}\u{0BCD}\u{0B9F}\u{0BCD}") {
                break 'lab8;
            }
            // ], line 142
            env.bra = env.cursor;
            // <-, line 142
            if !env.slice_from("\u{0B9F}\u{0BC1}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab9: loop {
            // (, line 144
            // Boolean test found_vetrumai_urupu, line 144
            if !context.b_found_vetrumai_urupu {
                break 'lab9;
            }
            // [, line 144
            env.ket = env.cursor;
            // literal, line 144
            if !env.eq_s_b(&"\u{0BA4}\u{0BCD}\u{0BA4}\u{0BCD}") {
                break 'lab9;
            }
            // (, line 144
            // test, line 144
            let v_4 = env.limit - env.cursor;
            // not, line 144
            let v_5 = env.limit - env.cursor;
            'lab10: loop {
                // literal, line 144
                if !env.eq_s_b(&"\u{0BC8}") {
                    break 'lab10;
                }
                break 'lab9;
            }
            env.cursor = env.limit - v_5;
            env.cursor = env.limit - v_4;
            // ], line 144
            env.bra = env.cursor;
            // <-, line 144
            if !env.slice_from("\u{0BAE}\u{0BCD}") {
                return false;
            }
            // ], line 144
            env.bra = env.cursor;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab11: loop {
            // (, line 146
            // [, line 146
            env.ket = env.cursor;
            // or, line 146
            'lab12: loop {
                let v_6 = env.limit - env.cursor;
                'lab13: loop {
                    // literal, line 146
                    if !env.eq_s_b(&"\u{0BC1}\u{0B95}\u{0BCD}") {
                        break 'lab13;
                    }
                    break 'lab12;
                }
                env.cursor = env.limit - v_6;
                // literal, line 146
                if !env.eq_s_b(&"\u{0BC1}\u{0B95}\u{0BCD}\u{0B95}\u{0BCD}") {
                    break 'lab11;
                }
                break 'lab12;
            }
            // ], line 146
            env.bra = env.cursor;
            // <-, line 146
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab14: loop {
            // (, line 148
            // [, line 148
            env.ket = env.cursor;
            // literal, line 148
            if !env.eq_s_b(&"\u{0BCD}") {
                break 'lab14;
            }
            // among, line 148
            if env.find_among_b(A_3, context) == 0 {
                break 'lab14;
            }
            // literal, line 148
            if !env.eq_s_b(&"\u{0BCD}") {
                break 'lab14;
            }
            // among, line 148
            if env.find_among_b(A_4, context) == 0 {
                break 'lab14;
            }
            // ], line 148
            env.bra = env.cursor;
            // delete, line 148
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab15: loop {
            // (, line 150
            // [, line 150
            env.ket = env.cursor;
            // literal, line 150
            if !env.eq_s_b(&"\u{0BC1}\u{0B95}\u{0BCD}") {
                break 'lab15;
            }
            // ], line 150
            env.bra = env.cursor;
            // <-, line 150
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab16: loop {
            // (, line 152
            // [, line 152
            env.ket = env.cursor;
            // literal, line 152
            if !env.eq_s_b(&"\u{0BCD}") {
                break 'lab16;
            }
            // among, line 152
            if env.find_among_b(A_5, context) == 0 {
                break 'lab16;
            }
            // ], line 152
            env.bra = env.cursor;
            // delete, line 152
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab17: loop {
            // (, line 154
            // [, line 154
            env.ket = env.cursor;
            // literal, line 154
            if !env.eq_s_b(&"\u{0BCD}") {
                break 'lab17;
            }
            // (, line 154
            // or, line 154
            'lab18: loop {
                let v_7 = env.limit - env.cursor;
                'lab19: loop {
                    // among, line 154
                    if env.find_among_b(A_6, context) == 0 {
                        break 'lab19;
                    }
                    break 'lab18;
                }
                env.cursor = env.limit - v_7;
                // among, line 154
                if env.find_among_b(A_7, context) == 0 {
                    break 'lab17;
                }
                break 'lab18;
            }
            // literal, line 154
            if !env.eq_s_b(&"\u{0BCD}") {
                break 'lab17;
            }
            // ], line 154
            env.bra = env.cursor;
            // <-, line 154
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab20: loop {
            // (, line 156
            // [, line 156
            env.ket = env.cursor;
            // among, line 156
            if env.find_among_b(A_8, context) == 0 {
                break 'lab20;
            }
            // ], line 156
            env.bra = env.cursor;
            // delete, line 156
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab21: loop {
            // (, line 158
            // [, line 158
            env.ket = env.cursor;
            // literal, line 158
            if !env.eq_s_b(&"\u{0BA9}\u{0BC1}") {
                break 'lab21;
            }
            // (, line 158
            // test, line 158
            let v_8 = env.limit - env.cursor;
            // not, line 158
            let v_9 = env.limit - env.cursor;
            'lab22: loop {
                // among, line 158
                if env.find_among_b(A_9, context) == 0 {
                    break 'lab22;
                }
                break 'lab21;
            }
            env.cursor = env.limit - v_9;
            env.cursor = env.limit - v_8;
            // ], line 158
            env.bra = env.cursor;
            // delete, line 158
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab23: loop {
            // (, line 160
            // [, line 160
            env.ket = env.cursor;
            // literal, line 160
            if !env.eq_s_b(&"\u{0B99}\u{0BCD}") {
                break 'lab23;
            }
            // (, line 160
            // test, line 160
            let v_10 = env.limit - env.cursor;
            // not, line 160
            let v_11 = env.limit - env.cursor;
            'lab24: loop {
                // literal, line 160
                if !env.eq_s_b(&"\u{0BC8}") {
                    break 'lab24;
                }
                break 'lab23;
            }
            env.cursor = env.limit - v_11;
            env.cursor = env.limit - v_10;
            // ], line 160
            env.bra = env.cursor;
            // <-, line 160
            if !env.slice_from("\u{0BAE}\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab25: loop {
            // (, line 162
            // [, line 162
            env.ket = env.cursor;
            // literal, line 162
            if !env.eq_s_b(&"\u{0B99}\u{0BCD}") {
                break 'lab25;
            }
            // ], line 162
            env.bra = env.cursor;
            // delete, line 162
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 164
        // [, line 164
        env.ket = env.cursor;
        // literal, line 164
        if !env.eq_s_b(&"\u{0BCD}") {
            return false;
        }
        // (, line 164
        // test, line 164
        let v_12 = env.limit - env.cursor;
        // (, line 164
        // or, line 164
        'lab26: loop {
            let v_13 = env.limit - env.cursor;
            'lab27: loop {
                // among, line 164
                if env.find_among_b(A_10, context) == 0 {
                    break 'lab27;
                }
                break 'lab26;
            }
            env.cursor = env.limit - v_13;
            // literal, line 164
            if !env.eq_s_b(&"\u{0BCD}") {
                return false;
            }
            break 'lab26;
        }
        env.cursor = env.limit - v_12;
        // ], line 164
        env.bra = env.cursor;
        // delete, line 164
        if !env.slice_del() {
            return false;
        }
        break 'lab0;
    }
    env.cursor = env.limit_backward;
    // set found_wrong_ending, line 167
    context.b_found_wrong_ending = true;
    return true;
}

fn r_remove_pronoun_prefixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 170
    // unset found_a_match, line 171
    context.b_found_a_match = false;
    // [, line 172
    env.bra = env.cursor;
    // among, line 172
    if env.find_among(A_11, context) == 0 {
        return false;
    }
    // among, line 172
    if env.find_among(A_12, context) == 0 {
        return false;
    }
    // literal, line 172
    if !env.eq_s(&"\u{0BCD}") {
        return false;
    }
    // ], line 172
    env.ket = env.cursor;
    // delete, line 172
    if !env.slice_del() {
        return false;
    }
    // (, line 173
    // set found_a_match, line 173
    context.b_found_a_match = true;
    // do, line 174
    let v_1 = env.cursor;
    'lab0: loop {
        // call fix_va_start, line 174
        if !r_fix_va_start(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    return true;
}

fn r_remove_plural_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 177
    // unset found_a_match, line 178
    context.b_found_a_match = false;
    // backwards, line 179
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 179
    // or, line 180
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 180
            // [, line 180
            env.ket = env.cursor;
            // literal, line 180
            if !env.eq_s_b(&"\u{0BC1}\u{0B99}\u{0BCD}\u{0B95}\u{0BB3}\u{0BCD}") {
                break 'lab1;
            }
            // (, line 180
            // test, line 180
            let v_2 = env.limit - env.cursor;
            // not, line 180
            let v_3 = env.limit - env.cursor;
            'lab2: loop {
                // among, line 180
                if env.find_among_b(A_13, context) == 0 {
                    break 'lab2;
                }
                break 'lab1;
            }
            env.cursor = env.limit - v_3;
            env.cursor = env.limit - v_2;
            // ], line 180
            env.bra = env.cursor;
            // <-, line 180
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab3: loop {
            // (, line 181
            // [, line 181
            env.ket = env.cursor;
            // literal, line 181
            if !env.eq_s_b(&"\u{0BB1}\u{0BCD}\u{0B95}\u{0BB3}\u{0BCD}") {
                break 'lab3;
            }
            // ], line 181
            env.bra = env.cursor;
            // <-, line 181
            if !env.slice_from("\u{0BB2}\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab4: loop {
            // (, line 182
            // [, line 182
            env.ket = env.cursor;
            // literal, line 182
            if !env.eq_s_b(&"\u{0B9F}\u{0BCD}\u{0B95}\u{0BB3}\u{0BCD}") {
                break 'lab4;
            }
            // ], line 182
            env.bra = env.cursor;
            // <-, line 182
            if !env.slice_from("\u{0BB3}\u{0BCD}") {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 183
        // [, line 183
        env.ket = env.cursor;
        // literal, line 183
        if !env.eq_s_b(&"\u{0B95}\u{0BB3}\u{0BCD}") {
            return false;
        }
        // ], line 183
        env.bra = env.cursor;
        // delete, line 183
        if !env.slice_del() {
            return false;
        }
        break 'lab0;
    }
    // (, line 184
    // set found_a_match, line 184
    context.b_found_a_match = true;
    env.cursor = env.limit_backward;
    return true;
}

fn r_remove_question_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 188
    // call has_min_length, line 189
    if !r_has_min_length(env, context) {
        return false;
    }
    // unset found_a_match, line 190
    context.b_found_a_match = false;
    // backwards, line 191
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 191
    // do, line 192
    let v_1 = env.limit - env.cursor;
    'lab0: loop {
        // (, line 192
        // [, line 193
        env.ket = env.cursor;
        // among, line 193
        if env.find_among_b(A_14, context) == 0 {
            break 'lab0;
        }
        // ], line 193
        env.bra = env.cursor;
        // <-, line 193
        if !env.slice_from("\u{0BCD}") {
            return false;
        }
        // (, line 194
        // set found_a_match, line 194
        context.b_found_a_match = true;
        break 'lab0;
    }
    env.cursor = env.limit - v_1;
    env.cursor = env.limit_backward;
    // do, line 197
    let v_2 = env.cursor;
    'lab1: loop {
        // call fix_endings, line 197
        if !r_fix_endings(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = v_2;
    return true;
}

fn r_remove_command_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 200
    // call has_min_length, line 201
    if !r_has_min_length(env, context) {
        return false;
    }
    // unset found_a_match, line 202
    context.b_found_a_match = false;
    // backwards, line 203
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 203
    // [, line 204
    env.ket = env.cursor;
    // among, line 204
    if env.find_among_b(A_15, context) == 0 {
        return false;
    }
    // ], line 204
    env.bra = env.cursor;
    // delete, line 204
    if !env.slice_del() {
        return false;
    }
    // (, line 205
    // set found_a_match, line 205
    context.b_found_a_match = true;
    env.cursor = env.limit_backward;
    return true;
}

fn r_remove_um(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 209
    // unset found_a_match, line 210
    context.b_found_a_match = false;
    // call has_min_length, line 211
    if !r_has_min_length(env, context) {
        return false;
    }
    // backwards, line 212
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 212
    // [, line 212
    env.ket = env.cursor;
    // literal, line 212
    if !env.eq_s_b(&"\u{0BC1}\u{0BAE}\u{0BCD}") {
        return false;
    }
    // ], line 212
    env.bra = env.cursor;
    // <-, line 212
    if !env.slice_from("\u{0BCD}") {
        return false;
    }
    // (, line 213
    // set found_a_match, line 213
    context.b_found_a_match = true;
    env.cursor = env.limit_backward;
    // do, line 215
    let v_1 = env.cursor;
    'lab0: loop {
        // call fix_ending, line 215
        if !r_fix_ending(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    return true;
}

fn r_remove_common_word_endings(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 218
    // unset found_a_match, line 222
    context.b_found_a_match = false;
    // call has_min_length, line 223
    if !r_has_min_length(env, context) {
        return false;
    }
    // backwards, line 224
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 224
    // or, line 241
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // test, line 225
            let v_2 = env.limit - env.cursor;
            // (, line 225
            // [, line 225
            env.ket = env.cursor;
            // or, line 225
            'lab2: loop {
                let v_3 = env.limit - env.cursor;
                'lab3: loop {
                    // literal, line 225
                    if !env.eq_s_b(&"\u{0BC1}\u{0B9F}\u{0BA9}\u{0BCD}") {
                        break 'lab3;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab4: loop {
                    // literal, line 226
                    if !env.eq_s_b(&"\u{0BBF}\u{0BB2}\u{0BCD}\u{0BB2}\u{0BC8}") {
                        break 'lab4;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab5: loop {
                    // literal, line 227
                    if !env.eq_s_b(&"\u{0BBF}\u{0B9F}\u{0BAE}\u{0BCD}") {
                        break 'lab5;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab6: loop {
                    // literal, line 228
                    if !env.eq_s_b(&"\u{0BBF}\u{0BA9}\u{0BCD}\u{0BB1}\u{0BBF}") {
                        break 'lab6;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab7: loop {
                    // literal, line 229
                    if !env.eq_s_b(&"\u{0BBE}\u{0B95}\u{0BBF}") {
                        break 'lab7;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab8: loop {
                    // literal, line 230
                    if !env.eq_s_b(&"\u{0BBE}\u{0B95}\u{0BBF}\u{0BAF}") {
                        break 'lab8;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab9: loop {
                    // literal, line 231
                    if !env.eq_s_b(&"\u{0BC6}\u{0BA9}\u{0BCD}\u{0BB1}\u{0BC1}") {
                        break 'lab9;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab10: loop {
                    // literal, line 232
                    if !env.eq_s_b(&"\u{0BC1}\u{0BB3}\u{0BCD}\u{0BB3}") {
                        break 'lab10;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab11: loop {
                    // literal, line 233
                    if !env.eq_s_b(&"\u{0BC1}\u{0B9F}\u{0BC8}\u{0BAF}") {
                        break 'lab11;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab12: loop {
                    // literal, line 234
                    if !env.eq_s_b(&"\u{0BC1}\u{0B9F}\u{0BC8}") {
                        break 'lab12;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab13: loop {
                    // literal, line 235
                    if !env.eq_s_b(&"\u{0BC6}\u{0BA9}\u{0BC1}\u{0BAE}\u{0BCD}") {
                        break 'lab13;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab14: loop {
                    // (, line 236
                    // literal, line 236
                    if !env.eq_s_b(&"\u{0BB2}\u{0BCD}\u{0BB2}") {
                        break 'lab14;
                    }
                    // test, line 236
                    let v_4 = env.limit - env.cursor;
                    // (, line 236
                    // not, line 236
                    let v_5 = env.limit - env.cursor;
                    'lab15: loop {
                        // among, line 236
                        if env.find_among_b(A_16, context) == 0 {
                            break 'lab15;
                        }
                        break 'lab14;
                    }
                    env.cursor = env.limit - v_5;
                    env.cursor = env.limit - v_4;
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                'lab16: loop {
                    // literal, line 237
                    if !env.eq_s_b(&"\u{0BC6}\u{0BA9}") {
                        break 'lab16;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_3;
                // literal, line 238
                if !env.eq_s_b(&"\u{0BBE}\u{0B95}\u{0BBF}") {
                    break 'lab1;
                }
                break 'lab2;
            }
            // ], line 238
            env.bra = env.cursor;
            // <-, line 238
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            // (, line 239
            // set found_a_match, line 239
            context.b_found_a_match = true;
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // test, line 242
        let v_6 = env.limit - env.cursor;
        // (, line 242
        // [, line 242
        env.ket = env.cursor;
        // among, line 242
        if env.find_among_b(A_17, context) == 0 {
            return false;
        }
        // ], line 255
        env.bra = env.cursor;
        // delete, line 255
        if !env.slice_del() {
            return false;
        }
        // (, line 256
        // set found_a_match, line 256
        context.b_found_a_match = true;
        env.cursor = env.limit - v_6;
        break 'lab0;
    }
    env.cursor = env.limit_backward;
    // do, line 259
    let v_7 = env.cursor;
    'lab17: loop {
        // call fix_endings, line 259
        if !r_fix_endings(env, context) {
            break 'lab17;
        }
        break 'lab17;
    }
    env.cursor = v_7;
    return true;
}

fn r_remove_vetrumai_urupukal(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 262
    // unset found_a_match, line 263
    context.b_found_a_match = false;
    // unset found_vetrumai_urupu, line 264
    context.b_found_vetrumai_urupu = false;
    // call has_min_length, line 265
    if !r_has_min_length(env, context) {
        return false;
    }
    // backwards, line 266
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 266
    // (, line 267
    // or, line 269
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // test, line 268
            let v_2 = env.limit - env.cursor;
            // (, line 268
            // [, line 268
            env.ket = env.cursor;
            // literal, line 268
            if !env.eq_s_b(&"\u{0BA9}\u{0BC8}") {
                break 'lab1;
            }
            // ], line 268
            env.bra = env.cursor;
            // delete, line 268
            if !env.slice_del() {
                return false;
            }
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab2: loop {
            // test, line 270
            let v_3 = env.limit - env.cursor;
            // (, line 270
            // [, line 270
            env.ket = env.cursor;
            // or, line 271
            'lab3: loop {
                let v_4 = env.limit - env.cursor;
                'lab4: loop {
                    // (, line 270
                    // or, line 270
                    'lab5: loop {
                        let v_5 = env.limit - env.cursor;
                        'lab6: loop {
                            // literal, line 270
                            if !env.eq_s_b(&"\u{0BBF}\u{0BA9}\u{0BC8}") {
                                break 'lab6;
                            }
                            break 'lab5;
                        }
                        env.cursor = env.limit - v_5;
                        // literal, line 271
                        if !env.eq_s_b(&"\u{0BC8}") {
                            break 'lab4;
                        }
                        break 'lab5;
                    }
                    // (, line 271
                    // test, line 271
                    let v_6 = env.limit - env.cursor;
                    // not, line 271
                    let v_7 = env.limit - env.cursor;
                    'lab7: loop {
                        // among, line 271
                        if env.find_among_b(A_18, context) == 0 {
                            break 'lab7;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_7;
                    env.cursor = env.limit - v_6;
                    break 'lab3;
                }
                env.cursor = env.limit - v_4;
                // (, line 272
                // literal, line 272
                if !env.eq_s_b(&"\u{0BC8}") {
                    break 'lab2;
                }
                // (, line 272
                // test, line 272
                let v_8 = env.limit - env.cursor;
                // (, line 272
                // among, line 272
                if env.find_among_b(A_19, context) == 0 {
                    break 'lab2;
                }
                // literal, line 272
                if !env.eq_s_b(&"\u{0BCD}") {
                    break 'lab2;
                }
                env.cursor = env.limit - v_8;
                break 'lab3;
            }
            // ], line 273
            env.bra = env.cursor;
            // <-, line 273
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            env.cursor = env.limit - v_3;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab8: loop {
            // test, line 276
            let v_9 = env.limit - env.cursor;
            // (, line 276
            // [, line 276
            env.ket = env.cursor;
            // or, line 277
            'lab9: loop {
                let v_10 = env.limit - env.cursor;
                'lab10: loop {
                    // literal, line 277
                    if !env.eq_s_b(&"\u{0BCA}\u{0B9F}\u{0BC1}") {
                        break 'lab10;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab11: loop {
                    // literal, line 278
                    if !env.eq_s_b(&"\u{0BCB}\u{0B9F}\u{0BC1}") {
                        break 'lab11;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab12: loop {
                    // literal, line 279
                    if !env.eq_s_b(&"\u{0BBF}\u{0BB2}\u{0BCD}") {
                        break 'lab12;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab13: loop {
                    // literal, line 280
                    if !env.eq_s_b(&"\u{0BBF}\u{0BB1}\u{0BCD}") {
                        break 'lab13;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab14: loop {
                    // (, line 281
                    // literal, line 281
                    if !env.eq_s_b(&"\u{0BBF}\u{0BA9}\u{0BCD}") {
                        break 'lab14;
                    }
                    // (, line 281
                    // test, line 281
                    let v_11 = env.limit - env.cursor;
                    // not, line 281
                    let v_12 = env.limit - env.cursor;
                    'lab15: loop {
                        // literal, line 281
                        if !env.eq_s_b(&"\u{0BAE}") {
                            break 'lab15;
                        }
                        break 'lab14;
                    }
                    env.cursor = env.limit - v_12;
                    env.cursor = env.limit - v_11;
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab16: loop {
                    // literal, line 282
                    if !env.eq_s_b(&"\u{0BBF}\u{0BA9}\u{0BCD}\u{0BB1}\u{0BC1}") {
                        break 'lab16;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab17: loop {
                    // literal, line 283
                    if !env.eq_s_b(&"\u{0BBF}\u{0BB0}\u{0BC1}\u{0BA8}\u{0BCD}\u{0BA4}\u{0BC1}") {
                        break 'lab17;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab18: loop {
                    // literal, line 284
                    if !env.eq_s_b(&"\u{0BB5}\u{0BBF}\u{0B9F}") {
                        break 'lab18;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab19: loop {
                    // (, line 285
                    if !(context.i_length >= 7){
                        break 'lab19;
                    }
                    // literal, line 285
                    if !env.eq_s_b(&"\u{0BBF}\u{0B9F}\u{0BAE}\u{0BCD}") {
                        break 'lab19;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab20: loop {
                    // literal, line 286
                    if !env.eq_s_b(&"\u{0BBE}\u{0BB2}\u{0BCD}") {
                        break 'lab20;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab21: loop {
                    // literal, line 287
                    if !env.eq_s_b(&"\u{0BC1}\u{0B9F}\u{0BC8}") {
                        break 'lab21;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab22: loop {
                    // literal, line 288
                    if !env.eq_s_b(&"\u{0BBE}\u{0BAE}\u{0BB2}\u{0BCD}") {
                        break 'lab22;
                    }
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                'lab23: loop {
                    // (, line 289
                    // literal, line 289
                    if !env.eq_s_b(&"\u{0BB2}\u{0BCD}") {
                        break 'lab23;
                    }
                    // (, line 289
                    // test, line 289
                    let v_13 = env.limit - env.cursor;
                    // not, line 289
                    let v_14 = env.limit - env.cursor;
                    'lab24: loop {
                        // among, line 289
                        if env.find_among_b(A_20, context) == 0 {
                            break 'lab24;
                        }
                        break 'lab23;
                    }
                    env.cursor = env.limit - v_14;
                    env.cursor = env.limit - v_13;
                    break 'lab9;
                }
                env.cursor = env.limit - v_10;
                // literal, line 290
                if !env.eq_s_b(&"\u{0BC1}\u{0BB3}\u{0BCD}") {
                    break 'lab8;
                }
                break 'lab9;
            }
            // ], line 291
            env.bra = env.cursor;
            // <-, line 291
            if !env.slice_from("\u{0BCD}") {
                return false;
            }
            env.cursor = env.limit - v_9;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab25: loop {
            // test, line 294
            let v_15 = env.limit - env.cursor;
            // (, line 294
            // [, line 294
            env.ket = env.cursor;
            // or, line 295
            'lab26: loop {
                let v_16 = env.limit - env.cursor;
                'lab27: loop {
                    // literal, line 295
                    if !env.eq_s_b(&"\u{0B95}\u{0BA3}\u{0BCD}") {
                        break 'lab27;
                    }
                    break 'lab26;
                }
                env.cursor = env.limit - v_16;
                'lab28: loop {
                    // literal, line 296
                    if !env.eq_s_b(&"\u{0BAE}\u{0BC1}\u{0BA9}\u{0BCD}") {
                        break 'lab28;
                    }
                    break 'lab26;
                }
                env.cursor = env.limit - v_16;
                'lab29: loop {
                    // literal, line 297
                    if !env.eq_s_b(&"\u{0BAE}\u{0BC7}\u{0BB2}\u{0BCD}") {
                        break 'lab29;
                    }
                    break 'lab26;
                }
                env.cursor = env.limit - v_16;
                'lab30: loop {
                    // literal, line 298
                    if !env.eq_s_b(&"\u{0BAE}\u{0BC7}\u{0BB1}\u{0BCD}") {
                        break 'lab30;
                    }
                    break 'lab26;
                }
                env.cursor = env.limit - v_16;
                'lab31: loop {
                    // literal, line 299
                    if !env.eq_s_b(&"\u{0B95}\u{0BC0}\u{0BB4}\u{0BCD}") {
                        break 'lab31;
                    }
                    break 'lab26;
                }
                env.cursor = env.limit - v_16;
                'lab32: loop {
                    // literal, line 300
                    if !env.eq_s_b(&"\u{0BAA}\u{0BBF}\u{0BA9}\u{0BCD}") {
                        break 'lab32;
                    }
                    break 'lab26;
                }
                env.cursor = env.limit - v_16;
                // (, line 301
                // literal, line 301
                if !env.eq_s_b(&"\u{0BA4}\u{0BC1}") {
                    break 'lab25;
                }
                // (, line 301
                // test, line 301
                let v_17 = env.limit - env.cursor;
                // not, line 301
                let v_18 = env.limit - env.cursor;
                'lab33: loop {
                    // among, line 301
                    if env.find_among_b(A_21, context) == 0 {
                        break 'lab33;
                    }
                    break 'lab25;
                }
                env.cursor = env.limit - v_18;
                env.cursor = env.limit - v_17;
                break 'lab26;
            }
            // ], line 302
            env.bra = env.cursor;
            // delete, line 302
            if !env.slice_del() {
                return false;
            }
            env.cursor = env.limit - v_15;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // test, line 305
        let v_19 = env.limit - env.cursor;
        // (, line 305
        // [, line 305
        env.ket = env.cursor;
        // literal, line 305
        if !env.eq_s_b(&"\u{0BC0}") {
            return false;
        }
        // ], line 305
        env.bra = env.cursor;
        // <-, line 305
        if !env.slice_from("\u{0BBF}") {
            return false;
        }
        env.cursor = env.limit - v_19;
        break 'lab0;
    }
    // (, line 307
    // set found_a_match, line 307
    context.b_found_a_match = true;
    // (, line 308
    // set found_vetrumai_urupu, line 308
    context.b_found_vetrumai_urupu = true;
    // do, line 309
    let v_20 = env.limit - env.cursor;
    'lab34: loop {
        // (, line 309
        // [, line 309
        env.ket = env.cursor;
        // literal, line 309
        if !env.eq_s_b(&"\u{0BBF}\u{0BA9}\u{0BCD}") {
            break 'lab34;
        }
        // ], line 309
        env.bra = env.cursor;
        // <-, line 309
        if !env.slice_from("\u{0BCD}") {
            return false;
        }
        break 'lab34;
    }
    env.cursor = env.limit - v_20;
    env.cursor = env.limit_backward;
    // do, line 311
    let v_21 = env.cursor;
    'lab35: loop {
        // call fix_endings, line 311
        if !r_fix_endings(env, context) {
            break 'lab35;
        }
        break 'lab35;
    }
    env.cursor = v_21;
    return true;
}

fn r_remove_tense_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 314
    // set found_a_match, line 315
    context.b_found_a_match = true;
    // repeat, line 316
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 316
            // Boolean test found_a_match, line 316
            if !context.b_found_a_match {
                break 'lab1;
            }
            // (, line 316
            // do, line 316
            let v_2 = env.cursor;
            'lab2: loop {
                // call remove_tense_suffix, line 316
                if !r_remove_tense_suffix(env, context) {
                    break 'lab2;
                }
                break 'lab2;
            }
            env.cursor = v_2;
            continue 'replab0;
        }
        env.cursor = v_1;
        break 'replab0;
    }
    return true;
}

fn r_remove_tense_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 319
    // unset found_a_match, line 320
    context.b_found_a_match = false;
    // call has_min_length, line 321
    if !r_has_min_length(env, context) {
        return false;
    }
    // backwards, line 322
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 322
    // do, line 323
    let v_1 = env.limit - env.cursor;
    'lab0: loop {
        // (, line 323
        // or, line 330
        'lab1: loop {
            let v_2 = env.limit - env.cursor;
            'lab2: loop {
                // test, line 324
                let v_3 = env.limit - env.cursor;
                // (, line 324
                // [, line 324
                env.ket = env.cursor;
                // among, line 324
                if env.find_among_b(A_22, context) == 0 {
                    break 'lab2;
                }
                // ], line 327
                env.bra = env.cursor;
                // delete, line 327
                if !env.slice_del() {
                    return false;
                }
                // (, line 328
                // set found_a_match, line 328
                context.b_found_a_match = true;
                env.cursor = env.limit - v_3;
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            'lab3: loop {
                // test, line 331
                let v_4 = env.limit - env.cursor;
                // (, line 331
                // [, line 331
                env.ket = env.cursor;
                // or, line 332
                'lab4: loop {
                    let v_5 = env.limit - env.cursor;
                    'lab5: loop {
                        // literal, line 332
                        if !env.eq_s_b(&"\u{0BAE}\u{0BBE}\u{0BB0}\u{0BCD}") {
                            break 'lab5;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab6: loop {
                        // literal, line 333
                        if !env.eq_s_b(&"\u{0BAE}\u{0BBF}\u{0BA9}\u{0BCD}") {
                            break 'lab6;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab7: loop {
                        // literal, line 334
                        if !env.eq_s_b(&"\u{0BA9}\u{0BA9}\u{0BCD}") {
                            break 'lab7;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab8: loop {
                        // literal, line 335
                        if !env.eq_s_b(&"\u{0BA9}\u{0BBE}\u{0BA9}\u{0BCD}") {
                            break 'lab8;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab9: loop {
                        // literal, line 336
                        if !env.eq_s_b(&"\u{0BA9}\u{0BBE}\u{0BB3}\u{0BCD}") {
                            break 'lab9;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab10: loop {
                        // literal, line 337
                        if !env.eq_s_b(&"\u{0BA9}\u{0BBE}\u{0BB0}\u{0BCD}") {
                            break 'lab10;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab11: loop {
                        // (, line 338
                        // literal, line 338
                        if !env.eq_s_b(&"\u{0BB5}\u{0BA9}\u{0BCD}") {
                            break 'lab11;
                        }
                        // test, line 338
                        let v_6 = env.limit - env.cursor;
                        // (, line 338
                        // not, line 338
                        let v_7 = env.limit - env.cursor;
                        'lab12: loop {
                            // among, line 338
                            if env.find_among_b(A_23, context) == 0 {
                                break 'lab12;
                            }
                            break 'lab11;
                        }
                        env.cursor = env.limit - v_7;
                        env.cursor = env.limit - v_6;
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab13: loop {
                        // literal, line 339
                        if !env.eq_s_b(&"\u{0BA9}\u{0BB3}\u{0BCD}") {
                            break 'lab13;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab14: loop {
                        // literal, line 340
                        if !env.eq_s_b(&"\u{0BB5}\u{0BB3}\u{0BCD}") {
                            break 'lab14;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab15: loop {
                        // literal, line 341
                        if !env.eq_s_b(&"\u{0BA9}\u{0BB0}\u{0BCD}") {
                            break 'lab15;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab16: loop {
                        // literal, line 342
                        if !env.eq_s_b(&"\u{0BB5}\u{0BB0}\u{0BCD}") {
                            break 'lab16;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab17: loop {
                        // literal, line 343
                        if !env.eq_s_b(&"\u{0BA9}") {
                            break 'lab17;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab18: loop {
                        // literal, line 343
                        if !env.eq_s_b(&"\u{0BAA}") {
                            break 'lab18;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab19: loop {
                        // literal, line 343
                        if !env.eq_s_b(&"\u{0B95}") {
                            break 'lab19;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab20: loop {
                        // literal, line 343
                        if !env.eq_s_b(&"\u{0BA4}") {
                            break 'lab20;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab21: loop {
                        // literal, line 343
                        if !env.eq_s_b(&"\u{0BAF}") {
                            break 'lab21;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab22: loop {
                        // literal, line 344
                        if !env.eq_s_b(&"\u{0BAA}\u{0BA9}\u{0BCD}") {
                            break 'lab22;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab23: loop {
                        // literal, line 345
                        if !env.eq_s_b(&"\u{0BAA}\u{0BB3}\u{0BCD}") {
                            break 'lab23;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab24: loop {
                        // literal, line 346
                        if !env.eq_s_b(&"\u{0BAA}\u{0BB0}\u{0BCD}") {
                            break 'lab24;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab25: loop {
                        // (, line 347
                        // literal, line 347
                        if !env.eq_s_b(&"\u{0BA4}\u{0BC1}") {
                            break 'lab25;
                        }
                        // (, line 347
                        // test, line 347
                        let v_8 = env.limit - env.cursor;
                        // not, line 347
                        let v_9 = env.limit - env.cursor;
                        'lab26: loop {
                            // among, line 347
                            if env.find_among_b(A_24, context) == 0 {
                                break 'lab26;
                            }
                            break 'lab25;
                        }
                        env.cursor = env.limit - v_9;
                        env.cursor = env.limit - v_8;
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab27: loop {
                        // literal, line 348
                        if !env.eq_s_b(&"\u{0BBF}\u{0BB1}\u{0BCD}\u{0BB1}\u{0BC1}") {
                            break 'lab27;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab28: loop {
                        // literal, line 349
                        if !env.eq_s_b(&"\u{0BAA}\u{0BAE}\u{0BCD}") {
                            break 'lab28;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab29: loop {
                        // literal, line 350
                        if !env.eq_s_b(&"\u{0BA9}\u{0BAE}\u{0BCD}") {
                            break 'lab29;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab30: loop {
                        // literal, line 351
                        if !env.eq_s_b(&"\u{0BA4}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab30;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab31: loop {
                        // literal, line 352
                        if !env.eq_s_b(&"\u{0BB1}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab31;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab32: loop {
                        // literal, line 353
                        if !env.eq_s_b(&"\u{0B95}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab32;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab33: loop {
                        // literal, line 354
                        if !env.eq_s_b(&"\u{0BA9}\u{0BC6}\u{0BA9}\u{0BCD}") {
                            break 'lab33;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    'lab34: loop {
                        // literal, line 355
                        if !env.eq_s_b(&"\u{0BA9}\u{0BC8}") {
                            break 'lab34;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_5;
                    // literal, line 356
                    if !env.eq_s_b(&"\u{0BB5}\u{0BC8}") {
                        break 'lab3;
                    }
                    break 'lab4;
                }
                // ], line 357
                env.bra = env.cursor;
                // delete, line 357
                if !env.slice_del() {
                    return false;
                }
                // (, line 358
                // set found_a_match, line 358
                context.b_found_a_match = true;
                env.cursor = env.limit - v_4;
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            'lab35: loop {
                // test, line 361
                let v_10 = env.limit - env.cursor;
                // (, line 361
                // [, line 361
                env.ket = env.cursor;
                // or, line 362
                'lab36: loop {
                    let v_11 = env.limit - env.cursor;
                    'lab37: loop {
                        // (, line 362
                        // literal, line 362
                        if !env.eq_s_b(&"\u{0BBE}\u{0BA9}\u{0BCD}") {
                            break 'lab37;
                        }
                        // test, line 362
                        let v_12 = env.limit - env.cursor;
                        // (, line 362
                        // not, line 362
                        let v_13 = env.limit - env.cursor;
                        'lab38: loop {
                            // literal, line 362
                            if !env.eq_s_b(&"\u{0B9A}") {
                                break 'lab38;
                            }
                            break 'lab37;
                        }
                        env.cursor = env.limit - v_13;
                        env.cursor = env.limit - v_12;
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab39: loop {
                        // literal, line 363
                        if !env.eq_s_b(&"\u{0BBE}\u{0BB3}\u{0BCD}") {
                            break 'lab39;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab40: loop {
                        // literal, line 364
                        if !env.eq_s_b(&"\u{0BBE}\u{0BB0}\u{0BCD}") {
                            break 'lab40;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab41: loop {
                        // literal, line 365
                        if !env.eq_s_b(&"\u{0BC7}\u{0BA9}\u{0BCD}") {
                            break 'lab41;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab42: loop {
                        // literal, line 366
                        if !env.eq_s_b(&"\u{0BBE}") {
                            break 'lab42;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab43: loop {
                        // literal, line 367
                        if !env.eq_s_b(&"\u{0BBE}\u{0BAE}\u{0BCD}") {
                            break 'lab43;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab44: loop {
                        // literal, line 368
                        if !env.eq_s_b(&"\u{0BC6}\u{0BAE}\u{0BCD}") {
                            break 'lab44;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab45: loop {
                        // literal, line 369
                        if !env.eq_s_b(&"\u{0BC7}\u{0BAE}\u{0BCD}") {
                            break 'lab45;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab46: loop {
                        // literal, line 370
                        if !env.eq_s_b(&"\u{0BCB}\u{0BAE}\u{0BCD}") {
                            break 'lab46;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab47: loop {
                        // literal, line 371
                        if !env.eq_s_b(&"\u{0B95}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab47;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab48: loop {
                        // literal, line 372
                        if !env.eq_s_b(&"\u{0BA4}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab48;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab49: loop {
                        // literal, line 373
                        if !env.eq_s_b(&"\u{0B9F}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab49;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab50: loop {
                        // literal, line 374
                        if !env.eq_s_b(&"\u{0BB1}\u{0BC1}\u{0BAE}\u{0BCD}") {
                            break 'lab50;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab51: loop {
                        // literal, line 375
                        if !env.eq_s_b(&"\u{0BBE}\u{0BAF}\u{0BCD}") {
                            break 'lab51;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab52: loop {
                        // literal, line 376
                        if !env.eq_s_b(&"\u{0BA9}\u{0BC6}\u{0BA9}\u{0BCD}") {
                            break 'lab52;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab53: loop {
                        // literal, line 377
                        if !env.eq_s_b(&"\u{0BA9}\u{0BBF}\u{0BB0}\u{0BCD}") {
                            break 'lab53;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    'lab54: loop {
                        // literal, line 378
                        if !env.eq_s_b(&"\u{0BC0}\u{0BB0}\u{0BCD}") {
                            break 'lab54;
                        }
                        break 'lab36;
                    }
                    env.cursor = env.limit - v_11;
                    // literal, line 379
                    if !env.eq_s_b(&"\u{0BC0}\u{0BAF}\u{0BB0}\u{0BCD}") {
                        break 'lab35;
                    }
                    break 'lab36;
                }
                // ], line 380
                env.bra = env.cursor;
                // <-, line 380
                if !env.slice_from("\u{0BCD}") {
                    return false;
                }
                // (, line 381
                // set found_a_match, line 381
                context.b_found_a_match = true;
                env.cursor = env.limit - v_10;
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            // test, line 384
            let v_14 = env.limit - env.cursor;
            // (, line 384
            // (, line 384
            // [, line 384
            env.ket = env.cursor;
            // or, line 384
            'lab55: loop {
                let v_15 = env.limit - env.cursor;
                'lab56: loop {
                    // literal, line 384
                    if !env.eq_s_b(&"\u{0B95}\u{0BC1}") {
                        break 'lab56;
                    }
                    break 'lab55;
                }
                env.cursor = env.limit - v_15;
                // literal, line 384
                if !env.eq_s_b(&"\u{0BA4}\u{0BC1}") {
                    break 'lab0;
                }
                break 'lab55;
            }
            // (, line 384
            // test, line 384
            let v_16 = env.limit - env.cursor;
            // literal, line 384
            if !env.eq_s_b(&"\u{0BCD}") {
                break 'lab0;
            }
            env.cursor = env.limit - v_16;
            // ], line 384
            env.bra = env.cursor;
            // delete, line 384
            if !env.slice_del() {
                return false;
            }
            // (, line 385
            // set found_a_match, line 385
            context.b_found_a_match = true;
            env.cursor = env.limit - v_14;
            break 'lab1;
        }
        break 'lab0;
    }
    env.cursor = env.limit - v_1;
    // do, line 388
    let v_17 = env.limit - env.cursor;
    'lab57: loop {
        // (, line 388
        // [, line 388
        env.ket = env.cursor;
        // among, line 388
        if env.find_among_b(A_25, context) == 0 {
            break 'lab57;
        }
        // ], line 395
        env.bra = env.cursor;
        // delete, line 395
        if !env.slice_del() {
            return false;
        }
        // (, line 396
        // set found_a_match, line 396
        context.b_found_a_match = true;
        break 'lab57;
    }
    env.cursor = env.limit - v_17;
    env.cursor = env.limit_backward;
    // do, line 399
    let v_18 = env.cursor;
    'lab58: loop {
        // call fix_endings, line 399
        if !r_fix_endings(env, context) {
            break 'lab58;
        }
        break 'lab58;
    }
    env.cursor = v_18;
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        i_length: 0,
        b_found_wrong_ending: false,
        b_found_vetrumai_urupu: false,
        b_found_a_match: false,
    };
    // (, line 402
    // unset found_vetrumai_urupu, line 403
    context.b_found_vetrumai_urupu = false;
    // do, line 404
    let v_1 = env.cursor;
    'lab0: loop {
        // call fix_ending, line 404
        if !r_fix_ending(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // call has_min_length, line 405
    if !r_has_min_length(env, context) {
        return false;
    }
    // do, line 406
    let v_2 = env.cursor;
    'lab1: loop {
        // call remove_question_prefixes, line 406
        if !r_remove_question_prefixes(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = v_2;
    // do, line 407
    let v_3 = env.cursor;
    'lab2: loop {
        // call remove_pronoun_prefixes, line 407
        if !r_remove_pronoun_prefixes(env, context) {
            break 'lab2;
        }
        break 'lab2;
    }
    env.cursor = v_3;
    // do, line 408
    let v_4 = env.cursor;
    'lab3: loop {
        // call remove_question_suffixes, line 408
        if !r_remove_question_suffixes(env, context) {
            break 'lab3;
        }
        break 'lab3;
    }
    env.cursor = v_4;
    // do, line 409
    let v_5 = env.cursor;
    'lab4: loop {
        // call remove_um, line 409
        if !r_remove_um(env, context) {
            break 'lab4;
        }
        break 'lab4;
    }
    env.cursor = v_5;
    // do, line 410
    let v_6 = env.cursor;
    'lab5: loop {
        // call remove_common_word_endings, line 410
        if !r_remove_common_word_endings(env, context) {
            break 'lab5;
        }
        break 'lab5;
    }
    env.cursor = v_6;
    // do, line 411
    let v_7 = env.cursor;
    'lab6: loop {
        // call remove_vetrumai_urupukal, line 411
        if !r_remove_vetrumai_urupukal(env, context) {
            break 'lab6;
        }
        break 'lab6;
    }
    env.cursor = v_7;
    // do, line 412
    let v_8 = env.cursor;
    'lab7: loop {
        // call remove_plural_suffix, line 412
        if !r_remove_plural_suffix(env, context) {
            break 'lab7;
        }
        break 'lab7;
    }
    env.cursor = v_8;
    // do, line 413
    let v_9 = env.cursor;
    'lab8: loop {
        // call remove_command_suffixes, line 413
        if !r_remove_command_suffixes(env, context) {
            break 'lab8;
        }
        break 'lab8;
    }
    env.cursor = v_9;
    // do, line 414
    let v_10 = env.cursor;
    'lab9: loop {
        // call remove_tense_suffixes, line 414
        if !r_remove_tense_suffixes(env, context) {
            break 'lab9;
        }
        break 'lab9;
    }
    env.cursor = v_10;
    return true;
}
