rust-stemmers 1.2.0

//! 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>; 3] = &[
    Among("", -1, 3, None),
    Among("I", 0, 1, None),
    Among("U", 0, 2, None),
];

static A_1: &'static [Among<Context>; 16] = &[
    Among("ea", -1, 3, None),
    Among("a\u{0163}ia", -1, 7, None),
    Among("aua", -1, 2, None),
    Among("iua", -1, 4, None),
    Among("a\u{0163}ie", -1, 7, None),
    Among("ele", -1, 3, None),
    Among("ile", -1, 5, None),
    Among("iile", 6, 4, None),
    Among("iei", -1, 4, None),
    Among("atei", -1, 6, None),
    Among("ii", -1, 4, None),
    Among("ului", -1, 1, None),
    Among("ul", -1, 1, None),
    Among("elor", -1, 3, None),
    Among("ilor", -1, 4, None),
    Among("iilor", 14, 4, None),
];

static A_2: &'static [Among<Context>; 46] = &[
    Among("icala", -1, 4, None),
    Among("iciva", -1, 4, None),
    Among("ativa", -1, 5, None),
    Among("itiva", -1, 6, None),
    Among("icale", -1, 4, None),
    Among("a\u{0163}iune", -1, 5, None),
    Among("i\u{0163}iune", -1, 6, None),
    Among("atoare", -1, 5, None),
    Among("itoare", -1, 6, None),
    Among("\u{0103}toare", -1, 5, None),
    Among("icitate", -1, 4, None),
    Among("abilitate", -1, 1, None),
    Among("ibilitate", -1, 2, None),
    Among("ivitate", -1, 3, None),
    Among("icive", -1, 4, None),
    Among("ative", -1, 5, None),
    Among("itive", -1, 6, None),
    Among("icali", -1, 4, None),
    Among("atori", -1, 5, None),
    Among("icatori", 18, 4, None),
    Among("itori", -1, 6, None),
    Among("\u{0103}tori", -1, 5, None),
    Among("icitati", -1, 4, None),
    Among("abilitati", -1, 1, None),
    Among("ivitati", -1, 3, None),
    Among("icivi", -1, 4, None),
    Among("ativi", -1, 5, None),
    Among("itivi", -1, 6, None),
    Among("icit\u{0103}i", -1, 4, None),
    Among("abilit\u{0103}i", -1, 1, None),
    Among("ivit\u{0103}i", -1, 3, None),
    Among("icit\u{0103}\u{0163}i", -1, 4, None),
    Among("abilit\u{0103}\u{0163}i", -1, 1, None),
    Among("ivit\u{0103}\u{0163}i", -1, 3, None),
    Among("ical", -1, 4, None),
    Among("ator", -1, 5, None),
    Among("icator", 35, 4, None),
    Among("itor", -1, 6, None),
    Among("\u{0103}tor", -1, 5, None),
    Among("iciv", -1, 4, None),
    Among("ativ", -1, 5, None),
    Among("itiv", -1, 6, None),
    Among("ical\u{0103}", -1, 4, None),
    Among("iciv\u{0103}", -1, 4, None),
    Among("ativ\u{0103}", -1, 5, None),
    Among("itiv\u{0103}", -1, 6, None),
];

