//! 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("col", -1, -1, None),
    Among("par", -1, -1, None),
    Among("tap", -1, -1, None),
];

static A_1: &'static [Among<Context>; 4] = &[
    Among("", -1, 4, None),
    Among("I", 0, 1, None),
    Among("U", 0, 2, None),
    Among("Y", 0, 3, None),
];

static A_2: &'static [Among<Context>; 6] = &[
    Among("iqU", -1, 3, None),
    Among("abl", -1, 3, None),
    Among("I\u{00E8}r", -1, 4, None),
    Among("i\u{00E8}r", -1, 4, None),
    Among("eus", -1, 2, None),
    Among("iv", -1, 1, None),
];

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

static A_4: &'static [Among<Context>; 43] = &[
    Among("iqUe", -1, 1, None),
    Among("atrice", -1, 2, None),
    Among("ance", -1, 1, None),
    Among("ence", -1, 5, None),
    Among("logie", -1, 3, None),
    Among("able", -1, 1, None),
    Among("isme", -1, 1, None),
    Among("euse", -1, 11, None),
    Among("iste", -1, 1, None),
    Among("ive", -1, 8, None),
    Among("if", -1, 8, None),
    Among("usion", -1, 4, None),
    Among("ation", -1, 2, None),
    Among("ution", -1, 4, None),
    Among("ateur", -1, 2, None),
    Among("iqUes", -1, 1, None),
    Among("atrices", -1, 2, None),
    Among("ances", -1, 1, None),
    Among("ences", -1, 5, None),
    Among("logies", -1, 3, None),
    Among("ables", -1, 1, None),
    Among("ismes", -1, 1, None),
    Among("euses", -1, 11, None),
    Among("istes", -1, 1, None),
    Among("ives", -1, 8, None),
    Among("ifs", -1, 8, None),
    Among("usions", -1, 4, None),
    Among("ations", -1, 2, None),
    Among("utions", -1, 4, None),
    Among("ateurs", -1, 2, None),
    Among("ments", -1, 15, None),
    Among("ements", 30, 6, None),
    Among("issements", 31, 12, None),
    Among("it\u{00E9}s", -1, 7, None),
    Among("ment", -1, 15, None),
    Among("ement", 34, 6, None),
    Among("issement", 35, 12, None),
    Among("amment", 34, 13, None),
    Among("emment", 34, 14, None),
    Among("aux", -1, 10, None),
    Among("eaux", 39, 9, None),
    Among("eux", -1, 1, None),
    Among("it\u{00E9}", -1, 7, None),
];

static A_5: &'static [Among<Context>; 35] = &[
    Among("ira", -1, 1, None),
    Among("ie", -1, 1, None),
    Among("isse", -1, 1, None),
    Among("issante", -1, 1, None),
    Among("i", -1, 1, None),
    Among("irai", 4, 1, None),
    Among("ir", -1, 1, None),
    Among("iras", -1, 1, None),
    Among("ies", -1, 1, None),
    Among("\u{00EE}mes", -1, 1, None),
    Among("isses", -1, 1, None),
    Among("issantes", -1, 1, None),
    Among("\u{00EE}tes", -1, 1, None),
    Among("is", -1, 1, None),
    Among("irais", 13, 1, None),
    Among("issais", 13, 1, None),
    Among("irions", -1, 1, None),
    Among("issions", -1, 1, None),
    Among("irons", -1, 1, None),
    Among("issons", -1, 1, None),
    Among("issants", -1, 1, None),
    Among("it", -1, 1, None),
    Among("irait", 21, 1, None),
    Among("issait", 21, 1, None),
    Among("issant", -1, 1, None),
    Among("iraIent", -1, 1, None),
    Among("issaIent", -1, 1, None),
    Among("irent", -1, 1, None),
    Among("issent", -1, 1, None),
    Among("iront", -1, 1, None),
    Among("\u{00EE}t", -1, 1, None),
    Among("iriez", -1, 1, None),
    Among("issiez", -1, 1, None),
    Among("irez", -1, 1, None),
    Among("issez", -1, 1, None),
];

