//! 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("arsen", -1, -1, None),
    Among("commun", -1, -1, None),
    Among("gener", -1, -1, None),
];

static A_1: &'static [Among<Context>; 3] = &[
    Among("'", -1, 1, None),
    Among("'s'", 0, 1, None),
    Among("'s", -1, 1, None),
];

static A_2: &'static [Among<Context>; 6] = &[
    Among("ied", -1, 2, None),
    Among("s", -1, 3, None),
    Among("ies", 1, 2, None),
    Among("sses", 1, 1, None),
    Among("ss", 1, -1, None),
    Among("us", 1, -1, None),
];

static A_3: &'static [Among<Context>; 13] = &[
    Among("", -1, 3, None),
    Among("bb", 0, 2, None),
    Among("dd", 0, 2, None),
    Among("ff", 0, 2, None),
    Among("gg", 0, 2, None),
    Among("bl", 0, 1, None),
    Among("mm", 0, 2, None),
    Among("nn", 0, 2, None),
    Among("pp", 0, 2, None),
    Among("rr", 0, 2, None),
    Among("at", 0, 1, None),
    Among("tt", 0, 2, None),
    Among("iz", 0, 1, None),
];

static A_4: &'static [Among<Context>; 6] = &[
    Among("ed", -1, 2, None),
    Among("eed", 0, 1, None),
    Among("ing", -1, 2, None),
    Among("edly", -1, 2, None),
    Among("eedly", 3, 1, None),
    Among("ingly", -1, 2, None),
];

static A_5: &'static [Among<Context>; 24] = &[
    Among("anci", -1, 3, None),
    Among("enci", -1, 2, None),
    Among("ogi", -1, 13, None),
    Among("li", -1, 16, None),
    Among("bli", 3, 12, None),
    Among("abli", 4, 4, None),
    Among("alli", 3, 8, None),
    Among("fulli", 3, 14, None),
    Among("lessli", 3, 15, None),
    Among("ousli", 3, 10, None),
    Among("entli", 3, 5, None),
    Among("aliti", -1, 8, None),
    Among("biliti", -1, 12, None),
    Among("iviti", -1, 11, None),
    Among("tional", -1, 1, None),
    Among("ational", 14, 7, None),
    Among("alism", -1, 8, None),
    Among("ation", -1, 7, None),
    Among("ization", 17, 6, None),
    Among("izer", -1, 6, None),
    Among("ator", -1, 7, None),
    Among("iveness", -1, 11, None),
    Among("fulness", -1, 9, None),
    Among("ousness", -1, 10, None),
];

static A_6: &'static [Among<Context>; 9] = &[
    Among("icate", -1, 4, None),
    Among("ative", -1, 6, None),
    Among("alize", -1, 3, None),
    Among("iciti", -1, 4, None),
    Among("ical", -1, 4, None),
    Among("tional", -1, 1, None),
    Among("ational", 5, 2, None),
    Among("ful", -1, 5, None),
    Among("ness", -1, 5, None),
];

static A_7: &'static [Among<Context>; 18] = &[
    Among("ic", -1, 1, None),
    Among("ance", -1, 1, None),
    Among("ence", -1, 1, None),
    Among("able", -1, 1, None),
    Among("ible", -1, 1, None),
    Among("ate", -1, 1, None),
    Among("ive", -1, 1, None),
    Among("ize", -1, 1, None),
    Among("iti", -1, 1, None),
    Among("al", -1, 1, None),
    Among("ism", -1, 1, None),
    Among("ion", -1, 2, None),
    Among("er", -1, 1, None),
    Among("ous", -1, 1, None),
    Among("ant", -1, 1, None),
    Among("ent", -1, 1, None),
    Among("ment", 15, 1, None),
    Among("ement", 16, 1, None),
];

static A_8: &'static [Among<Context>; 2] = &[
    Among("e", -1, 1, None),
    Among("l", -1, 2, None),
];

static A_9: &'static [Among<Context>; 8] = &[
    Among("succeed", -1, -1, None),
    Among("proceed", -1, -1, None),
    Among("exceed", -1, -1, None),
    Among("canning", -1, -1, None),
    Among("inning", -1, -1, None),
    Among("earring", -1, -1, None),
    Among("herring", -1, -1, None),
    Among("outing", -1, -1, None),
];