static A_3: &'static [Among<Context>; 62] = &[
    Among("ica", -1, 1, None),
    Among("abila", -1, 1, None),
    Among("ibila", -1, 1, None),
    Among("oasa", -1, 1, None),
    Among("ata", -1, 1, None),
    Among("ita", -1, 1, None),
    Among("anta", -1, 1, None),
    Among("ista", -1, 3, None),
    Among("uta", -1, 1, None),
    Among("iva", -1, 1, None),
    Among("ic", -1, 1, None),
    Among("ice", -1, 1, None),
    Among("abile", -1, 1, None),
    Among("ibile", -1, 1, None),
    Among("isme", -1, 3, None),
    Among("iune", -1, 2, None),
    Among("oase", -1, 1, None),
    Among("ate", -1, 1, None),
    Among("itate", 17, 1, None),
    Among("ite", -1, 1, None),
    Among("ante", -1, 1, None),
    Among("iste", -1, 3, None),
    Among("ute", -1, 1, None),
    Among("ive", -1, 1, None),
    Among("ici", -1, 1, None),
    Among("abili", -1, 1, None),
    Among("ibili", -1, 1, None),
    Among("iuni", -1, 2, None),
    Among("atori", -1, 1, None),
    Among("osi", -1, 1, None),
    Among("ati", -1, 1, None),
    Among("itati", 30, 1, None),
    Among("iti", -1, 1, None),
    Among("anti", -1, 1, None),
    Among("isti", -1, 3, None),
    Among("uti", -1, 1, None),
    Among("i\u{015F}ti", -1, 3, None),
    Among("ivi", -1, 1, None),
    Among("it\u{0103}i", -1, 1, None),
    Among("o\u{015F}i", -1, 1, None),
    Among("it\u{0103}\u{0163}i", -1, 1, None),
    Among("abil", -1, 1, None),
    Among("ibil", -1, 1, None),
    Among("ism", -1, 3, None),
    Among("ator", -1, 1, None),
    Among("os", -1, 1, None),
    Among("at", -1, 1, None),
    Among("it", -1, 1, None),
    Among("ant", -1, 1, None),
    Among("ist", -1, 3, None),
    Among("ut", -1, 1, None),
    Among("iv", -1, 1, None),
    Among("ic\u{0103}", -1, 1, None),
    Among("abil\u{0103}", -1, 1, None),
    Among("ibil\u{0103}", -1, 1, None),
    Among("oas\u{0103}", -1, 1, None),
    Among("at\u{0103}", -1, 1, None),
    Among("it\u{0103}", -1, 1, None),
    Among("ant\u{0103}", -1, 1, None),
    Among("ist\u{0103}", -1, 3, None),
    Among("ut\u{0103}", -1, 1, None),
    Among("iv\u{0103}", -1, 1, None),
];

