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>; 6] = &[
    Among("", -1, 6, None),
    Among("\u{00E1}", 0, 1, None),
    Among("\u{00E9}", 0, 2, None),
    Among("\u{00ED}", 0, 3, None),
    Among("\u{00F3}", 0, 4, None),
    Among("\u{00FA}", 0, 5, None),
];

static A_1: &'static [Among<Context>; 13] = &[
    Among("la", -1, -1, None),
    Among("sela", 0, -1, None),
    Among("le", -1, -1, None),
    Among("me", -1, -1, None),
    Among("se", -1, -1, None),
    Among("lo", -1, -1, None),
    Among("selo", 5, -1, None),
    Among("las", -1, -1, None),
    Among("selas", 7, -1, None),
    Among("les", -1, -1, None),
    Among("los", -1, -1, None),
    Among("selos", 10, -1, None),
    Among("nos", -1, -1, None),
];

static A_2: &'static [Among<Context>; 11] = &[
    Among("ando", -1, 6, None),
    Among("iendo", -1, 6, None),
    Among("yendo", -1, 7, None),
    Among("\u{00E1}ndo", -1, 2, None),
    Among("i\u{00E9}ndo", -1, 1, None),
    Among("ar", -1, 6, None),
    Among("er", -1, 6, None),
    Among("ir", -1, 6, None),
    Among("\u{00E1}r", -1, 3, None),
    Among("\u{00E9}r", -1, 4, None),
    Among("\u{00ED}r", -1, 5, None),
];

static A_3: &'static [Among<Context>; 4] = &[
    Among("ic", -1, -1, None),
    Among("ad", -1, -1, None),
    Among("os", -1, -1, None),
    Among("iv", -1, 1, None),
];

static A_4: &'static [Among<Context>; 3] = &[
    Among("able", -1, 1, None),
    Among("ible", -1, 1, None),
    Among("ante", -1, 1, None),
];

static A_5: &'static [Among<Context>; 3] = &[
    Among("ic", -1, 1, None),
    Among("abil", -1, 1, None),
    Among("iv", -1, 1, None),
];

static A_6: &'static [Among<Context>; 46] = &[
    Among("ica", -1, 1, None),
    Among("ancia", -1, 2, None),
    Among("encia", -1, 5, None),
    Among("adora", -1, 2, None),
    Among("osa", -1, 1, None),
    Among("ista", -1, 1, None),
    Among("iva", -1, 9, None),
    Among("anza", -1, 1, None),
    Among("log\u{00ED}a", -1, 3, None),
    Among("idad", -1, 8, None),
    Among("able", -1, 1, None),
    Among("ible", -1, 1, None),
    Among("ante", -1, 2, None),
    Among("mente", -1, 7, None),
    Among("amente", 13, 6, None),
    Among("aci\u{00F3}n", -1, 2, None),
    Among("uci\u{00F3}n", -1, 4, None),
    Among("ico", -1, 1, None),
    Among("ismo", -1, 1, None),
    Among("oso", -1, 1, None),
    Among("amiento", -1, 1, None),
    Among("imiento", -1, 1, None),
    Among("ivo", -1, 9, None),
    Among("ador", -1, 2, None),
    Among("icas", -1, 1, None),
    Among("ancias", -1, 2, None),
    Among("encias", -1, 5, None),
    Among("adoras", -1, 2, None),
    Among("osas", -1, 1, None),
    Among("istas", -1, 1, None),
    Among("ivas", -1, 9, None),
    Among("anzas", -1, 1, None),
    Among("log\u{00ED}as", -1, 3, None),
    Among("idades", -1, 8, None),
    Among("ables", -1, 1, None),
    Among("ibles", -1, 1, None),
    Among("aciones", -1, 2, None),
    Among("uciones", -1, 4, None),
    Among("adores", -1, 2, None),
    Among("antes", -1, 2, None),
    Among("icos", -1, 1, None),
    Among("ismos", -1, 1, None),
    Among("osos", -1, 1, None),
    Among("amientos", -1, 1, None),
    Among("imientos", -1, 1, None),
    Among("ivos", -1, 9, None),
];