static A_10: &'static [Among<Context>; 18] = &[
    Among("andes", -1, -1, None),
    Among("atlas", -1, -1, None),
    Among("bias", -1, -1, None),
    Among("cosmos", -1, -1, None),
    Among("dying", -1, 3, None),
    Among("early", -1, 9, None),
    Among("gently", -1, 7, None),
    Among("howe", -1, -1, None),
    Among("idly", -1, 6, None),
    Among("lying", -1, 4, None),
    Among("news", -1, -1, None),
    Among("only", -1, 10, None),
    Among("singly", -1, 11, None),
    Among("skies", -1, 2, None),
    Among("skis", -1, 1, None),
    Among("sky", -1, -1, None),
    Among("tying", -1, 5, None),
    Among("ugly", -1, 8, None),
];

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

static G_v_WXY: &'static [u8; 5] = &[1, 17, 65, 208, 1];

static G_valid_LI: &'static [u8; 3] = &[55, 141, 2];

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

fn r_prelude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 25
    // unset Y_found, line 26
    context.b_Y_found = false;
    // do, line 27
    let v_1 = env.cursor;
    'lab0: loop {
        // (, line 27
        // [, line 27
        env.bra = env.cursor;
        // literal, line 27
        if !env.eq_s(&"'") {
            break 'lab0;
        }
        // ], line 27
        env.ket = env.cursor;
        // delete, line 27
        if !env.slice_del() {
            return false;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // do, line 28
    let v_2 = env.cursor;
    'lab1: loop {
        // (, line 28
        // [, line 28
        env.bra = env.cursor;
        // literal, line 28
        if !env.eq_s(&"y") {
            break 'lab1;
        }
        // ], line 28
        env.ket = env.cursor;
        // <-, line 28
        if !env.slice_from("Y") {
            return false;
        }
        // set Y_found, line 28
        context.b_Y_found = true;
        break 'lab1;
    }
    env.cursor = v_2;
    // do, line 29
    let v_3 = env.cursor;
    'lab2: loop {
        // repeat, line 29
        'replab3: loop{
            let v_4 = env.cursor;
            'lab4: for _ in 0..1 {
                // (, line 29
                // goto, line 29
                'golab5: loop {
                    let v_5 = env.cursor;
                    'lab6: loop {
                        // (, line 29
                        if !env.in_grouping(G_v, 97, 121) {
                            break 'lab6;
                        }
                        // [, line 29
                        env.bra = env.cursor;
                        // literal, line 29
                        if !env.eq_s(&"y") {
                            break 'lab6;
                        }
                        // ], line 29
                        env.ket = env.cursor;
                        env.cursor = v_5;
                        break 'golab5;
                    }
                    env.cursor = v_5;
                    if env.cursor >= env.limit {
                        break 'lab4;
                    }
                    env.next_char();
                }
                // <-, line 29
                if !env.slice_from("Y") {
                    return false;
                }
                // set Y_found, line 29
                context.b_Y_found = true;
                continue 'replab3;
            }
            env.cursor = v_4;
            break 'replab3;
        }
        break 'lab2;
    }
    env.cursor = v_3;
    return true;
}

fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 32
    context.i_p1 = env.limit;
    context.i_p2 = env.limit;
    // do, line 35
    let v_1 = env.cursor;
    'lab0: loop {
        // (, line 35
        // or, line 41
        'lab1: loop {
            let v_2 = env.cursor;
            'lab2: loop {
                // among, line 36
                if env.find_among(A_0, context) == 0 {
                    break 'lab2;
                }
                break 'lab1;
            }
            env.cursor = v_2;
            // (, line 41
            // gopast, line 41
            'golab3: loop {
                'lab4: loop {
                    if !env.in_grouping(G_v, 97, 121) {
                        break 'lab4;
                    }
                    break 'golab3;
                }
                if env.cursor >= env.limit {
                    break 'lab0;
                }
                env.next_char();
            }
            // gopast, line 41
            'golab5: loop {
                'lab6: loop {
                    if !env.out_grouping(G_v, 97, 121) {
                        break 'lab6;
                    }
                    break 'golab5;
                }
                if env.cursor >= env.limit {
                    break 'lab0;
                }
                env.next_char();
            }
            break 'lab1;
        }
        // setmark p1, line 42
        context.i_p1 = env.cursor;
        // gopast, line 43
        'golab7: loop {
            'lab8: loop {
                if !env.in_grouping(G_v, 97, 121) {
                    break 'lab8;
                }
                break 'golab7;
            }
            if env.cursor >= env.limit {
                break 'lab0;
            }
            env.next_char();
        }
        // gopast, line 43
        'golab9: loop {
            'lab10: loop {
                if !env.out_grouping(G_v, 97, 121) {
                    break 'lab10;
                }
                break 'golab9;
            }
            if env.cursor >= env.limit {
                break 'lab0;
            }
            env.next_char();
        }
        // setmark p2, line 43
        context.i_p2 = env.cursor;
        break 'lab0;
    }
    env.cursor = v_1;
    return true;
}

