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>; 8] = &[
    Among("cs", -1, -1, None),
    Among("dzs", -1, -1, None),
    Among("gy", -1, -1, None),
    Among("ly", -1, -1, None),
    Among("ny", -1, -1, None),
    Among("sz", -1, -1, None),
    Among("ty", -1, -1, None),
    Among("zs", -1, -1, None),
];

static A_1: &'static [Among<Context>; 2] = &[
    Among("\u{00E1}", -1, 1, None),
    Among("\u{00E9}", -1, 2, None),
];

static A_2: &'static [Among<Context>; 23] = &[
    Among("bb", -1, -1, None),
    Among("cc", -1, -1, None),
    Among("dd", -1, -1, None),
    Among("ff", -1, -1, None),
    Among("gg", -1, -1, None),
    Among("jj", -1, -1, None),
    Among("kk", -1, -1, None),
    Among("ll", -1, -1, None),
    Among("mm", -1, -1, None),
    Among("nn", -1, -1, None),
    Among("pp", -1, -1, None),
    Among("rr", -1, -1, None),
    Among("ccs", -1, -1, None),
    Among("ss", -1, -1, None),
    Among("zzs", -1, -1, None),
    Among("tt", -1, -1, None),
    Among("vv", -1, -1, None),
    Among("ggy", -1, -1, None),
    Among("lly", -1, -1, None),
    Among("nny", -1, -1, None),
    Among("tty", -1, -1, None),
    Among("ssz", -1, -1, None),
    Among("zz", -1, -1, None),
];

static A_3: &'static [Among<Context>; 2] = &[
    Among("al", -1, 1, None),
    Among("el", -1, 2, None),
];

static A_4: &'static [Among<Context>; 44] = &[
    Among("ba", -1, -1, None),
    Among("ra", -1, -1, None),
    Among("be", -1, -1, None),
    Among("re", -1, -1, None),
    Among("ig", -1, -1, None),
    Among("nak", -1, -1, None),
    Among("nek", -1, -1, None),
    Among("val", -1, -1, None),
    Among("vel", -1, -1, None),
    Among("ul", -1, -1, None),
    Among("b\u{0151}l", -1, -1, None),
    Among("r\u{0151}l", -1, -1, None),
    Among("t\u{0151}l", -1, -1, None),
    Among("n\u{00E1}l", -1, -1, None),
    Among("n\u{00E9}l", -1, -1, None),
    Among("b\u{00F3}l", -1, -1, None),
    Among("r\u{00F3}l", -1, -1, None),
    Among("t\u{00F3}l", -1, -1, None),
    Among("\u{00FC}l", -1, -1, None),
    Among("n", -1, -1, None),
    Among("an", 19, -1, None),
    Among("ban", 20, -1, None),
    Among("en", 19, -1, None),
    Among("ben", 22, -1, None),
    Among("k\u{00E9}ppen", 22, -1, None),
    Among("on", 19, -1, None),
    Among("\u{00F6}n", 19, -1, None),
    Among("k\u{00E9}pp", -1, -1, None),
    Among("kor", -1, -1, None),
    Among("t", -1, -1, None),
    Among("at", 29, -1, None),
    Among("et", 29, -1, None),
    Among("k\u{00E9}nt", 29, -1, None),
    Among("ank\u{00E9}nt", 32, -1, None),
    Among("enk\u{00E9}nt", 32, -1, None),
    Among("onk\u{00E9}nt", 32, -1, None),
    Among("ot", 29, -1, None),
    Among("\u{00E9}rt", 29, -1, None),
    Among("\u{00F6}t", 29, -1, None),
    Among("hez", -1, -1, None),
    Among("hoz", -1, -1, None),
    Among("h\u{00F6}z", -1, -1, None),
    Among("v\u{00E1}", -1, -1, None),
    Among("v\u{00E9}", -1, -1, None),
];

static A_5: &'static [Among<Context>; 3] = &[
    Among("\u{00E1}n", -1, 2, None),
    Among("\u{00E9}n", -1, 1, None),
    Among("\u{00E1}nk\u{00E9}nt", -1, 3, None),
];

static A_6: &'static [Among<Context>; 6] = &[
    Among("stul", -1, 2, None),
    Among("astul", 0, 1, None),
    Among("\u{00E1}stul", 0, 3, None),
    Among("st\u{00FC}l", -1, 2, None),
    Among("est\u{00FC}l", 3, 1, None),
    Among("\u{00E9}st\u{00FC}l", 3, 4, None),
];