static A_7: &'static [Among<Context>; 12] = &[
    Among("ya", -1, 1, None),
    Among("ye", -1, 1, None),
    Among("yan", -1, 1, None),
    Among("yen", -1, 1, None),
    Among("yeron", -1, 1, None),
    Among("yendo", -1, 1, None),
    Among("yo", -1, 1, None),
    Among("yas", -1, 1, None),
    Among("yes", -1, 1, None),
    Among("yais", -1, 1, None),
    Among("yamos", -1, 1, None),
    Among("y\u{00F3}", -1, 1, None),
];

static A_8: &'static [Among<Context>; 96] = &[
    Among("aba", -1, 2, None),
    Among("ada", -1, 2, None),
    Among("ida", -1, 2, None),
    Among("ara", -1, 2, None),
    Among("iera", -1, 2, None),
    Among("\u{00ED}a", -1, 2, None),
    Among("ar\u{00ED}a", 5, 2, None),
    Among("er\u{00ED}a", 5, 2, None),
    Among("ir\u{00ED}a", 5, 2, None),
    Among("ad", -1, 2, None),
    Among("ed", -1, 2, None),
    Among("id", -1, 2, None),
    Among("ase", -1, 2, None),
    Among("iese", -1, 2, None),
    Among("aste", -1, 2, None),
    Among("iste", -1, 2, None),
    Among("an", -1, 2, None),
    Among("aban", 16, 2, None),
    Among("aran", 16, 2, None),
    Among("ieran", 16, 2, None),
    Among("\u{00ED}an", 16, 2, None),
    Among("ar\u{00ED}an", 20, 2, None),
    Among("er\u{00ED}an", 20, 2, None),
    Among("ir\u{00ED}an", 20, 2, None),
    Among("en", -1, 1, None),
    Among("asen", 24, 2, None),
    Among("iesen", 24, 2, None),
    Among("aron", -1, 2, None),
    Among("ieron", -1, 2, None),
    Among("ar\u{00E1}n", -1, 2, None),
    Among("er\u{00E1}n", -1, 2, None),
    Among("ir\u{00E1}n", -1, 2, None),
    Among("ado", -1, 2, None),
    Among("ido", -1, 2, None),
    Among("ando", -1, 2, None),
    Among("iendo", -1, 2, None),
    Among("ar", -1, 2, None),
    Among("er", -1, 2, None),
    Among("ir", -1, 2, None),
    Among("as", -1, 2, None),
    Among("abas", 39, 2, None),
    Among("adas", 39, 2, None),
    Among("idas", 39, 2, None),
    Among("aras", 39, 2, None),
    Among("ieras", 39, 2, None),
    Among("\u{00ED}as", 39, 2, None),
    Among("ar\u{00ED}as", 45, 2, None),
    Among("er\u{00ED}as", 45, 2, None),
    Among("ir\u{00ED}as", 45, 2, None),
    Among("es", -1, 1, None),
    Among("ases", 49, 2, None),
    Among("ieses", 49, 2, None),
    Among("abais", -1, 2, None),
    Among("arais", -1, 2, None),
    Among("ierais", -1, 2, None),
    Among("\u{00ED}ais", -1, 2, None),
    Among("ar\u{00ED}ais", 55, 2, None),
    Among("er\u{00ED}ais", 55, 2, None),
    Among("ir\u{00ED}ais", 55, 2, None),
    Among("aseis", -1, 2, None),
    Among("ieseis", -1, 2, None),
    Among("asteis", -1, 2, None),
    Among("isteis", -1, 2, None),
    Among("\u{00E1}is", -1, 2, None),
    Among("\u{00E9}is", -1, 1, None),
    Among("ar\u{00E9}is", 64, 2, None),
    Among("er\u{00E9}is", 64, 2, None),
    Among("ir\u{00E9}is", 64, 2, None),
    Among("ados", -1, 2, None),
    Among("idos", -1, 2, None),
    Among("amos", -1, 2, None),
    Among("\u{00E1}bamos", 70, 2, None),
    Among("\u{00E1}ramos", 70, 2, None),
    Among("i\u{00E9}ramos", 70, 2, None),
    Among("\u{00ED}amos", 70, 2, None),
    Among("ar\u{00ED}amos", 74, 2, None),
    Among("er\u{00ED}amos", 74, 2, None),
    Among("ir\u{00ED}amos", 74, 2, None),
    Among("emos", -1, 1, None),
    Among("aremos", 78, 2, None),
    Among("eremos", 78, 2, None),
    Among("iremos", 78, 2, None),
    Among("\u{00E1}semos", 78, 2, None),
    Among("i\u{00E9}semos", 78, 2, None),
    Among("imos", -1, 2, None),
    Among("ar\u{00E1}s", -1, 2, None),
    Among("er\u{00E1}s", -1, 2, None),
    Among("ir\u{00E1}s", -1, 2, None),
    Among("\u{00ED}s", -1, 2, None),
    Among("ar\u{00E1}", -1, 2, None),
    Among("er\u{00E1}", -1, 2, None),
    Among("ir\u{00E1}", -1, 2, None),
    Among("ar\u{00E9}", -1, 2, None),
    Among("er\u{00E9}", -1, 2, None),
    Among("ir\u{00E9}", -1, 2, None),
    Among("i\u{00F3}", -1, 2, None),
];