static A_4: &'static [Among<Context>; 94] = &[
    Among("ea", -1, 1, None),
    Among("ia", -1, 1, None),
    Among("esc", -1, 1, None),
    Among("\u{0103}sc", -1, 1, None),
    Among("ind", -1, 1, None),
    Among("\u{00E2}nd", -1, 1, None),
    Among("are", -1, 1, None),
    Among("ere", -1, 1, None),
    Among("ire", -1, 1, None),
    Among("\u{00E2}re", -1, 1, None),
    Among("se", -1, 2, None),
    Among("ase", 10, 1, None),
    Among("sese", 10, 2, None),
    Among("ise", 10, 1, None),
    Among("use", 10, 1, None),
    Among("\u{00E2}se", 10, 1, None),
    Among("e\u{015F}te", -1, 1, None),
    Among("\u{0103}\u{015F}te", -1, 1, None),
    Among("eze", -1, 1, None),
    Among("ai", -1, 1, None),
    Among("eai", 19, 1, None),
    Among("iai", 19, 1, None),
    Among("sei", -1, 2, None),
    Among("e\u{015F}ti", -1, 1, None),
    Among("\u{0103}\u{015F}ti", -1, 1, None),
    Among("ui", -1, 1, None),
    Among("ezi", -1, 1, None),
    Among("a\u{015F}i", -1, 1, None),
    Among("se\u{015F}i", -1, 2, None),
    Among("ase\u{015F}i", 28, 1, None),
    Among("sese\u{015F}i", 28, 2, None),
    Among("ise\u{015F}i", 28, 1, None),
    Among("use\u{015F}i", 28, 1, None),
    Among("\u{00E2}se\u{015F}i", 28, 1, None),
    Among("i\u{015F}i", -1, 1, None),
    Among("u\u{015F}i", -1, 1, None),
    Among("\u{00E2}\u{015F}i", -1, 1, None),
    Among("\u{00E2}i", -1, 1, None),
    Among("a\u{0163}i", -1, 2, None),
    Among("ea\u{0163}i", 38, 1, None),
    Among("ia\u{0163}i", 38, 1, None),
    Among("e\u{0163}i", -1, 2, None),
    Among("i\u{0163}i", -1, 2, None),
    Among("ar\u{0103}\u{0163}i", -1, 1, None),
    Among("ser\u{0103}\u{0163}i", -1, 2, None),
    Among("aser\u{0103}\u{0163}i", 44, 1, None),
    Among("seser\u{0103}\u{0163}i", 44, 2, None),
    Among("iser\u{0103}\u{0163}i", 44, 1, None),
    Among("user\u{0103}\u{0163}i", 44, 1, None),
    Among("\u{00E2}ser\u{0103}\u{0163}i", 44, 1, None),
    Among("ir\u{0103}\u{0163}i", -1, 1, None),
    Among("ur\u{0103}\u{0163}i", -1, 1, None),
    Among("\u{00E2}r\u{0103}\u{0163}i", -1, 1, None),
    Among("\u{00E2}\u{0163}i", -1, 2, None),
    Among("am", -1, 1, None),
    Among("eam", 54, 1, None),
    Among("iam", 54, 1, None),
    Among("em", -1, 2, None),
    Among("asem", 57, 1, None),
    Among("sesem", 57, 2, None),
    Among("isem", 57, 1, None),
    Among("usem", 57, 1, None),
    Among("\u{00E2}sem", 57, 1, None),
    Among("im", -1, 2, None),
    Among("\u{0103}m", -1, 2, None),
    Among("ar\u{0103}m", 64, 1, None),
    Among("ser\u{0103}m", 64, 2, None),
    Among("aser\u{0103}m", 66, 1, None),
    Among("seser\u{0103}m", 66, 2, None),
    Among("iser\u{0103}m", 66, 1, None),
    Among("user\u{0103}m", 66, 1, None),
    Among("\u{00E2}ser\u{0103}m", 66, 1, None),
    Among("ir\u{0103}m", 64, 1, None),
    Among("ur\u{0103}m", 64, 1, None),
    Among("\u{00E2}r\u{0103}m", 64, 1, None),
    Among("\u{00E2}m", -1, 2, None),
    Among("au", -1, 1, None),
    Among("eau", 76, 1, None),
    Among("iau", 76, 1, None),
    Among("indu", -1, 1, None),
    Among("\u{00E2}ndu", -1, 1, None),
    Among("ez", -1, 1, None),
    Among("easc\u{0103}", -1, 1, None),
    Among("ar\u{0103}", -1, 1, None),
    Among("ser\u{0103}", -1, 2, None),
    Among("aser\u{0103}", 84, 1, None),
    Among("seser\u{0103}", 84, 2, None),
    Among("iser\u{0103}", 84, 1, None),
    Among("user\u{0103}", 84, 1, None),
    Among("\u{00E2}ser\u{0103}", 84, 1, None),
    Among("ir\u{0103}", -1, 1, None),
    Among("ur\u{0103}", -1, 1, None),
    Among("\u{00E2}r\u{0103}", -1, 1, None),
    Among("eaz\u{0103}", -1, 1, None),
];

static A_5: &'static [Among<Context>; 5] = &[
    Among("a", -1, 1, None),
    Among("e", -1, 1, None),
    Among("ie", 1, 1, None),
    Among("i", -1, 1, None),
    Among("\u{0103}", -1, 1, None),
];

static G_v: &'static [u8; 21] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 32, 0, 0, 4];

#[derive(Clone)]
struct Context {
    b_standard_suffix_removed: bool,
    i_p2: usize,
    i_p1: usize,
    i_pV: usize,
}

fn r_prelude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 30
    // repeat, line 31
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // goto, line 31
            'golab2: loop {
                let v_2 = env.cursor;
                'lab3: loop {
                    // (, line 31
                    if !env.in_grouping(G_v, 97, 259) {
                        break 'lab3;
                    }
                    // [, line 32
                    env.bra = env.cursor;
                    // or, line 32
                    'lab4: loop {
                        let v_3 = env.cursor;
                        'lab5: loop {
                            // (, line 32
                            // literal, line 32
                            if !env.eq_s(&"u") {
                                break 'lab5;
                            }
                            // ], line 32
                            env.ket = env.cursor;
                            if !env.in_grouping(G_v, 97, 259) {
                                break 'lab5;
                            }
                            // <-, line 32
                            if !env.slice_from("U") {
                                return false;
                            }
                            break 'lab4;
                        }
                        env.cursor = v_3;
                        // (, line 33
                        // literal, line 33
                        if !env.eq_s(&"i") {
                            break 'lab3;
                        }
                        // ], line 33
                        env.ket = env.cursor;
                        if !env.in_grouping(G_v, 97, 259) {
                            break 'lab3;
                        }
                        // <-, line 33
                        if !env.slice_from("I") {
                            return false;
                        }
                        break 'lab4;
                    }
                    env.cursor = v_2;
                    break 'golab2;
                }
                env.cursor = v_2;
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            continue 'replab0;
        }
        env.cursor = v_1;
        break 'replab0;
    }
    return true;
}

fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 37
    context.i_pV = env.limit;
    context.i_p1 = env.limit;
    context.i_p2 = env.limit;
    // do, line 43
    let v_1 = env.cursor;
    'lab0: loop {
        // (, line 43
        // or, line 45
        'lab1: loop {
            let v_2 = env.cursor;
            'lab2: loop {
                // (, line 44
                if !env.in_grouping(G_v, 97, 259) {
                    break 'lab2;
                }
                // or, line 44
                'lab3: loop {
                    let v_3 = env.cursor;
                    'lab4: loop {
                        // (, line 44
                        if !env.out_grouping(G_v, 97, 259) {
                            break 'lab4;
                        }
                        // gopast, line 44
                        'golab5: loop {
                            'lab6: loop {
                                if !env.in_grouping(G_v, 97, 259) {
                                    break 'lab6;
                                }
                                break 'golab5;
                            }
                            if env.cursor >= env.limit {
                                break 'lab4;
                            }
                            env.next_char();
                        }
                        break 'lab3;
                    }
                    env.cursor = v_3;
                    // (, line 44
                    if !env.in_grouping(G_v, 97, 259) {
                        break 'lab2;
                    }
                    // gopast, line 44
                    'golab7: loop {
                        'lab8: loop {
                            if !env.out_grouping(G_v, 97, 259) {
                                break 'lab8;
                            }
                            break 'golab7;
                        }
                        if env.cursor >= env.limit {
                            break 'lab2;
                        }
                        env.next_char();
                    }
                    break 'lab3;
                }
                break 'lab1;
            }
            env.cursor = v_2;
            // (, line 46
            if !env.out_grouping(G_v, 97, 259) {
                break 'lab0;
            }
            // or, line 46
            'lab9: loop {
                let v_6 = env.cursor;
                'lab10: loop {
                    // (, line 46
                    if !env.out_grouping(G_v, 97, 259) {
                        break 'lab10;
                    }
                    // gopast, line 46
                    'golab11: loop {
                        'lab12: loop {
                            if !env.in_grouping(G_v, 97, 259) {
                                break 'lab12;
                            }
                            break 'golab11;
                        }
                        if env.cursor >= env.limit {
                            break 'lab10;
                        }
                        env.next_char();
                    }
                    break 'lab9;
                }
                env.cursor = v_6;
                // (, line 46
                if !env.in_grouping(G_v, 97, 259) {
                    break 'lab0;
                }
                // next, line 46
                if env.cursor >= env.limit {
                    break 'lab0;
                }
                env.next_char();
                break 'lab9;
            }
            break 'lab1;
        }
        // setmark pV, line 47
        context.i_pV = env.cursor;
        break 'lab0;
    }
    env.cursor = v_1;
    // do, line 49
    let v_8 = env.cursor;
    'lab13: loop {
        // (, line 49
        // gopast, line 50
        'golab14: loop {
            'lab15: loop {
                if !env.in_grouping(G_v, 97, 259) {
                    break 'lab15;
                }
                break 'golab14;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // gopast, line 50
        'golab16: loop {
            'lab17: loop {
                if !env.out_grouping(G_v, 97, 259) {
                    break 'lab17;
                }
                break 'golab16;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // setmark p1, line 50
        context.i_p1 = env.cursor;
        // gopast, line 51
        'golab18: loop {
            'lab19: loop {
                if !env.in_grouping(G_v, 97, 259) {
                    break 'lab19;
                }
                break 'golab18;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // gopast, line 51
        'golab20: loop {
            'lab21: loop {
                if !env.out_grouping(G_v, 97, 259) {
                    break 'lab21;
                }
                break 'golab20;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // setmark p2, line 51
        context.i_p2 = env.cursor;
        break 'lab13;
    }
    env.cursor = v_8;
    return true;
}