static A_6: &'static [Among<Context>; 38] = &[
    Among("a", -1, 3, None),
    Among("era", 0, 2, None),
    Among("asse", -1, 3, None),
    Among("ante", -1, 3, None),
    Among("\u{00E9}e", -1, 2, None),
    Among("ai", -1, 3, None),
    Among("erai", 5, 2, None),
    Among("er", -1, 2, None),
    Among("as", -1, 3, None),
    Among("eras", 8, 2, None),
    Among("\u{00E2}mes", -1, 3, None),
    Among("asses", -1, 3, None),
    Among("antes", -1, 3, None),
    Among("\u{00E2}tes", -1, 3, None),
    Among("\u{00E9}es", -1, 2, None),
    Among("ais", -1, 3, None),
    Among("erais", 15, 2, None),
    Among("ions", -1, 1, None),
    Among("erions", 17, 2, None),
    Among("assions", 17, 3, None),
    Among("erons", -1, 2, None),
    Among("ants", -1, 3, None),
    Among("\u{00E9}s", -1, 2, None),
    Among("ait", -1, 3, None),
    Among("erait", 23, 2, None),
    Among("ant", -1, 3, None),
    Among("aIent", -1, 3, None),
    Among("eraIent", 26, 2, None),
    Among("\u{00E8}rent", -1, 2, None),
    Among("assent", -1, 3, None),
    Among("eront", -1, 2, None),
    Among("\u{00E2}t", -1, 3, None),
    Among("ez", -1, 2, None),
    Among("iez", 32, 2, None),
    Among("eriez", 33, 2, None),
    Among("assiez", 33, 3, None),
    Among("erez", 32, 2, None),
    Among("\u{00E9}", -1, 2, None),
];

static A_7: &'static [Among<Context>; 7] = &[
    Among("e", -1, 3, None),
    Among("I\u{00E8}re", 0, 2, None),
    Among("i\u{00E8}re", 0, 2, None),
    Among("ion", -1, 1, None),
    Among("Ier", -1, 2, None),
    Among("ier", -1, 2, None),
    Among("\u{00EB}", -1, 4, None),
];

static A_8: &'static [Among<Context>; 5] = &[
    Among("ell", -1, -1, None),
    Among("eill", -1, -1, None),
    Among("enn", -1, -1, None),
    Among("onn", -1, -1, None),
    Among("ett", -1, -1, None),
];

static G_v: &'static [u8; 20] = &[17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 130, 103, 8, 5];

static G_keep_with_s: &'static [u8; 17] = &[1, 65, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128];

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

fn r_prelude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // repeat, line 38
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // goto, line 38
            'golab2: loop {
                let v_2 = env.cursor;
                'lab3: loop {
                    // (, line 38
                    // or, line 44
                    'lab4: loop {
                        let v_3 = env.cursor;
                        'lab5: loop {
                            // (, line 40
                            if !env.in_grouping(G_v, 97, 251) {
                                break 'lab5;
                            }
                            // [, line 40
                            env.bra = env.cursor;
                            // or, line 40
                            'lab6: loop {
                                let v_4 = env.cursor;
                                'lab7: loop {
                                    // (, line 40
                                    // literal, line 40
                                    if !env.eq_s(&"u") {
                                        break 'lab7;
                                    }
                                    // ], line 40
                                    env.ket = env.cursor;
                                    if !env.in_grouping(G_v, 97, 251) {
                                        break 'lab7;
                                    }
                                    // <-, line 40
                                    if !env.slice_from("U") {
                                        return false;
                                    }
                                    break 'lab6;
                                }
                                env.cursor = v_4;
                                'lab8: loop {
                                    // (, line 41
                                    // literal, line 41
                                    if !env.eq_s(&"i") {
                                        break 'lab8;
                                    }
                                    // ], line 41
                                    env.ket = env.cursor;
                                    if !env.in_grouping(G_v, 97, 251) {
                                        break 'lab8;
                                    }
                                    // <-, line 41
                                    if !env.slice_from("I") {
                                        return false;
                                    }
                                    break 'lab6;
                                }
                                env.cursor = v_4;
                                // (, line 42
                                // literal, line 42
                                if !env.eq_s(&"y") {
                                    break 'lab5;
                                }
                                // ], line 42
                                env.ket = env.cursor;
                                // <-, line 42
                                if !env.slice_from("Y") {
                                    return false;
                                }
                                break 'lab6;
                            }
                            break 'lab4;
                        }
                        env.cursor = v_3;
                        'lab9: loop {
                            // (, line 45
                            // [, line 45
                            env.bra = env.cursor;
                            // literal, line 45
                            if !env.eq_s(&"y") {
                                break 'lab9;
                            }
                            // ], line 45
                            env.ket = env.cursor;
                            if !env.in_grouping(G_v, 97, 251) {
                                break 'lab9;
                            }
                            // <-, line 45
                            if !env.slice_from("Y") {
                                return false;
                            }
                            break 'lab4;
                        }
                        env.cursor = v_3;
                        // (, line 47
                        // literal, line 47
                        if !env.eq_s(&"q") {
                            break 'lab3;
                        }
                        // [, line 47
                        env.bra = env.cursor;
                        // literal, line 47
                        if !env.eq_s(&"u") {
                            break 'lab3;
                        }
                        // ], line 47
                        env.ket = env.cursor;
                        // <-, line 47
                        if !env.slice_from("U") {
                            return false;
                        }
                        break 'lab4;
                    }
                    env.cursor = v_2;
                    break 'golab2;
                }
                env.cursor = v_2;
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            continue 'replab0;
        }
        env.cursor = v_1;
        break 'replab0;
    }
    return true;
}

fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 50
    context.i_pV = env.limit;
    context.i_p1 = env.limit;
    context.i_p2 = env.limit;
    // do, line 56
    let v_1 = env.cursor;
    'lab0: loop {
        // (, line 56
        // or, line 58
        'lab1: loop {
            let v_2 = env.cursor;
            'lab2: loop {
                // (, line 57
                if !env.in_grouping(G_v, 97, 251) {
                    break 'lab2;
                }
                if !env.in_grouping(G_v, 97, 251) {
                    break 'lab2;
                }
                // next, line 57
                if env.cursor >= env.limit {
                    break 'lab2;
                }
                env.next_char();
                break 'lab1;
            }
            env.cursor = v_2;
            'lab3: loop {
                // among, line 59
                if env.find_among(A_0, context) == 0 {
                    break 'lab3;
                }
                break 'lab1;
            }
            env.cursor = v_2;
            // (, line 66
            // next, line 66
            if env.cursor >= env.limit {
                break 'lab0;
            }
            env.next_char();
            // gopast, line 66
            'golab4: loop {
                'lab5: loop {
                    if !env.in_grouping(G_v, 97, 251) {
                        break 'lab5;
                    }
                    break 'golab4;
                }
                if env.cursor >= env.limit {
                    break 'lab0;
                }
                env.next_char();
            }
            break 'lab1;
        }
        // setmark pV, line 67
        context.i_pV = env.cursor;
        break 'lab0;
    }
    env.cursor = v_1;
    // do, line 69
    let v_4 = env.cursor;
    'lab6: loop {
        // (, line 69
        // gopast, line 70
        'golab7: loop {
            'lab8: loop {
                if !env.in_grouping(G_v, 97, 251) {
                    break 'lab8;
                }
                break 'golab7;
            }
            if env.cursor >= env.limit {
                break 'lab6;
            }
            env.next_char();
        }
        // gopast, line 70
        'golab9: loop {
            'lab10: loop {
                if !env.out_grouping(G_v, 97, 251) {
                    break 'lab10;
                }
                break 'golab9;
            }
            if env.cursor >= env.limit {
                break 'lab6;
            }
            env.next_char();
        }
        // setmark p1, line 70
        context.i_p1 = env.cursor;
        // gopast, line 71
        'golab11: loop {
            'lab12: loop {
                if !env.in_grouping(G_v, 97, 251) {
                    break 'lab12;
                }
                break 'golab11;
            }
            if env.cursor >= env.limit {
                break 'lab6;
            }
            env.next_char();
        }
        // gopast, line 71
        'golab13: loop {
            'lab14: loop {
                if !env.out_grouping(G_v, 97, 251) {
                    break 'lab14;
                }
                break 'golab13;
            }
            if env.cursor >= env.limit {
                break 'lab6;
            }
            env.next_char();
        }
        // setmark p2, line 71
        context.i_p2 = env.cursor;
        break 'lab6;
    }
    env.cursor = v_4;
    return true;
}