fn r_shortv(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 49
    // or, line 51
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 50
            if !env.out_grouping_b(G_v_WXY, 89, 121) {
                break 'lab1;
            }
            if !env.in_grouping_b(G_v, 97, 121) {
                break 'lab1;
            }
            if !env.out_grouping_b(G_v, 97, 121) {
                break 'lab1;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 52
        if !env.out_grouping_b(G_v, 97, 121) {
            return false;
        }
        if !env.in_grouping_b(G_v, 97, 121) {
            return false;
        }
        // atlimit, line 52
        if env.cursor > env.limit_backward {
            return false;
        }
        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_R2(env: &mut SnowballEnv, context: &mut Context) -> bool {
    if !(context.i_p2 <= env.cursor){
        return false;
    }
    return true;
}

fn r_Step_1a(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 58
    // try, line 59
    let v_1 = env.limit - env.cursor;
    'lab0: loop {
        // (, line 59
        // [, line 60
        env.ket = env.cursor;
        // substring, line 60
        among_var = env.find_among_b(A_1, context);
        if among_var == 0 {
            env.cursor = env.limit - v_1;
            break 'lab0;
        }
        // ], line 60
        env.bra = env.cursor;
        if among_var == 0 {
            env.cursor = env.limit - v_1;
            break 'lab0;
        } else if among_var == 1 {
            // (, line 62
            // delete, line 62
            if !env.slice_del() {
                return false;
            }
        }
        break 'lab0;
    }
    // [, line 65
    env.ket = env.cursor;
    // substring, line 65
    among_var = env.find_among_b(A_2, context);
    if among_var == 0 {
        return false;
    }
    // ], line 65
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 66
        // <-, line 66
        if !env.slice_from("ss") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 68
        // or, line 68
        'lab1: loop {
            let v_2 = env.limit - env.cursor;
            'lab2: loop {
                // (, line 68
                // hop, line 68
                let c = env.byte_index_for_hop(-2);
                if env.limit_backward as i32 > c || c > env.limit as i32 {
                    break 'lab2;
                }
                env.cursor = c as usize;
                // <-, line 68
                if !env.slice_from("i") {
                    return false;
                }
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            // <-, line 68
            if !env.slice_from("ie") {
                return false;
            }
            break 'lab1;
        }
    } else if among_var == 3 {
        // (, line 69
        // next, line 69
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
        // gopast, line 69
        'golab3: loop {
            'lab4: loop {
                if !env.in_grouping_b(G_v, 97, 121) {
                    break 'lab4;
                }
                break 'golab3;
            }
            if env.cursor <= env.limit_backward {
                return false;
            }
            env.previous_char();
        }
        // delete, line 69
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_Step_1b(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 74
    // [, line 75
    env.ket = env.cursor;
    // substring, line 75
    among_var = env.find_among_b(A_4, context);
    if among_var == 0 {
        return false;
    }
    // ], line 75
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 77
        // call R1, line 77
        if !r_R1(env, context) {
            return false;
        }
        // <-, line 77
        if !env.slice_from("ee") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 79
        // test, line 80
        let v_1 = env.limit - env.cursor;
        // gopast, line 80
        'golab0: loop {
            'lab1: loop {
                if !env.in_grouping_b(G_v, 97, 121) {
                    break 'lab1;
                }
                break 'golab0;
            }
            if env.cursor <= env.limit_backward {
                return false;
            }
            env.previous_char();
        }
        env.cursor = env.limit - v_1;
        // delete, line 80
        if !env.slice_del() {
            return false;
        }
        // test, line 81
        let v_3 = env.limit - env.cursor;
        // substring, line 81
        among_var = env.find_among_b(A_3, context);
        if among_var == 0 {
            return false;
        }
        env.cursor = env.limit - v_3;
        if among_var == 0 {
            return false;
        } else if among_var == 1 {
            // (, line 83
            // <+, line 83
            let c = env.cursor;
            let (bra, ket) = (env.cursor, env.cursor);
            env.insert(bra, ket, "e");
            env.cursor = c;
        } else if among_var == 2 {
            // (, line 86
            // [, line 86
            env.ket = env.cursor;
            // next, line 86
            if env.cursor <= env.limit_backward {
                return false;
            }
            env.previous_char();
            // ], line 86
            env.bra = env.cursor;
            // delete, line 86
            if !env.slice_del() {
                return false;
            }
        } else if among_var == 3 {
            // (, line 87
            // atmark, line 87
            if env.cursor != context.i_p1 {
                return false;
            }
            // test, line 87
            let v_4 = env.limit - env.cursor;
            // call shortv, line 87
            if !r_shortv(env, context) {
                return false;
            }
            env.cursor = env.limit - v_4;
            // <+, line 87
            let c = env.cursor;
            let (bra, ket) = (env.cursor, env.cursor);
            env.insert(bra, ket, "e");
            env.cursor = c;
        }
    }
    return true;
}