fn r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // repeat, line 55
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 55
            // [, line 57
            env.bra = env.cursor;
            // substring, line 57
            among_var = env.find_among(A_0, context);
            if among_var == 0 {
                break 'lab1;
            }
            // ], line 57
            env.ket = env.cursor;
            if among_var == 0 {
                break 'lab1;
            } else if among_var == 1 {
                // (, line 58
                // <-, line 58
                if !env.slice_from("i") {
                    return false;
                }
            } else if among_var == 2 {
                // (, line 59
                // <-, line 59
                if !env.slice_from("u") {
                    return false;
                }
            } else if among_var == 3 {
                // (, line 60
                // next, line 60
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            continue 'replab0;
        }
        env.cursor = v_1;
        break 'replab0;
    }
    return true;
}

fn r_RV(env: &mut SnowballEnv, context: &mut Context) -> bool {
    if !(context.i_pV <= env.cursor){
        return false;
    }
    return true;
}

fn r_R1(env: &mut SnowballEnv, context: &mut Context) -> bool {
    if !(context.i_p1 <= env.cursor){
        return false;
    }
    return true;
}

fn r_R2(env: &mut SnowballEnv, context: &mut Context) -> bool {
    if !(context.i_p2 <= env.cursor){
        return false;
    }
    return true;
}

fn r_step_0(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 71
    // [, line 72
    env.ket = env.cursor;
    // substring, line 72
    among_var = env.find_among_b(A_1, context);
    if among_var == 0 {
        return false;
    }
    // ], line 72
    env.bra = env.cursor;
    // call R1, line 72
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 74
        // delete, line 74
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 76
        // <-, line 76
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 78
        // <-, line 78
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 80
        // <-, line 80
        if !env.slice_from("i") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 82
        // not, line 82
        let v_1 = env.limit - env.cursor;
        'lab0: loop {
            // literal, line 82
            if !env.eq_s_b(&"ab") {
                break 'lab0;
            }
            return false;
        }
        env.cursor = env.limit - v_1;
        // <-, line 82
        if !env.slice_from("i") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 84
        // <-, line 84
        if !env.slice_from("at") {
            return false;
        }
    } else if among_var == 7 {
        // (, line 86
        // <-, line 86
        if !env.slice_from("a\u{0163}i") {
            return false;
        }
    }
    return true;
}

fn r_combo_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // test, line 90
    let v_1 = env.limit - env.cursor;
    // (, line 90
    // [, line 91
    env.ket = env.cursor;
    // substring, line 91
    among_var = env.find_among_b(A_2, context);
    if among_var == 0 {
        return false;
    }
    // ], line 91
    env.bra = env.cursor;
    // call R1, line 91
    if !r_R1(env, context) {
        return false;
    }
    // (, line 91
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 99
        // <-, line 100
        if !env.slice_from("abil") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 102
        // <-, line 103
        if !env.slice_from("ibil") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 105
        // <-, line 106
        if !env.slice_from("iv") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 111
        // <-, line 112
        if !env.slice_from("ic") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 116
        // <-, line 117
        if !env.slice_from("at") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 120
        // <-, line 121
        if !env.slice_from("it") {
            return false;
        }
    }
    // set standard_suffix_removed, line 124
    context.b_standard_suffix_removed = true;
    env.cursor = env.limit - v_1;
    return true;
}