static A_7: &'static [Among<Context>; 2] = &[
    Among("\u{00E1}", -1, 1, None),
    Among("\u{00E9}", -1, 2, None),
];

static A_8: &'static [Among<Context>; 7] = &[
    Among("k", -1, 7, None),
    Among("ak", 0, 4, None),
    Among("ek", 0, 6, None),
    Among("ok", 0, 5, None),
    Among("\u{00E1}k", 0, 1, None),
    Among("\u{00E9}k", 0, 2, None),
    Among("\u{00F6}k", 0, 3, None),
];

static A_9: &'static [Among<Context>; 12] = &[
    Among("\u{00E9}i", -1, 7, None),
    Among("\u{00E1}\u{00E9}i", 0, 6, None),
    Among("\u{00E9}\u{00E9}i", 0, 5, None),
    Among("\u{00E9}", -1, 9, None),
    Among("k\u{00E9}", 3, 4, None),
    Among("ak\u{00E9}", 4, 1, None),
    Among("ek\u{00E9}", 4, 1, None),
    Among("ok\u{00E9}", 4, 1, None),
    Among("\u{00E1}k\u{00E9}", 4, 3, None),
    Among("\u{00E9}k\u{00E9}", 4, 2, None),
    Among("\u{00F6}k\u{00E9}", 4, 1, None),
    Among("\u{00E9}\u{00E9}", 3, 8, None),
];

static A_10: &'static [Among<Context>; 31] = &[
    Among("a", -1, 18, None),
    Among("ja", 0, 17, None),
    Among("d", -1, 16, None),
    Among("ad", 2, 13, None),
    Among("ed", 2, 13, None),
    Among("od", 2, 13, None),
    Among("\u{00E1}d", 2, 14, None),
    Among("\u{00E9}d", 2, 15, None),
    Among("\u{00F6}d", 2, 13, None),
    Among("e", -1, 18, None),
    Among("je", 9, 17, None),
    Among("nk", -1, 4, None),
    Among("unk", 11, 1, None),
    Among("\u{00E1}nk", 11, 2, None),
    Among("\u{00E9}nk", 11, 3, None),
    Among("\u{00FC}nk", 11, 1, None),
    Among("uk", -1, 8, None),
    Among("juk", 16, 7, None),
    Among("\u{00E1}juk", 17, 5, None),
    Among("\u{00FC}k", -1, 8, None),
    Among("j\u{00FC}k", 19, 7, None),
    Among("\u{00E9}j\u{00FC}k", 20, 6, None),
    Among("m", -1, 12, None),
    Among("am", 22, 9, None),
    Among("em", 22, 9, None),
    Among("om", 22, 9, None),
    Among("\u{00E1}m", 22, 10, None),
    Among("\u{00E9}m", 22, 11, None),
    Among("o", -1, 18, None),
    Among("\u{00E1}", -1, 19, None),
    Among("\u{00E9}", -1, 20, None),
];

static A_11: &'static [Among<Context>; 42] = &[
    Among("id", -1, 10, None),
    Among("aid", 0, 9, None),
    Among("jaid", 1, 6, None),
    Among("eid", 0, 9, None),
    Among("jeid", 3, 6, None),
    Among("\u{00E1}id", 0, 7, None),
    Among("\u{00E9}id", 0, 8, None),
    Among("i", -1, 15, None),
    Among("ai", 7, 14, None),
    Among("jai", 8, 11, None),
    Among("ei", 7, 14, None),
    Among("jei", 10, 11, None),
    Among("\u{00E1}i", 7, 12, None),
    Among("\u{00E9}i", 7, 13, None),
    Among("itek", -1, 24, None),
    Among("eitek", 14, 21, None),
    Among("jeitek", 15, 20, None),
    Among("\u{00E9}itek", 14, 23, None),
    Among("ik", -1, 29, None),
    Among("aik", 18, 26, None),
    Among("jaik", 19, 25, None),
    Among("eik", 18, 26, None),
    Among("jeik", 21, 25, None),
    Among("\u{00E1}ik", 18, 27, None),
    Among("\u{00E9}ik", 18, 28, None),
    Among("ink", -1, 20, None),
    Among("aink", 25, 17, None),
    Among("jaink", 26, 16, None),
    Among("eink", 25, 17, None),
    Among("jeink", 28, 16, None),
    Among("\u{00E1}ink", 25, 18, None),
    Among("\u{00E9}ink", 25, 19, None),
    Among("aitok", -1, 21, None),
    Among("jaitok", 32, 20, None),
    Among("\u{00E1}itok", -1, 22, None),
    Among("im", -1, 5, None),
    Among("aim", 35, 4, None),
    Among("jaim", 36, 1, None),
    Among("eim", 35, 4, None),
    Among("jeim", 38, 1, None),
    Among("\u{00E1}im", 35, 2, None),
    Among("\u{00E9}im", 35, 3, None),
];

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

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

fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 44
    context.i_p1 = env.limit;
    // or, line 51
    'lab0: loop {
        let v_1 = env.cursor;
        'lab1: loop {
            // (, line 48
            if !env.in_grouping(G_v, 97, 369) {
                break 'lab1;
            }
            // goto, line 48
            'golab2: loop {
                let v_2 = env.cursor;
                'lab3: loop {
                    if !env.out_grouping(G_v, 97, 369) {
                        break 'lab3;
                    }
                    env.cursor = v_2;
                    break 'golab2;
                }
                env.cursor = v_2;
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            // or, line 49
            'lab4: loop {
                let v_3 = env.cursor;
                'lab5: loop {
                    // among, line 49
                    if env.find_among(A_0, context) == 0 {
                        break 'lab5;
                    }
                    break 'lab4;
                }
                env.cursor = v_3;
                // next, line 49
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
                break 'lab4;
            }
            // setmark p1, line 50
            context.i_p1 = env.cursor;
            break 'lab0;
        }
        env.cursor = v_1;
        // (, line 53
        if !env.out_grouping(G_v, 97, 369) {
            return false;
        }
        // gopast, line 53
        'golab6: loop {
            'lab7: loop {
                if !env.in_grouping(G_v, 97, 369) {
                    break 'lab7;
                }
                break 'golab6;
            }
            if env.cursor >= env.limit {
                return false;
            }
            env.next_char();
        }
        // setmark p1, line 53
        context.i_p1 = env.cursor;
        break 'lab0;
    }
    return true;
}

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

fn r_v_ending(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 60
    // [, line 61
    env.ket = env.cursor;
    // substring, line 61
    among_var = env.find_among_b(A_1, context);
    if among_var == 0 {
        return false;
    }
    // ], line 61
    env.bra = env.cursor;
    // call R1, line 61
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 62
        // <-, line 62
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 63
        // <-, line 63
        if !env.slice_from("e") {
            return false;
        }
    }
    return true;
}

fn r_double(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 67
    // test, line 68
    let v_1 = env.limit - env.cursor;
    // among, line 68
    if env.find_among_b(A_2, context) == 0 {
        return false;
    }
    env.cursor = env.limit - v_1;
    return true;
}

fn r_undouble(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 72
    // next, line 73
    if env.cursor <= env.limit_backward {
        return false;
    }
    env.previous_char();
    // [, line 73
    env.ket = env.cursor;
    // hop, line 73
    let c = env.byte_index_for_hop(-1);
    if env.limit_backward as i32 > c || c > env.limit as i32 {
        return false;
    }
    env.cursor = c as usize;
    // ], line 73
    env.bra = env.cursor;
    // delete, line 73
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_instrum(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 76
    // [, line 77
    env.ket = env.cursor;
    // substring, line 77
    among_var = env.find_among_b(A_3, context);
    if among_var == 0 {
        return false;
    }
    // ], line 77
    env.bra = env.cursor;
    // call R1, line 77
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 78
        // call double, line 78
        if !r_double(env, context) {
            return false;
        }
    } else if among_var == 2 {
        // (, line 79
        // call double, line 79
        if !r_double(env, context) {
            return false;
        }
    }
    // delete, line 81
    if !env.slice_del() {
        return false;
    }
    // call undouble, line 82
    if !r_undouble(env, context) {
        return false;
    }
    return true;
}

fn r_case(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 86
    // [, line 87
    env.ket = env.cursor;
    // substring, line 87
    if env.find_among_b(A_4, context) == 0 {
        return false;
    }
    // ], line 87
    env.bra = env.cursor;
    // call R1, line 87
    if !r_R1(env, context) {
        return false;
    }
    // delete, line 111
    if !env.slice_del() {
        return false;
    }
    // call v_ending, line 112
    if !r_v_ending(env, context) {
        return false;
    }
    return true;
}