static A_9: &'static [Among<Context>; 8] = &[
    Among("a", -1, 1, None),
    Among("e", -1, 2, None),
    Among("o", -1, 1, None),
    Among("os", -1, 1, None),
    Among("\u{00E1}", -1, 1, None),
    Among("\u{00E9}", -1, 2, None),
    Among("\u{00ED}", -1, 1, None),
    Among("\u{00F3}", -1, 1, None),
];

static G_v: &'static [u8; 20] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 4, 10];

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

fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 31
    context.i_pV = env.limit;
    context.i_p1 = env.limit;
    context.i_p2 = env.limit;
    // do, line 37
    let v_1 = env.cursor;
    'lab0: loop {
        // (, line 37
        // or, line 39
        'lab1: loop {
            let v_2 = env.cursor;
            'lab2: loop {
                // (, line 38
                if !env.in_grouping(G_v, 97, 252) {
                    break 'lab2;
                }
                // or, line 38
                'lab3: loop {
                    let v_3 = env.cursor;
                    'lab4: loop {
                        // (, line 38
                        if !env.out_grouping(G_v, 97, 252) {
                            break 'lab4;
                        }
                        // gopast, line 38
                        'golab5: loop {
                            'lab6: loop {
                                if !env.in_grouping(G_v, 97, 252) {
                                    break 'lab6;
                                }
                                break 'golab5;
                            }
                            if env.cursor >= env.limit {
                                break 'lab4;
                            }
                            env.next_char();
                        }
                        break 'lab3;
                    }
                    env.cursor = v_3;
                    // (, line 38
                    if !env.in_grouping(G_v, 97, 252) {
                        break 'lab2;
                    }
                    // gopast, line 38
                    'golab7: loop {
                        'lab8: loop {
                            if !env.out_grouping(G_v, 97, 252) {
                                break 'lab8;
                            }
                            break 'golab7;
                        }
                        if env.cursor >= env.limit {
                            break 'lab2;
                        }
                        env.next_char();
                    }
                    break 'lab3;
                }
                break 'lab1;
            }
            env.cursor = v_2;
            // (, line 40
            if !env.out_grouping(G_v, 97, 252) {
                break 'lab0;
            }
            // or, line 40
            'lab9: loop {
                let v_6 = env.cursor;
                'lab10: loop {
                    // (, line 40
                    if !env.out_grouping(G_v, 97, 252) {
                        break 'lab10;
                    }
                    // gopast, line 40
                    'golab11: loop {
                        'lab12: loop {
                            if !env.in_grouping(G_v, 97, 252) {
                                break 'lab12;
                            }
                            break 'golab11;
                        }
                        if env.cursor >= env.limit {
                            break 'lab10;
                        }
                        env.next_char();
                    }
                    break 'lab9;
                }
                env.cursor = v_6;
                // (, line 40
                if !env.in_grouping(G_v, 97, 252) {
                    break 'lab0;
                }
                // next, line 40
                if env.cursor >= env.limit {
                    break 'lab0;
                }
                env.next_char();
                break 'lab9;
            }
            break 'lab1;
        }
        // setmark pV, line 41
        context.i_pV = env.cursor;
        break 'lab0;
    }
    env.cursor = v_1;
    // do, line 43
    let v_8 = env.cursor;
    'lab13: loop {
        // (, line 43
        // gopast, line 44
        'golab14: loop {
            'lab15: loop {
                if !env.in_grouping(G_v, 97, 252) {
                    break 'lab15;
                }
                break 'golab14;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // gopast, line 44
        'golab16: loop {
            'lab17: loop {
                if !env.out_grouping(G_v, 97, 252) {
                    break 'lab17;
                }
                break 'golab16;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // setmark p1, line 44
        context.i_p1 = env.cursor;
        // gopast, line 45
        'golab18: loop {
            'lab19: loop {
                if !env.in_grouping(G_v, 97, 252) {
                    break 'lab19;
                }
                break 'golab18;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // gopast, line 45
        'golab20: loop {
            'lab21: loop {
                if !env.out_grouping(G_v, 97, 252) {
                    break 'lab21;
                }
                break 'golab20;
            }
            if env.cursor >= env.limit {
                break 'lab13;
            }
            env.next_char();
        }
        // setmark p2, line 45
        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 49
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 49
            // [, line 50
            env.bra = env.cursor;
            // substring, line 50
            among_var = env.find_among(A_0, context);
            if among_var == 0 {
                break 'lab1;
            }
            // ], line 50
            env.ket = env.cursor;
            if among_var == 0 {
                break 'lab1;
            } else if among_var == 1 {
                // (, line 51
                // <-, line 51
                if !env.slice_from("a") {
                    return false;
                }
            } else if among_var == 2 {
                // (, line 52
                // <-, line 52
                if !env.slice_from("e") {
                    return false;
                }
            } else if among_var == 3 {
                // (, line 53
                // <-, line 53
                if !env.slice_from("i") {
                    return false;
                }
            } else if among_var == 4 {
                // (, line 54
                // <-, line 54
                if !env.slice_from("o") {
                    return false;
                }
            } else if among_var == 5 {
                // (, line 55
                // <-, line 55
                if !env.slice_from("u") {
                    return false;
                }
            } else if among_var == 6 {
                // (, line 57
                // next, line 57
                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_attached_pronoun(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 67
    // [, line 68
    env.ket = env.cursor;
    // substring, line 68
    if env.find_among_b(A_1, context) == 0 {
        return false;
    }
    // ], line 68
    env.bra = env.cursor;
    // substring, line 72
    among_var = env.find_among_b(A_2, context);
    if among_var == 0 {
        return false;
    }
    // call RV, line 72
    if !r_RV(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 73
        // ], line 73
        env.bra = env.cursor;
        // <-, line 73
        if !env.slice_from("iendo") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 74
        // ], line 74
        env.bra = env.cursor;
        // <-, line 74
        if !env.slice_from("ando") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 75
        // ], line 75
        env.bra = env.cursor;
        // <-, line 75
        if !env.slice_from("ar") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 76
        // ], line 76
        env.bra = env.cursor;
        // <-, line 76
        if !env.slice_from("er") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 77
        // ], line 77
        env.bra = env.cursor;
        // <-, line 77
        if !env.slice_from("ir") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 81
        // delete, line 81
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 7 {
        // (, line 82
        // literal, line 82
        if !env.eq_s_b(&"u") {
            return false;
        }
        // delete, line 82
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_standard_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 86
    // [, line 87
    env.ket = env.cursor;
    // substring, line 87
    among_var = env.find_among_b(A_6, context);
    if among_var == 0 {
        return false;
    }
    // ], line 87
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 98
        // call R2, line 99
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 99
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 104
        // call R2, line 105
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 105
        if !env.slice_del() {
            return false;
        }
        // try, line 106
        let v_1 = env.limit - env.cursor;
        'lab0: loop {
            // (, line 106
            // [, line 106
            env.ket = env.cursor;
            // literal, line 106
            if !env.eq_s_b(&"ic") {
                env.cursor = env.limit - v_1;
                break 'lab0;
            }
            // ], line 106
            env.bra = env.cursor;
            // call R2, line 106
            if !r_R2(env, context) {
                env.cursor = env.limit - v_1;
                break 'lab0;
            }
            // delete, line 106
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
    } else if among_var == 3 {
        // (, line 110
        // call R2, line 111
        if !r_R2(env, context) {
            return false;
        }
        // <-, line 111
        if !env.slice_from("log") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 114
        // call R2, line 115
        if !r_R2(env, context) {
            return false;
        }
        // <-, line 115
        if !env.slice_from("u") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 118
        // call R2, line 119
        if !r_R2(env, context) {
            return false;
        }
        // <-, line 119
        if !env.slice_from("ente") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 122
        // call R1, line 123
        if !r_R1(env, context) {
            return false;
        }
        // delete, line 123
        if !env.slice_del() {
            return false;
        }
        // try, line 124
        let v_2 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 124
            // [, line 125
            env.ket = env.cursor;
            // substring, line 125
            among_var = env.find_among_b(A_3, context);
            if among_var == 0 {
                env.cursor = env.limit - v_2;
                break 'lab1;
            }
            // ], line 125
            env.bra = env.cursor;
            // call R2, line 125
            if !r_R2(env, context) {
                env.cursor = env.limit - v_2;
                break 'lab1;
            }
            // delete, line 125
            if !env.slice_del() {
                return false;
            }
            if among_var == 0 {
                env.cursor = env.limit - v_2;
                break 'lab1;
            } else if among_var == 1 {
                // (, line 126
                // [, line 126
                env.ket = env.cursor;
                // literal, line 126
                if !env.eq_s_b(&"at") {
                    env.cursor = env.limit - v_2;
                    break 'lab1;
                }
                // ], line 126
                env.bra = env.cursor;
                // call R2, line 126
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_2;
                    break 'lab1;
                }
                // delete, line 126
                if !env.slice_del() {
                    return false;
                }
            }
            break 'lab1;
        }
    } else if among_var == 7 {
        // (, line 134
        // call R2, line 135
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 135
        if !env.slice_del() {
            return false;
        }
        // try, line 136
        let v_3 = env.limit - env.cursor;
        'lab2: loop {
            // (, line 136
            // [, line 137
            env.ket = env.cursor;
            // substring, line 137
            among_var = env.find_among_b(A_4, context);
            if among_var == 0 {
                env.cursor = env.limit - v_3;
                break 'lab2;
            }
            // ], line 137
            env.bra = env.cursor;
            if among_var == 0 {
                env.cursor = env.limit - v_3;
                break 'lab2;
            } else if among_var == 1 {
                // (, line 140
                // call R2, line 140
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_3;
                    break 'lab2;
                }
                // delete, line 140
                if !env.slice_del() {
                    return false;
                }
            }
            break 'lab2;
        }
    } else if among_var == 8 {
        // (, line 146
        // call R2, line 147
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 147
        if !env.slice_del() {
            return false;
        }
        // try, line 148
        let v_4 = env.limit - env.cursor;
        'lab3: loop {
            // (, line 148
            // [, line 149
            env.ket = env.cursor;
            // substring, line 149
            among_var = env.find_among_b(A_5, context);
            if among_var == 0 {
                env.cursor = env.limit - v_4;
                break 'lab3;
            }
            // ], line 149
            env.bra = env.cursor;
            if among_var == 0 {
                env.cursor = env.limit - v_4;
                break 'lab3;
            } else if among_var == 1 {
                // (, line 152
                // call R2, line 152
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_4;
                    break 'lab3;
                }
                // delete, line 152
                if !env.slice_del() {
                    return false;
                }
            }
            break 'lab3;
        }
    } else if among_var == 9 {
        // (, line 158
        // call R2, line 159
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 159
        if !env.slice_del() {
            return false;
        }
        // try, line 160
        let v_5 = env.limit - env.cursor;
        'lab4: loop {
            // (, line 160
            // [, line 161
            env.ket = env.cursor;
            // literal, line 161
            if !env.eq_s_b(&"at") {
                env.cursor = env.limit - v_5;
                break 'lab4;
            }
            // ], line 161
            env.bra = env.cursor;
            // call R2, line 161
            if !r_R2(env, context) {
                env.cursor = env.limit - v_5;
                break 'lab4;
            }
            // delete, line 161
            if !env.slice_del() {
                return false;
            }
            break 'lab4;
        }
    }
    return true;
}