fn r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // repeat, line 75
    'replab0: loop{
        let v_1 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 75
            // [, line 77
            env.bra = env.cursor;
            // substring, line 77
            among_var = env.find_among(A_1, context);
            if among_var == 0 {
                break 'lab1;
            }
            // ], line 77
            env.ket = env.cursor;
            if among_var == 0 {
                break 'lab1;
            } else if among_var == 1 {
                // (, line 78
                // <-, line 78
                if !env.slice_from("i") {
                    return false;
                }
            } else if among_var == 2 {
                // (, line 79
                // <-, line 79
                if !env.slice_from("u") {
                    return false;
                }
            } else if among_var == 3 {
                // (, line 80
                // <-, line 80
                if !env.slice_from("y") {
                    return false;
                }
            } else if among_var == 4 {
                // (, line 81
                // next, line 81
                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_standard_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 91
    // [, line 92
    env.ket = env.cursor;
    // substring, line 92
    among_var = env.find_among_b(A_4, context);
    if among_var == 0 {
        return false;
    }
    // ], line 92
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 96
        // call R2, line 96
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 96
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 99
        // call R2, line 99
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 99
        if !env.slice_del() {
            return false;
        }
        // try, line 100
        let v_1 = env.limit - env.cursor;
        'lab0: loop {
            // (, line 100
            // [, line 100
            env.ket = env.cursor;
            // literal, line 100
            if !env.eq_s_b(&"ic") {
                env.cursor = env.limit - v_1;
                break 'lab0;
            }
            // ], line 100
            env.bra = env.cursor;
            // or, line 100
            'lab1: loop {
                let v_2 = env.limit - env.cursor;
                'lab2: loop {
                    // (, line 100
                    // call R2, line 100
                    if !r_R2(env, context) {
                        break 'lab2;
                    }
                    // delete, line 100
                    if !env.slice_del() {
                        return false;
                    }
                    break 'lab1;
                }
                env.cursor = env.limit - v_2;
                // <-, line 100
                if !env.slice_from("iqU") {
                    return false;
                }
                break 'lab1;
            }
            break 'lab0;
        }
    } else if among_var == 3 {
        // (, line 104
        // call R2, line 104
        if !r_R2(env, context) {
            return false;
        }
        // <-, line 104
        if !env.slice_from("log") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 107
        // call R2, line 107
        if !r_R2(env, context) {
            return false;
        }
        // <-, line 107
        if !env.slice_from("u") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 110
        // call R2, line 110
        if !r_R2(env, context) {
            return false;
        }
        // <-, line 110
        if !env.slice_from("ent") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 113
        // call RV, line 114
        if !r_RV(env, context) {
            return false;
        }
        // delete, line 114
        if !env.slice_del() {
            return false;
        }
        // try, line 115
        let v_3 = env.limit - env.cursor;
        'lab3: loop {
            // (, line 115
            // [, line 116
            env.ket = env.cursor;
            // substring, line 116
            among_var = env.find_among_b(A_2, context);
            if among_var == 0 {
                env.cursor = env.limit - v_3;
                break 'lab3;
            }
            // ], line 116
            env.bra = env.cursor;
            if among_var == 0 {
                env.cursor = env.limit - v_3;
                break 'lab3;
            } else if among_var == 1 {
                // (, line 117
                // call R2, line 117
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_3;
                    break 'lab3;
                }
                // delete, line 117
                if !env.slice_del() {
                    return false;
                }
                // [, line 117
                env.ket = env.cursor;
                // literal, line 117
                if !env.eq_s_b(&"at") {
                    env.cursor = env.limit - v_3;
                    break 'lab3;
                }
                // ], line 117
                env.bra = env.cursor;
                // call R2, line 117
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_3;
                    break 'lab3;
                }
                // delete, line 117
                if !env.slice_del() {
                    return false;
                }
            } else if among_var == 2 {
                // (, line 118
                // or, line 118
                'lab4: loop {
                    let v_4 = env.limit - env.cursor;
                    'lab5: loop {
                        // (, line 118
                        // call R2, line 118
                        if !r_R2(env, context) {
                            break 'lab5;
                        }
                        // delete, line 118
                        if !env.slice_del() {
                            return false;
                        }
                        break 'lab4;
                    }
                    env.cursor = env.limit - v_4;
                    // (, line 118
                    // call R1, line 118
                    if !r_R1(env, context) {
                        env.cursor = env.limit - v_3;
                        break 'lab3;
                    }
                    // <-, line 118
                    if !env.slice_from("eux") {
                        return false;
                    }
                    break 'lab4;
                }
            } else if among_var == 3 {
                // (, line 120
                // call R2, line 120
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_3;
                    break 'lab3;
                }
                // delete, line 120
                if !env.slice_del() {
                    return false;
                }
            } else if among_var == 4 {
                // (, line 122
                // call RV, line 122
                if !r_RV(env, context) {
                    env.cursor = env.limit - v_3;
                    break 'lab3;
                }
                // <-, line 122
                if !env.slice_from("i") {
                    return false;
                }
            }
            break 'lab3;
        }
    } else if among_var == 7 {
        // (, line 128
        // call R2, line 129
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 129
        if !env.slice_del() {
            return false;
        }
        // try, line 130
        let v_5 = env.limit - env.cursor;
        'lab6: loop {
            // (, line 130
            // [, line 131
            env.ket = env.cursor;
            // substring, line 131
            among_var = env.find_among_b(A_3, context);
            if among_var == 0 {
                env.cursor = env.limit - v_5;
                break 'lab6;
            }
            // ], line 131
            env.bra = env.cursor;
            if among_var == 0 {
                env.cursor = env.limit - v_5;
                break 'lab6;
            } else if among_var == 1 {
                // (, line 132
                // or, line 132
                'lab7: loop {
                    let v_6 = env.limit - env.cursor;
                    'lab8: loop {
                        // (, line 132
                        // call R2, line 132
                        if !r_R2(env, context) {
                            break 'lab8;
                        }
                        // delete, line 132
                        if !env.slice_del() {
                            return false;
                        }
                        break 'lab7;
                    }
                    env.cursor = env.limit - v_6;
                    // <-, line 132
                    if !env.slice_from("abl") {
                        return false;
                    }
                    break 'lab7;
                }
            } else if among_var == 2 {
                // (, line 133
                // or, line 133
                'lab9: loop {
                    let v_7 = env.limit - env.cursor;
                    'lab10: loop {
                        // (, line 133
                        // call R2, line 133
                        if !r_R2(env, context) {
                            break 'lab10;
                        }
                        // delete, line 133
                        if !env.slice_del() {
                            return false;
                        }
                        break 'lab9;
                    }
                    env.cursor = env.limit - v_7;
                    // <-, line 133
                    if !env.slice_from("iqU") {
                        return false;
                    }
                    break 'lab9;
                }
            } else if among_var == 3 {
                // (, line 134
                // call R2, line 134
                if !r_R2(env, context) {
                    env.cursor = env.limit - v_5;
                    break 'lab6;
                }
                // delete, line 134
                if !env.slice_del() {
                    return false;
                }
            }
            break 'lab6;
        }
    } else if among_var == 8 {
        // (, line 140
        // call R2, line 141
        if !r_R2(env, context) {
            return false;
        }
        // delete, line 141
        if !env.slice_del() {
            return false;
        }
        // try, line 142
        let v_8 = env.limit - env.cursor;
        'lab11: loop {
            // (, line 142
            // [, line 142
            env.ket = env.cursor;
            // literal, line 142
            if !env.eq_s_b(&"at") {
                env.cursor = env.limit - v_8;
                break 'lab11;
            }
            // ], line 142
            env.bra = env.cursor;
            // call R2, line 142
            if !r_R2(env, context) {
                env.cursor = env.limit - v_8;
                break 'lab11;
            }
            // delete, line 142
            if !env.slice_del() {
                return false;
            }
            // [, line 142
            env.ket = env.cursor;
            // literal, line 142
            if !env.eq_s_b(&"ic") {
                env.cursor = env.limit - v_8;
                break 'lab11;
            }
            // ], line 142
            env.bra = env.cursor;
            // or, line 142
            'lab12: loop {
                let v_9 = env.limit - env.cursor;
                'lab13: loop {
                    // (, line 142
                    // call R2, line 142
                    if !r_R2(env, context) {
                        break 'lab13;
                    }
                    // delete, line 142
                    if !env.slice_del() {
                        return false;
                    }
                    break 'lab12;
                }
                env.cursor = env.limit - v_9;
                // <-, line 142
                if !env.slice_from("iqU") {
                    return false;
                }
                break 'lab12;
            }
            break 'lab11;
        }
    } else if among_var == 9 {
        // (, line 144
        // <-, line 144
        if !env.slice_from("eau") {
            return false;
        }
    } else if among_var == 10 {
        // (, line 145
        // call R1, line 145
        if !r_R1(env, context) {
            return false;
        }
        // <-, line 145
        if !env.slice_from("al") {
            return false;
        }
    } else if among_var == 11 {
        // (, line 147
        // or, line 147
        'lab14: loop {
            let v_10 = env.limit - env.cursor;
            'lab15: loop {
                // (, line 147
                // call R2, line 147
                if !r_R2(env, context) {
                    break 'lab15;
                }
                // delete, line 147
                if !env.slice_del() {
                    return false;
                }
                break 'lab14;
            }
            env.cursor = env.limit - v_10;
            // (, line 147
            // call R1, line 147
            if !r_R1(env, context) {
                return false;
            }
            // <-, line 147
            if !env.slice_from("eux") {
                return false;
            }
            break 'lab14;
        }
    } else if among_var == 12 {
        // (, line 150
        // call R1, line 150
        if !r_R1(env, context) {
            return false;
        }
        if !env.out_grouping_b(G_v, 97, 251) {
            return false;
        }
        // delete, line 150
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 13 {
        // (, line 155
        // call RV, line 155
        if !r_RV(env, context) {
            return false;
        }
        // fail, line 155
        // (, line 155
        // <-, line 155
        if !env.slice_from("ant") {
            return false;
        }
        return false;
    } else if among_var == 14 {
        // (, line 156
        // call RV, line 156
        if !r_RV(env, context) {
            return false;
        }
        // fail, line 156
        // (, line 156
        // <-, line 156
        if !env.slice_from("ent") {
            return false;
        }
        return false;
    } else if among_var == 15 {
        // (, line 158
        // test, line 158
        let v_11 = env.limit - env.cursor;
        // (, line 158
        if !env.in_grouping_b(G_v, 97, 251) {
            return false;
        }
        // call RV, line 158
        if !r_RV(env, context) {
            return false;
        }
        env.cursor = env.limit - v_11;
        // fail, line 158
        // (, line 158
        // delete, line 158
        if !env.slice_del() {
            return false;
        }
        return false;
    }
    return true;
}