fn r_case_special(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 115
    // [, line 116
    env.ket = env.cursor;
    // substring, line 116
    among_var = env.find_among_b(A_5, context);
    if among_var == 0 {
        return false;
    }
    // ], line 116
    env.bra = env.cursor;
    // call R1, line 116
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 117
        // <-, line 117
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 118
        // <-, line 118
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 119
        // <-, line 119
        if !env.slice_from("a") {
            return false;
        }
    }
    return true;
}

fn r_case_other(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 123
    // [, line 124
    env.ket = env.cursor;
    // substring, line 124
    among_var = env.find_among_b(A_6, context);
    if among_var == 0 {
        return false;
    }
    // ], line 124
    env.bra = env.cursor;
    // call R1, line 124
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 125
        // delete, line 125
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 126
        // delete, line 126
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 3 {
        // (, line 127
        // <-, line 127
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 128
        // <-, line 128
        if !env.slice_from("e") {
            return false;
        }
    }
    return true;
}

fn r_factive(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 132
    // [, line 133
    env.ket = env.cursor;
    // substring, line 133
    among_var = env.find_among_b(A_7, context);
    if among_var == 0 {
        return false;
    }
    // ], line 133
    env.bra = env.cursor;
    // call R1, line 133
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 134
        // call double, line 134
        if !r_double(env, context) {
            return false;
        }
    } else if among_var == 2 {
        // (, line 135
        // call double, line 135
        if !r_double(env, context) {
            return false;
        }
    }
    // delete, line 137
    if !env.slice_del() {
        return false;
    }
    // call undouble, line 138
    if !r_undouble(env, context) {
        return false;
    }
    return true;
}