fn r_y_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 167
    // setlimit, line 168
    let v_1 = env.limit - env.cursor;
    // tomark, line 168
    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 168
    // [, line 168
    env.ket = env.cursor;
    // substring, line 168
    among_var = env.find_among_b(A_7, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 168
    env.bra = env.cursor;
    env.limit_backward = v_2;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 171
        // literal, line 171
        if !env.eq_s_b(&"u") {
            return false;
        }
        // delete, line 171
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 175
    // setlimit, line 176
    let v_1 = env.limit - env.cursor;
    // tomark, line 176
    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 176
    // [, line 176
    env.ket = env.cursor;
    // substring, line 176
    among_var = env.find_among_b(A_8, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 176
    env.bra = env.cursor;
    env.limit_backward = v_2;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 179
        // try, line 179
        let v_3 = env.limit - env.cursor;
        'lab0: loop {
            // (, line 179
            // literal, line 179
            if !env.eq_s_b(&"u") {
                env.cursor = env.limit - v_3;
                break 'lab0;
            }
            // test, line 179
            let v_4 = env.limit - env.cursor;
            // literal, line 179
            if !env.eq_s_b(&"g") {
                env.cursor = env.limit - v_3;
                break 'lab0;
            }
            env.cursor = env.limit - v_4;
            break 'lab0;
        }
        // ], line 179
        env.bra = env.cursor;
        // delete, line 179
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 200
        // delete, line 200
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_residual_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 204
    // [, line 205
    env.ket = env.cursor;
    // substring, line 205
    among_var = env.find_among_b(A_9, context);
    if among_var == 0 {
        return false;
    }
    // ], line 205
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 208
        // call RV, line 208
        if !r_RV(env, context) {
            return false;
        }
        // delete, line 208
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 210
        // call RV, line 210
        if !r_RV(env, context) {
            return false;
        }
        // delete, line 210
        if !env.slice_del() {
            return false;
        }
        // try, line 210
        let v_1 = env.limit - env.cursor;
        'lab0: loop {
            // (, line 210
            // [, line 210
            env.ket = env.cursor;
            // literal, line 210
            if !env.eq_s_b(&"u") {
                env.cursor = env.limit - v_1;
                break 'lab0;
            }
            // ], line 210
            env.bra = env.cursor;
            // test, line 210
            let v_2 = env.limit - env.cursor;
            // literal, line 210
            if !env.eq_s_b(&"g") {
                env.cursor = env.limit - v_1;
                break 'lab0;
            }
            env.cursor = env.limit - v_2;
            // call RV, line 210
            if !r_RV(env, context) {
                env.cursor = env.limit - v_1;
                break 'lab0;
            }
            // delete, line 210
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
    }
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        i_p2: 0,
        i_p1: 0,
        i_pV: 0,
    };
    // (, line 215
    // do, line 216
    let v_1 = env.cursor;
    'lab0: loop {
        // call mark_regions, line 216
        if !r_mark_regions(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // backwards, line 217
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 217
    // do, line 218
    let v_2 = env.limit - env.cursor;
    'lab1: loop {
        // call attached_pronoun, line 218
        if !r_attached_pronoun(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = env.limit - v_2;
    // do, line 219
    let v_3 = env.limit - env.cursor;
    'lab2: loop {
        // (, line 219
        // or, line 219
        'lab3: loop {
            let v_4 = env.limit - env.cursor;
            'lab4: loop {
                // call standard_suffix, line 219
                if !r_standard_suffix(env, context) {
                    break 'lab4;
                }
                break 'lab3;
            }
            env.cursor = env.limit - v_4;
            'lab5: loop {
                // call y_verb_suffix, line 220
                if !r_y_verb_suffix(env, context) {
                    break 'lab5;
                }
                break 'lab3;
            }
            env.cursor = env.limit - v_4;
            // call verb_suffix, line 221
            if !r_verb_suffix(env, context) {
                break 'lab2;
            }
            break 'lab3;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_3;
    // do, line 223
    let v_5 = env.limit - env.cursor;
    'lab6: loop {
        // call residual_suffix, line 223
        if !r_residual_suffix(env, context) {
            break 'lab6;
        }
        break 'lab6;
    }
    env.cursor = env.limit - v_5;
    env.cursor = env.limit_backward;
    // do, line 225
    let v_6 = env.cursor;
    'lab7: loop {
        // call postlude, line 225
        if !r_postlude(env, context) {
            break 'lab7;
        }
        break 'lab7;
    }
    env.cursor = v_6;
    return true;
}