fn r_standard_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 128
    // unset standard_suffix_removed, line 129
    context.b_standard_suffix_removed = false;
    // repeat, line 130
    'replab0: loop{
        let v_1 = env.limit - env.cursor;
        'lab1: for _ in 0..1 {
            // call combo_suffix, line 130
            if !r_combo_suffix(env, context) {
                break 'lab1;
            }
            continue 'replab0;
        }
        env.cursor = env.limit - v_1;
        break 'replab0;
    }
    // [, line 131
    env.ket = env.cursor;
    // substring, line 131
    among_var = env.find_among_b(A_3, context);
    if among_var == 0 {
        return false;
    }
    // ], line 131
    env.bra = env.cursor;
    // call R2, line 131
    if !r_R2(env, context) {
        return false;
    }
    // (, line 131
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 147
        // delete, line 148
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 150
        // literal, line 151
        if !env.eq_s_b(&"\u{0163}") {
            return false;
        }
        // ], line 151
        env.bra = env.cursor;
        // <-, line 151
        if !env.slice_from("t") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 154
        // <-, line 155
        if !env.slice_from("ist") {
            return false;
        }
    }
    // set standard_suffix_removed, line 159
    context.b_standard_suffix_removed = true;
    return true;
}

fn r_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // setlimit, line 163
    let v_1 = env.limit - env.cursor;
    // tomark, line 163
    if env.cursor < context.i_pV {
        return false;
    }
    env.cursor = context.i_pV;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 163
    // [, line 164
    env.ket = env.cursor;
    // substring, line 164
    among_var = env.find_among_b(A_4, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 164
    env.bra = env.cursor;
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    } else if among_var == 1 {
        // (, line 199
        // or, line 199
        'lab0: loop {
            let v_3 = env.limit - env.cursor;
            'lab1: loop {
                if !env.out_grouping_b(G_v, 97, 259) {
                    break 'lab1;
                }
                break 'lab0;
            }
            env.cursor = env.limit - v_3;
            // literal, line 199
            if !env.eq_s_b(&"u") {
                env.limit_backward = v_2;
                return false;
            }
            break 'lab0;
        }
        // delete, line 199
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 213
        // delete, line 213
        if !env.slice_del() {
            return false;
        }
    }
    env.limit_backward = v_2;
    return true;
}

fn r_vowel_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 217
    // [, line 218
    env.ket = env.cursor;
    // substring, line 218
    among_var = env.find_among_b(A_5, context);
    if among_var == 0 {
        return false;
    }
    // ], line 218
    env.bra = env.cursor;
    // call RV, line 218
    if !r_RV(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 219
        // delete, line 219
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        b_standard_suffix_removed: false,
        i_p2: 0,
        i_p1: 0,
        i_pV: 0,
    };
    // (, line 224
    // do, line 225
    let v_1 = env.cursor;
    'lab0: loop {
        // call prelude, line 225
        if !r_prelude(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // do, line 226
    let v_2 = env.cursor;
    'lab1: loop {
        // call mark_regions, line 226
        if !r_mark_regions(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = v_2;
    // backwards, line 227
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 227
    // do, line 228
    let v_3 = env.limit - env.cursor;
    'lab2: loop {
        // call step_0, line 228
        if !r_step_0(env, context) {
            break 'lab2;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_3;
    // do, line 229
    let v_4 = env.limit - env.cursor;
    'lab3: loop {
        // call standard_suffix, line 229
        if !r_standard_suffix(env, context) {
            break 'lab3;
        }
        break 'lab3;
    }
    env.cursor = env.limit - v_4;
    // do, line 230
    let v_5 = env.limit - env.cursor;
    'lab4: loop {
        // (, line 230
        // or, line 230
        'lab5: loop {
            let v_6 = env.limit - env.cursor;
            'lab6: loop {
                // Boolean test standard_suffix_removed, line 230
                if !context.b_standard_suffix_removed {
                    break 'lab6;
                }
                break 'lab5;
            }
            env.cursor = env.limit - v_6;
            // call verb_suffix, line 230
            if !r_verb_suffix(env, context) {
                break 'lab4;
            }
            break 'lab5;
        }
        break 'lab4;
    }
    env.cursor = env.limit - v_5;
    // do, line 231
    let v_7 = env.limit - env.cursor;
    'lab7: loop {
        // call vowel_suffix, line 231
        if !r_vowel_suffix(env, context) {
            break 'lab7;
        }
        break 'lab7;
    }
    env.cursor = env.limit - v_7;
    env.cursor = env.limit_backward;
    // do, line 233
    let v_8 = env.cursor;
    'lab8: loop {
        // call postlude, line 233
        if !r_postlude(env, context) {
            break 'lab8;
        }
        break 'lab8;
    }
    env.cursor = v_8;
    return true;
}