fn r_plural(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 141
    // [, line 142
    env.ket = env.cursor;
    // substring, line 142
    among_var = env.find_among_b(A_8, context);
    if among_var == 0 {
        return false;
    }
    // ], line 142
    env.bra = env.cursor;
    // call R1, line 142
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 143
        // <-, line 143
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 144
        // <-, line 144
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 145
        // delete, line 145
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 4 {
        // (, line 146
        // delete, line 146
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 5 {
        // (, line 147
        // delete, line 147
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 6 {
        // (, line 148
        // delete, line 148
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 7 {
        // (, line 149
        // delete, line 149
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_owned(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 153
    // [, line 154
    env.ket = env.cursor;
    // substring, line 154
    among_var = env.find_among_b(A_9, context);
    if among_var == 0 {
        return false;
    }
    // ], line 154
    env.bra = env.cursor;
    // call R1, line 154
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 155
        // delete, line 155
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 156
        // <-, line 156
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 157
        // <-, line 157
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 158
        // delete, line 158
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 5 {
        // (, line 159
        // <-, line 159
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 160
        // <-, line 160
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 7 {
        // (, line 161
        // delete, line 161
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 8 {
        // (, line 162
        // <-, line 162
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 9 {
        // (, line 163
        // delete, line 163
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_sing_owner(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 167
    // [, line 168
    env.ket = env.cursor;
    // substring, line 168
    among_var = env.find_among_b(A_10, context);
    if among_var == 0 {
        return false;
    }
    // ], line 168
    env.bra = env.cursor;
    // call R1, line 168
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 169
        // delete, line 169
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 170
        // <-, line 170
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 171
        // <-, line 171
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 172
        // delete, line 172
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 5 {
        // (, line 173
        // <-, line 173
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 174
        // <-, line 174
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 7 {
        // (, line 175
        // delete, line 175
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 8 {
        // (, line 176
        // delete, line 176
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 9 {
        // (, line 177
        // delete, line 177
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 10 {
        // (, line 178
        // <-, line 178
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 11 {
        // (, line 179
        // <-, line 179
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 12 {
        // (, line 180
        // delete, line 180
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 13 {
        // (, line 181
        // delete, line 181
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 14 {
        // (, line 182
        // <-, line 182
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 15 {
        // (, line 183
        // <-, line 183
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 16 {
        // (, line 184
        // delete, line 184
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 17 {
        // (, line 185
        // delete, line 185
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 18 {
        // (, line 186
        // delete, line 186
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 19 {
        // (, line 187
        // <-, line 187
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 20 {
        // (, line 188
        // <-, line 188
        if !env.slice_from("e") {
            return false;
        }
    }
    return true;
}

fn r_plur_owner(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 192
    // [, line 193
    env.ket = env.cursor;
    // substring, line 193
    among_var = env.find_among_b(A_11, context);
    if among_var == 0 {
        return false;
    }
    // ], line 193
    env.bra = env.cursor;
    // call R1, line 193
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 194
        // delete, line 194
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 195
        // <-, line 195
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 196
        // <-, line 196
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 197
        // delete, line 197
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 5 {
        // (, line 198
        // delete, line 198
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 6 {
        // (, line 199
        // delete, line 199
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 7 {
        // (, line 200
        // <-, line 200
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 8 {
        // (, line 201
        // <-, line 201
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 9 {
        // (, line 202
        // delete, line 202
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 10 {
        // (, line 203
        // delete, line 203
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 11 {
        // (, line 204
        // delete, line 204
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 12 {
        // (, line 205
        // <-, line 205
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 13 {
        // (, line 206
        // <-, line 206
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 14 {
        // (, line 207
        // delete, line 207
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 15 {
        // (, line 208
        // delete, line 208
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 16 {
        // (, line 209
        // delete, line 209
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 17 {
        // (, line 210
        // delete, line 210
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 18 {
        // (, line 211
        // <-, line 211
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 19 {
        // (, line 212
        // <-, line 212
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 20 {
        // (, line 214
        // delete, line 214
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 21 {
        // (, line 215
        // delete, line 215
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 22 {
        // (, line 216
        // <-, line 216
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 23 {
        // (, line 217
        // <-, line 217
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 24 {
        // (, line 218
        // delete, line 218
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 25 {
        // (, line 219
        // delete, line 219
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 26 {
        // (, line 220
        // delete, line 220
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 27 {
        // (, line 221
        // <-, line 221
        if !env.slice_from("a") {
            return false;
        }
    } else if among_var == 28 {
        // (, line 222
        // <-, line 222
        if !env.slice_from("e") {
            return false;
        }
    } else if among_var == 29 {
        // (, line 223
        // delete, line 223
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        i_p1: 0,
    };
    // (, line 228
    // do, line 229
    let v_1 = env.cursor;
    'lab0: loop {
        // call mark_regions, line 229
        if !r_mark_regions(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // backwards, line 230
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 230
    // do, line 231
    let v_2 = env.limit - env.cursor;
    'lab1: loop {
        // call instrum, line 231
        if !r_instrum(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = env.limit - v_2;
    // do, line 232
    let v_3 = env.limit - env.cursor;
    'lab2: loop {
        // call case, line 232
        if !r_case(env, context) {
            break 'lab2;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_3;
    // do, line 233
    let v_4 = env.limit - env.cursor;
    'lab3: loop {
        // call case_special, line 233
        if !r_case_special(env, context) {
            break 'lab3;
        }
        break 'lab3;
    }
    env.cursor = env.limit - v_4;
    // do, line 234
    let v_5 = env.limit - env.cursor;
    'lab4: loop {
        // call case_other, line 234
        if !r_case_other(env, context) {
            break 'lab4;
        }
        break 'lab4;
    }
    env.cursor = env.limit - v_5;
    // do, line 235
    let v_6 = env.limit - env.cursor;
    'lab5: loop {
        // call factive, line 235
        if !r_factive(env, context) {
            break 'lab5;
        }
        break 'lab5;
    }
    env.cursor = env.limit - v_6;
    // do, line 236
    let v_7 = env.limit - env.cursor;
    'lab6: loop {
        // call owned, line 236
        if !r_owned(env, context) {
            break 'lab6;
        }
        break 'lab6;
    }
    env.cursor = env.limit - v_7;
    // do, line 237
    let v_8 = env.limit - env.cursor;
    'lab7: loop {
        // call sing_owner, line 237
        if !r_sing_owner(env, context) {
            break 'lab7;
        }
        break 'lab7;
    }
    env.cursor = env.limit - v_8;
    // do, line 238
    let v_9 = env.limit - env.cursor;
    'lab8: loop {
        // call plur_owner, line 238
        if !r_plur_owner(env, context) {
            break 'lab8;
        }
        break 'lab8;
    }
    env.cursor = env.limit - v_9;
    // do, line 239
    let v_10 = env.limit - env.cursor;
    'lab9: loop {
        // call plural, line 239
        if !r_plural(env, context) {
            break 'lab9;
        }
        break 'lab9;
    }
    env.cursor = env.limit - v_10;
    env.cursor = env.limit_backward;
    return true;
}