fn r_i_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // setlimit, line 163
    let v_1 = env.limit - env.cursor;
    // tomark, line 163
    if env.cursor < context.i_pV {
        return false;
    }
    env.cursor = context.i_pV;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 163
    // [, line 164
    env.ket = env.cursor;
    // substring, line 164
    among_var = env.find_among_b(A_5, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 164
    env.bra = env.cursor;
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    } else if among_var == 1 {
        // (, line 170
        if !env.out_grouping_b(G_v, 97, 251) {
            env.limit_backward = v_2;
            return false;
        }
        // delete, line 170
        if !env.slice_del() {
            return false;
        }
    }
    env.limit_backward = v_2;
    return true;
}

fn r_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // setlimit, line 174
    let v_1 = env.limit - env.cursor;
    // tomark, line 174
    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 174
    // [, line 175
    env.ket = env.cursor;
    // substring, line 175
    among_var = env.find_among_b(A_6, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 175
    env.bra = env.cursor;
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    } else if among_var == 1 {
        // (, line 177
        // call R2, line 177
        if !r_R2(env, context) {
            env.limit_backward = v_2;
            return false;
        }
        // delete, line 177
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 185
        // delete, line 185
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 3 {
        // (, line 190
        // delete, line 190
        if !env.slice_del() {
            return false;
        }
        // try, line 191
        let v_3 = env.limit - env.cursor;
        'lab0: loop {
            // (, line 191
            // [, line 191
            env.ket = env.cursor;
            // literal, line 191
            if !env.eq_s_b(&"e") {
                env.cursor = env.limit - v_3;
                break 'lab0;
            }
            // ], line 191
            env.bra = env.cursor;
            // delete, line 191
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
    }
    env.limit_backward = v_2;
    return true;
}