fn r_Step_1c(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 93
    // [, line 94
    env.ket = env.cursor;
    // or, line 94
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // literal, line 94
            if !env.eq_s_b(&"y") {
                break 'lab1;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // literal, line 94
        if !env.eq_s_b(&"Y") {
            return false;
        }
        break 'lab0;
    }
    // ], line 94
    env.bra = env.cursor;
    if !env.out_grouping_b(G_v, 97, 121) {
        return false;
    }
    // not, line 95
    let v_2 = env.limit - env.cursor;
    'lab2: loop {
        // atlimit, line 95
        if env.cursor > env.limit_backward {
            break 'lab2;
        }
        return false;
    }
    env.cursor = env.limit - v_2;
    // <-, line 96
    if !env.slice_from("i") {
        return false;
    }
    return true;
}

fn r_Step_2(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 99
    // [, line 100
    env.ket = env.cursor;
    // substring, line 100
    among_var = env.find_among_b(A_5, context);
    if among_var == 0 {
        return false;
    }
    // ], line 100
    env.bra = env.cursor;
    // call R1, line 100
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 101
        // <-, line 101
        if !env.slice_from("tion") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 102
        // <-, line 102
        if !env.slice_from("ence") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 103
        // <-, line 103
        if !env.slice_from("ance") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 104
        // <-, line 104
        if !env.slice_from("able") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 105
        // <-, line 105
        if !env.slice_from("ent") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 107
        // <-, line 107
        if !env.slice_from("ize") {
            return false;
        }
    } else if among_var == 7 {
        // (, line 109
        // <-, line 109
        if !env.slice_from("ate") {
            return false;
        }
    } else if among_var == 8 {
        // (, line 111
        // <-, line 111
        if !env.slice_from("al") {
            return false;
        }
    } else if among_var == 9 {
        // (, line 112
        // <-, line 112
        if !env.slice_from("ful") {
            return false;
        }
    } else if among_var == 10 {
        // (, line 114
        // <-, line 114
        if !env.slice_from("ous") {
            return false;
        }
    } else if among_var == 11 {
        // (, line 116
        // <-, line 116
        if !env.slice_from("ive") {
            return false;
        }
    } else if among_var == 12 {
        // (, line 118
        // <-, line 118
        if !env.slice_from("ble") {
            return false;
        }
    } else if among_var == 13 {
        // (, line 119
        // literal, line 119
        if !env.eq_s_b(&"l") {
            return false;
        }
        // <-, line 119
        if !env.slice_from("og") {
            return false;
        }
    } else if among_var == 14 {
        // (, line 120
        // <-, line 120
        if !env.slice_from("ful") {
            return false;
        }
    } else if among_var == 15 {
        // (, line 121
        // <-, line 121
        if !env.slice_from("less") {
            return false;
        }
    } else if among_var == 16 {
        // (, line 122
        if !env.in_grouping_b(G_valid_LI, 99, 116) {
            return false;
        }
        // delete, line 122
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_Step_3(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 126
    // [, line 127
    env.ket = env.cursor;
    // substring, line 127
    among_var = env.find_among_b(A_6, context);
    if among_var == 0 {
        return false;
    }
    // ], line 127
    env.bra = env.cursor;
    // call R1, line 127
    if !r_R1(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 128
        // <-, line 128
        if !env.slice_from("tion") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 129
        // <-, line 129
        if !env.slice_from("ate") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 130
        // <-, line 130
        if !env.slice_from("al") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 132
        // <-, line 132
        if !env.slice_from("ic") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 134
        // delete, line 134
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 6 {
        // (, line 136
        // call R2, line 136
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 136
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_Step_4(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 140
    // [, line 141
    env.ket = env.cursor;
    // substring, line 141
    among_var = env.find_among_b(A_7, context);
    if among_var == 0 {
        return false;
    }
    // ], line 141
    env.bra = env.cursor;
    // call R2, line 141
    if !r_R2(env, context) {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 144
        // delete, line 144
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 145
        // or, line 145
        'lab0: loop {
            let v_1 = env.limit - env.cursor;
            'lab1: loop {
                // literal, line 145
                if !env.eq_s_b(&"s") {
                    break 'lab1;
                }
                break 'lab0;
            }
            env.cursor = env.limit - v_1;
            // literal, line 145
            if !env.eq_s_b(&"t") {
                return false;
            }
            break 'lab0;
        }
        // delete, line 145
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_Step_5(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 149
    // [, line 150
    env.ket = env.cursor;
    // substring, line 150
    among_var = env.find_among_b(A_8, context);
    if among_var == 0 {
        return false;
    }
    // ], line 150
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 151
        // or, line 151
        'lab0: loop {
            let v_1 = env.limit - env.cursor;
            'lab1: loop {
                // call R2, line 151
                if !r_R2(env, context) {
                    break 'lab1;
                }
                break 'lab0;
            }
            env.cursor = env.limit - v_1;
            // (, line 151
            // call R1, line 151
            if !r_R1(env, context) {
                return false;
            }
            // not, line 151
            let v_2 = env.limit - env.cursor;
            'lab2: loop {
                // call shortv, line 151
                if !r_shortv(env, context) {
                    break 'lab2;
                }
                return false;
            }
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        // delete, line 151
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 152
        // call R2, line 152
        if !r_R2(env, context) {
            return false;
        }
        // literal, line 152
        if !env.eq_s_b(&"l") {
            return false;
        }
        // delete, line 152
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_exception2(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 156
    // [, line 158
    env.ket = env.cursor;
    // substring, line 158
    if env.find_among_b(A_9, context) == 0 {
        return false;
    }
    // ], line 158
    env.bra = env.cursor;
    // atlimit, line 158
    if env.cursor > env.limit_backward {
        return false;
    }
    return true;
}

fn r_exception1(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 168
    // [, line 170
    env.bra = env.cursor;
    // substring, line 170
    among_var = env.find_among(A_10, context);
    if among_var == 0 {
        return false;
    }
    // ], line 170
    env.ket = env.cursor;
    // atlimit, line 170
    if env.cursor < env.limit {
        return false;
    }
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 174
        // <-, line 174
        if !env.slice_from("ski") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 175
        // <-, line 175
        if !env.slice_from("sky") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 176
        // <-, line 176
        if !env.slice_from("die") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 177
        // <-, line 177
        if !env.slice_from("lie") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 178
        // <-, line 178
        if !env.slice_from("tie") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 182
        // <-, line 182
        if !env.slice_from("idl") {
            return false;
        }
    } else if among_var == 7 {
        // (, line 183
        // <-, line 183
        if !env.slice_from("gentl") {
            return false;
        }
    } else if among_var == 8 {
        // (, line 184
        // <-, line 184
        if !env.slice_from("ugli") {
            return false;
        }
    } else if among_var == 9 {
        // (, line 185
        // <-, line 185
        if !env.slice_from("earli") {
            return false;
        }
    } else if among_var == 10 {
        // (, line 186
        // <-, line 186
        if !env.slice_from("onli") {
            return false;
        }
    } else if among_var == 11 {
        // (, line 187
        // <-, line 187
        if !env.slice_from("singl") {
            return false;
        }
    }
    return true;
}

fn r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 203
    // Boolean test Y_found, line 203
    if !context.b_Y_found {
        return false;
    }
    // repeat, line 203
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 203
            // goto, line 203
            'golab2: loop {
                let v_2 = env.cursor;
                'lab3: loop {
                    // (, line 203
                    // [, line 203
                    env.bra = env.cursor;
                    // literal, line 203
                    if !env.eq_s(&"Y") {
                        break 'lab3;
                    }
                    // ], line 203
                    env.ket = env.cursor;
                    env.cursor = v_2;
                    break 'golab2;
                }
                env.cursor = v_2;
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            // <-, line 203
            if !env.slice_from("y") {
                return false;
            }
            continue 'replab0;
        }
        env.cursor = v_1;
        break 'replab0;
    }
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        b_Y_found: false,
        i_p2: 0,
        i_p1: 0,
    };
    // (, line 205
    // or, line 207
    'lab0: loop {
        let v_1 = env.cursor;
        'lab1: loop {
            // call exception1, line 207
            if !r_exception1(env, context) {
                break 'lab1;
            }
            break 'lab0;
        }
        env.cursor = v_1;
        'lab2: loop {
            // not, line 208
            let v_2 = env.cursor;
            'lab3: loop {
                // hop, line 208
                let c = env.byte_index_for_hop(3);
                if 0 as i32 > c || c > env.limit as i32 {
                    break 'lab3;
                }
                env.cursor = c as usize;
                break 'lab2;
            }
            env.cursor = v_2;
            break 'lab0;
        }
        env.cursor = v_1;
        // (, line 208
        // do, line 209
        let v_3 = env.cursor;
        'lab4: loop {
            // call prelude, line 209
            if !r_prelude(env, context) {
                break 'lab4;
            }
            break 'lab4;
        }
        env.cursor = v_3;
        // do, line 210
        let v_4 = env.cursor;
        'lab5: loop {
            // call mark_regions, line 210
            if !r_mark_regions(env, context) {
                break 'lab5;
            }
            break 'lab5;
        }
        env.cursor = v_4;
        // backwards, line 211
        env.limit_backward = env.cursor;
        env.cursor = env.limit;
        // (, line 211
        // do, line 213
        let v_5 = env.limit - env.cursor;
        'lab6: loop {
            // call Step_1a, line 213
            if !r_Step_1a(env, context) {
                break 'lab6;
            }
            break 'lab6;
        }
        env.cursor = env.limit - v_5;
        // or, line 215
        'lab7: loop {
            let v_6 = env.limit - env.cursor;
            'lab8: loop {
                // call exception2, line 215
                if !r_exception2(env, context) {
                    break 'lab8;
                }
                break 'lab7;
            }
            env.cursor = env.limit - v_6;
            // (, line 215
            // do, line 217
            let v_7 = env.limit - env.cursor;
            'lab9: loop {
                // call Step_1b, line 217
                if !r_Step_1b(env, context) {
                    break 'lab9;
                }
                break 'lab9;
            }
            env.cursor = env.limit - v_7;
            // do, line 218
            let v_8 = env.limit - env.cursor;
            'lab10: loop {
                // call Step_1c, line 218
                if !r_Step_1c(env, context) {
                    break 'lab10;
                }
                break 'lab10;
            }
            env.cursor = env.limit - v_8;
            // do, line 220
            let v_9 = env.limit - env.cursor;
            'lab11: loop {
                // call Step_2, line 220
                if !r_Step_2(env, context) {
                    break 'lab11;
                }
                break 'lab11;
            }
            env.cursor = env.limit - v_9;
            // do, line 221
            let v_10 = env.limit - env.cursor;
            'lab12: loop {
                // call Step_3, line 221
                if !r_Step_3(env, context) {
                    break 'lab12;
                }
                break 'lab12;
            }
            env.cursor = env.limit - v_10;
            // do, line 222
            let v_11 = env.limit - env.cursor;
            'lab13: loop {
                // call Step_4, line 222
                if !r_Step_4(env, context) {
                    break 'lab13;
                }
                break 'lab13;
            }
            env.cursor = env.limit - v_11;
            // do, line 224
            let v_12 = env.limit - env.cursor;
            'lab14: loop {
                // call Step_5, line 224
                if !r_Step_5(env, context) {
                    break 'lab14;
                }
                break 'lab14;
            }
            env.cursor = env.limit - v_12;
            break 'lab7;
        }
        env.cursor = env.limit_backward;
        // do, line 227
        let v_13 = env.cursor;
        'lab15: loop {
            // call postlude, line 227
            if !r_postlude(env, context) {
                break 'lab15;
            }
            break 'lab15;
        }
        env.cursor = v_13;
        break 'lab0;
    }
    return true;
}