fn r_residual_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 198
    // try, line 199
    let v_1 = env.limit - env.cursor;
    'lab0: loop {
        // (, line 199
        // [, line 199
        env.ket = env.cursor;
        // literal, line 199
        if !env.eq_s_b(&"s") {
            env.cursor = env.limit - v_1;
            break 'lab0;
        }
        // ], line 199
        env.bra = env.cursor;
        // test, line 199
        let v_2 = env.limit - env.cursor;
        if !env.out_grouping_b(G_keep_with_s, 97, 232) {
            env.cursor = env.limit - v_1;
            break 'lab0;
        }
        env.cursor = env.limit - v_2;
        // delete, line 199
        if !env.slice_del() {
            return false;
        }
        break 'lab0;
    }
    // setlimit, line 200
    let v_3 = env.limit - env.cursor;
    // tomark, line 200
    if env.cursor < context.i_pV {
        return false;
    }
    env.cursor = context.i_pV;
    let v_4 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_3;
    // (, line 200
    // [, line 201
    env.ket = env.cursor;
    // substring, line 201
    among_var = env.find_among_b(A_7, context);
    if among_var == 0 {
        env.limit_backward = v_4;
        return false;
    }
    // ], line 201
    env.bra = env.cursor;
    if among_var == 0 {
        env.limit_backward = v_4;
        return false;
    } else if among_var == 1 {
        // (, line 202
        // call R2, line 202
        if !r_R2(env, context) {
            env.limit_backward = v_4;
            return false;
        }
        // or, line 202
        'lab1: loop {
            let v_5 = env.limit - env.cursor;
            'lab2: loop {
                // literal, line 202
                if !env.eq_s_b(&"s") {
                    break 'lab2;
                }
                break 'lab1;
            }
            env.cursor = env.limit - v_5;
            // literal, line 202
            if !env.eq_s_b(&"t") {
                env.limit_backward = v_4;
                return false;
            }
            break 'lab1;
        }
        // delete, line 202
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 204
        // <-, line 204
        if !env.slice_from("i") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 205
        // delete, line 205
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 4 {
        // (, line 206
        // literal, line 206
        if !env.eq_s_b(&"gu") {
            env.limit_backward = v_4;
            return false;
        }
        // delete, line 206
        if !env.slice_del() {
            return false;
        }
    }
    env.limit_backward = v_4;
    return true;
}

fn r_un_double(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 211
    // test, line 212
    let v_1 = env.limit - env.cursor;
    // among, line 212
    if env.find_among_b(A_8, context) == 0 {
        return false;
    }
    env.cursor = env.limit - v_1;
    // [, line 212
    env.ket = env.cursor;
    // next, line 212
    if env.cursor <= env.limit_backward {
        return false;
    }
    env.previous_char();
    // ], line 212
    env.bra = env.cursor;
    // delete, line 212
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_un_accent(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 215
    // atleast, line 216
    let mut v_1 = 1;
    // atleast, line 216
    'replab0: loop{
        'lab1: for _ in 0..1 {
            if !env.out_grouping_b(G_v, 97, 251) {
                break 'lab1;
            }
            v_1 -= 1;
            continue 'replab0;
        }
        break 'replab0;
    }
    if v_1 > 0 {
        return false;
    }
    // [, line 217
    env.ket = env.cursor;
    // or, line 217
    'lab2: loop {
        let v_3 = env.limit - env.cursor;
        'lab3: loop {
            // literal, line 217
            if !env.eq_s_b(&"\u{00E9}") {
                break 'lab3;
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        // literal, line 217
        if !env.eq_s_b(&"\u{00E8}") {
            return false;
        }
        break 'lab2;
    }
    // ], line 217
    env.bra = env.cursor;
    // <-, line 217
    if !env.slice_from("e") {
        return false;
    }
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        i_p2: 0,
        i_p1: 0,
        i_pV: 0,
    };
    // (, line 221
    // do, line 223
    let v_1 = env.cursor;
    'lab0: loop {
        // call prelude, line 223
        if !r_prelude(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // do, line 224
    let v_2 = env.cursor;
    'lab1: loop {
        // call mark_regions, line 224
        if !r_mark_regions(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = v_2;
    // backwards, line 225
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 225
    // do, line 227
    let v_3 = env.limit - env.cursor;
    'lab2: loop {
        // (, line 227
        // or, line 237
        'lab3: loop {
            let v_4 = env.limit - env.cursor;
            'lab4: loop {
                // (, line 228
                // and, line 233
                let v_5 = env.limit - env.cursor;
                // (, line 229
                // or, line 229
                'lab5: loop {
                    let v_6 = env.limit - env.cursor;
                    'lab6: loop {
                        // call standard_suffix, line 229
                        if !r_standard_suffix(env, context) {
                            break 'lab6;
                        }
                        break 'lab5;
                    }
                    env.cursor = env.limit - v_6;
                    'lab7: loop {
                        // call i_verb_suffix, line 230
                        if !r_i_verb_suffix(env, context) {
                            break 'lab7;
                        }
                        break 'lab5;
                    }
                    env.cursor = env.limit - v_6;
                    // call verb_suffix, line 231
                    if !r_verb_suffix(env, context) {
                        break 'lab4;
                    }
                    break 'lab5;
                }
                env.cursor = env.limit - v_5;
                // try, line 234
                let v_7 = env.limit - env.cursor;
                'lab8: loop {
                    // (, line 234
                    // [, line 234
                    env.ket = env.cursor;
                    // or, line 234
                    'lab9: loop {
                        let v_8 = env.limit - env.cursor;
                        'lab10: loop {
                            // (, line 234
                            // literal, line 234
                            if !env.eq_s_b(&"Y") {
                                break 'lab10;
                            }
                            // ], line 234
                            env.bra = env.cursor;
                            // <-, line 234
                            if !env.slice_from("i") {
                                return false;
                            }
                            break 'lab9;
                        }
                        env.cursor = env.limit - v_8;
                        // (, line 235
                        // literal, line 235
                        if !env.eq_s_b(&"\u{00E7}") {
                            env.cursor = env.limit - v_7;
                            break 'lab8;
                        }
                        // ], line 235
                        env.bra = env.cursor;
                        // <-, line 235
                        if !env.slice_from("c") {
                            return false;
                        }
                        break 'lab9;
                    }
                    break 'lab8;
                }
                break 'lab3;
            }
            env.cursor = env.limit - v_4;
            // call residual_suffix, line 238
            if !r_residual_suffix(env, context) {
                break 'lab2;
            }
            break 'lab3;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_3;
    // do, line 243
    let v_9 = env.limit - env.cursor;
    'lab11: loop {
        // call un_double, line 243
        if !r_un_double(env, context) {
            break 'lab11;
        }
        break 'lab11;
    }
    env.cursor = env.limit - v_9;
    // do, line 244
    let v_10 = env.limit - env.cursor;
    'lab12: loop {
        // call un_accent, line 244
        if !r_un_accent(env, context) {
            break 'lab12;
        }
        break 'lab12;
    }
    env.cursor = env.limit - v_10;
    env.cursor = env.limit_backward;
    // do, line 246
    let v_11 = env.cursor;
    'lab13: loop {
        // call postlude, line 246
        if !r_postlude(env, context) {
            break 'lab13;
        }
        break 'lab13;
    }
    env.cursor = v_11;
    return true;
}
