//! 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>; 10] = &[
    Among("pa", -1, 1, None),
    Among("sti", -1, 2, None),
    Among("kaan", -1, 1, None),
    Among("han", -1, 1, None),
    Among("kin", -1, 1, None),
    Among("h\u{00E4}n", -1, 1, None),
    Among("k\u{00E4}\u{00E4}n", -1, 1, None),
    Among("ko", -1, 1, None),
    Among("p\u{00E4}", -1, 1, None),
    Among("k\u{00F6}", -1, 1, None),
];

static A_1: &'static [Among<Context>; 6] = &[
    Among("lla", -1, -1, None),
    Among("na", -1, -1, None),
    Among("ssa", -1, -1, None),
    Among("ta", -1, -1, None),
    Among("lta", 3, -1, None),
    Among("sta", 3, -1, None),
];

static A_2: &'static [Among<Context>; 6] = &[
    Among("ll\u{00E4}", -1, -1, None),
    Among("n\u{00E4}", -1, -1, None),
    Among("ss\u{00E4}", -1, -1, None),
    Among("t\u{00E4}", -1, -1, None),
    Among("lt\u{00E4}", 3, -1, None),
    Among("st\u{00E4}", 3, -1, None),
];

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

static A_4: &'static [Among<Context>; 9] = &[
    Among("nsa", -1, 3, None),
    Among("mme", -1, 3, None),
    Among("nne", -1, 3, None),
    Among("ni", -1, 2, None),
    Among("si", -1, 1, None),
    Among("an", -1, 4, None),
    Among("en", -1, 6, None),
    Among("\u{00E4}n", -1, 5, None),
    Among("ns\u{00E4}", -1, 3, None),
];

static A_5: &'static [Among<Context>; 7] = &[
    Among("aa", -1, -1, None),
    Among("ee", -1, -1, None),
    Among("ii", -1, -1, None),
    Among("oo", -1, -1, None),
    Among("uu", -1, -1, None),
    Among("\u{00E4}\u{00E4}", -1, -1, None),
    Among("\u{00F6}\u{00F6}", -1, -1, None),
];

static A_6: &'static [Among<Context>; 30] = &[
    Among("a", -1, 8, None),
    Among("lla", 0, -1, None),
    Among("na", 0, -1, None),
    Among("ssa", 0, -1, None),
    Among("ta", 0, -1, None),
    Among("lta", 4, -1, None),
    Among("sta", 4, -1, None),
    Among("tta", 4, 9, None),
    Among("lle", -1, -1, None),
    Among("ine", -1, -1, None),
    Among("ksi", -1, -1, None),
    Among("n", -1, 7, None),
    Among("han", 11, 1, None),
    Among("den", 11, -1, Some(&r_VI)),
    Among("seen", 11, -1, Some(&r_LONG)),
    Among("hen", 11, 2, None),
    Among("tten", 11, -1, Some(&r_VI)),
    Among("hin", 11, 3, None),
    Among("siin", 11, -1, Some(&r_VI)),
    Among("hon", 11, 4, None),
    Among("h\u{00E4}n", 11, 5, None),
    Among("h\u{00F6}n", 11, 6, None),
    Among("\u{00E4}", -1, 8, None),
    Among("ll\u{00E4}", 22, -1, None),
    Among("n\u{00E4}", 22, -1, None),
    Among("ss\u{00E4}", 22, -1, None),
    Among("t\u{00E4}", 22, -1, None),
    Among("lt\u{00E4}", 26, -1, None),
    Among("st\u{00E4}", 26, -1, None),
    Among("tt\u{00E4}", 26, 9, None),
];

static A_7: &'static [Among<Context>; 14] = &[
    Among("eja", -1, -1, None),
    Among("mma", -1, 1, None),
    Among("imma", 1, -1, None),
    Among("mpa", -1, 1, None),
    Among("impa", 3, -1, None),
    Among("mmi", -1, 1, None),
    Among("immi", 5, -1, None),
    Among("mpi", -1, 1, None),
    Among("impi", 7, -1, None),
    Among("ej\u{00E4}", -1, -1, None),
    Among("mm\u{00E4}", -1, 1, None),
    Among("imm\u{00E4}", 10, -1, None),
    Among("mp\u{00E4}", -1, 1, None),
    Among("imp\u{00E4}", 12, -1, None),
];

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

static A_9: &'static [Among<Context>; 2] = &[
    Among("mma", -1, 1, None),
    Among("imma", 0, -1, None),
];

static G_AEI: &'static [u8; 17] = &[17, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8];

static G_V1: &'static [u8; 19] = &[17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32];

static G_V2: &'static [u8; 19] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32];

static G_particle_end: &'static [u8; 19] = &[17, 97, 24, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32];

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

fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 40
    context.i_p1 = env.limit;
    context.i_p2 = env.limit;
    // goto, line 45
    'golab0: loop {
        let v_1 = env.cursor;
        'lab1: loop {
            if !env.in_grouping(G_V1, 97, 246) {
                break 'lab1;
            }
            env.cursor = v_1;
            break 'golab0;
        }
        env.cursor = v_1;
        if env.cursor >= env.limit {
            return false;
        }
        env.next_char();
    }
    // gopast, line 45
    'golab2: loop {
        'lab3: loop {
            if !env.out_grouping(G_V1, 97, 246) {
                break 'lab3;
            }
            break 'golab2;
        }
        if env.cursor >= env.limit {
            return false;
        }
        env.next_char();
    }
    // setmark p1, line 45
    context.i_p1 = env.cursor;
    // goto, line 46
    'golab4: loop {
        let v_3 = env.cursor;
        'lab5: loop {
            if !env.in_grouping(G_V1, 97, 246) {
                break 'lab5;
            }
            env.cursor = v_3;
            break 'golab4;
        }
        env.cursor = v_3;
        if env.cursor >= env.limit {
            return false;
        }
        env.next_char();
    }
    // gopast, line 46
    'golab6: loop {
        'lab7: loop {
            if !env.out_grouping(G_V1, 97, 246) {
                break 'lab7;
            }
            break 'golab6;
        }
        if env.cursor >= env.limit {
            return false;
        }
        env.next_char();
    }
    // setmark p2, line 46
    context.i_p2 = env.cursor;
    return true;
}

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

fn r_particle_etc(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 53
    // setlimit, line 54
    let v_1 = env.limit - env.cursor;
    // tomark, line 54
    if env.cursor < context.i_p1 {
        return false;
    }
    env.cursor = context.i_p1;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 54
    // [, line 54
    env.ket = env.cursor;
    // substring, line 54
    among_var = env.find_among_b(A_0, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 54
    env.bra = env.cursor;
    env.limit_backward = v_2;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 61
        if !env.in_grouping_b(G_particle_end, 97, 246) {
            return false;
        }
    } else if among_var == 2 {
        // (, line 63
        // call R2, line 63
        if !r_R2(env, context) {
            return false;
        }
    }
    // delete, line 65
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_possessive(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 67
    // setlimit, line 68
    let v_1 = env.limit - env.cursor;
    // tomark, line 68
    if env.cursor < context.i_p1 {
        return false;
    }
    env.cursor = context.i_p1;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 68
    // [, line 68
    env.ket = env.cursor;
    // substring, line 68
    among_var = env.find_among_b(A_4, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 68
    env.bra = env.cursor;
    env.limit_backward = v_2;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 71
        // not, line 71
        let v_3 = env.limit - env.cursor;
        'lab0: loop {
            // literal, line 71
            if !env.eq_s_b(&"k") {
                break 'lab0;
            }
            return false;
        }
        env.cursor = env.limit - v_3;
        // delete, line 71
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 2 {
        // (, line 73
        // delete, line 73
        if !env.slice_del() {
            return false;
        }
        // [, line 73
        env.ket = env.cursor;
        // literal, line 73
        if !env.eq_s_b(&"kse") {
            return false;
        }
        // ], line 73
        env.bra = env.cursor;
        // <-, line 73
        if !env.slice_from("ksi") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 77
        // delete, line 77
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 4 {
        // (, line 80
        // among, line 80
        if env.find_among_b(A_1, context) == 0 {
            return false;
        }
        // delete, line 80
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 5 {
        // (, line 82
        // among, line 82
        if env.find_among_b(A_2, context) == 0 {
            return false;
        }
        // delete, line 83
        if !env.slice_del() {
            return false;
        }
    } else if among_var == 6 {
        // (, line 85
        // among, line 85
        if env.find_among_b(A_3, context) == 0 {
            return false;
        }
        // delete, line 85
        if !env.slice_del() {
            return false;
        }
    }
    return true;
}

fn r_LONG(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // among, line 90
    if env.find_among_b(A_5, context) == 0 {
        return false;
    }
    return true;
}

fn r_VI(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 92
    // literal, line 92
    if !env.eq_s_b(&"i") {
        return false;
    }
    if !env.in_grouping_b(G_V2, 97, 246) {
        return false;
    }
    return true;
}

fn r_case_ending(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 94
    // setlimit, line 95
    let v_1 = env.limit - env.cursor;
    // tomark, line 95
    if env.cursor < context.i_p1 {
        return false;
    }
    env.cursor = context.i_p1;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 95
    // [, line 95
    env.ket = env.cursor;
    // substring, line 95
    among_var = env.find_among_b(A_6, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 95
    env.bra = env.cursor;
    env.limit_backward = v_2;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 97
        // literal, line 97
        if !env.eq_s_b(&"a") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 98
        // literal, line 98
        if !env.eq_s_b(&"e") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 99
        // literal, line 99
        if !env.eq_s_b(&"i") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 100
        // literal, line 100
        if !env.eq_s_b(&"o") {
            return false;
        }
    } else if among_var == 5 {
        // (, line 101
        // literal, line 101
        if !env.eq_s_b(&"\u{00E4}") {
            return false;
        }
    } else if among_var == 6 {
        // (, line 102
        // literal, line 102
        if !env.eq_s_b(&"\u{00F6}") {
            return false;
        }
    } else if among_var == 7 {
        // (, line 110
        // try, line 110
        let v_3 = env.limit - env.cursor;
        'lab0: loop {
            // (, line 110
            // and, line 112
            let v_4 = env.limit - env.cursor;
            // or, line 111
            'lab1: loop {
                let v_5 = env.limit - env.cursor;
                'lab2: loop {
                    // call LONG, line 110
                    if !r_LONG(env, context) {
                        break 'lab2;
                    }
                    break 'lab1;
                }
                env.cursor = env.limit - v_5;
                // literal, line 111
                if !env.eq_s_b(&"ie") {
                    env.cursor = env.limit - v_3;
                    break 'lab0;
                }
                break 'lab1;
            }
            env.cursor = env.limit - v_4;
            // next, line 112
            if env.cursor <= env.limit_backward {
                env.cursor = env.limit - v_3;
                break 'lab0;
            }
            env.previous_char();
            // ], line 112
            env.bra = env.cursor;
            break 'lab0;
        }
    } else if among_var == 8 {
        // (, line 118
        if !env.in_grouping_b(G_V1, 97, 246) {
            return false;
        }
        if !env.out_grouping_b(G_V1, 97, 246) {
            return false;
        }
    } else if among_var == 9 {
        // (, line 120
        // literal, line 120
        if !env.eq_s_b(&"e") {
            return false;
        }
    }
    // delete, line 137
    if !env.slice_del() {
        return false;
    }
    // set ending_removed, line 138
    context.b_ending_removed = true;
    return true;
}

fn r_other_endings(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 140
    // setlimit, line 141
    let v_1 = env.limit - env.cursor;
    // tomark, line 141
    if env.cursor < context.i_p2 {
        return false;
    }
    env.cursor = context.i_p2;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 141
    // [, line 141
    env.ket = env.cursor;
    // substring, line 141
    among_var = env.find_among_b(A_7, context);
    if among_var == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 141
    env.bra = env.cursor;
    env.limit_backward = v_2;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 145
        // not, line 145
        let v_3 = env.limit - env.cursor;
        'lab0: loop {
            // literal, line 145
            if !env.eq_s_b(&"po") {
                break 'lab0;
            }
            return false;
        }
        env.cursor = env.limit - v_3;
    }
    // delete, line 150
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_i_plural(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 152
    // setlimit, line 153
    let v_1 = env.limit - env.cursor;
    // tomark, line 153
    if env.cursor < context.i_p1 {
        return false;
    }
    env.cursor = context.i_p1;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 153
    // [, line 153
    env.ket = env.cursor;
    // substring, line 153
    if env.find_among_b(A_8, context) == 0 {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 153
    env.bra = env.cursor;
    env.limit_backward = v_2;
    // delete, line 157
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_t_plural(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 159
    // setlimit, line 160
    let v_1 = env.limit - env.cursor;
    // tomark, line 160
    if env.cursor < context.i_p1 {
        return false;
    }
    env.cursor = context.i_p1;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 160
    // [, line 161
    env.ket = env.cursor;
    // literal, line 161
    if !env.eq_s_b(&"t") {
        env.limit_backward = v_2;
        return false;
    }
    // ], line 161
    env.bra = env.cursor;
    // test, line 161
    let v_3 = env.limit - env.cursor;
    if !env.in_grouping_b(G_V1, 97, 246) {
        env.limit_backward = v_2;
        return false;
    }
    env.cursor = env.limit - v_3;
    // delete, line 162
    if !env.slice_del() {
        return false;
    }
    env.limit_backward = v_2;
    // setlimit, line 164
    let v_4 = env.limit - env.cursor;
    // tomark, line 164
    if env.cursor < context.i_p2 {
        return false;
    }
    env.cursor = context.i_p2;
    let v_5 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_4;
    // (, line 164
    // [, line 164
    env.ket = env.cursor;
    // substring, line 164
    among_var = env.find_among_b(A_9, context);
    if among_var == 0 {
        env.limit_backward = v_5;
        return false;
    }
    // ], line 164
    env.bra = env.cursor;
    env.limit_backward = v_5;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 166
        // not, line 166
        let v_6 = env.limit - env.cursor;
        'lab0: loop {
            // literal, line 166
            if !env.eq_s_b(&"po") {
                break 'lab0;
            }
            return false;
        }
        env.cursor = env.limit - v_6;
    }
    // delete, line 169
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_tidy(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 171
    // setlimit, line 172
    let v_1 = env.limit - env.cursor;
    // tomark, line 172
    if env.cursor < context.i_p1 {
        return false;
    }
    env.cursor = context.i_p1;
    let v_2 = env.limit_backward;
    env.limit_backward = env.cursor;
    env.cursor = env.limit - v_1;
    // (, line 172
    // do, line 173
    let v_3 = env.limit - env.cursor;
    'lab0: loop {
        // (, line 173
        // and, line 173
        let v_4 = env.limit - env.cursor;
        // call LONG, line 173
        if !r_LONG(env, context) {
            break 'lab0;
        }
        env.cursor = env.limit - v_4;
        // (, line 173
        // [, line 173
        env.ket = env.cursor;
        // next, line 173
        if env.cursor <= env.limit_backward {
            break 'lab0;
        }
        env.previous_char();
        // ], line 173
        env.bra = env.cursor;
        // delete, line 173
        if !env.slice_del() {
            return false;
        }
        break 'lab0;
    }
    env.cursor = env.limit - v_3;
    // do, line 174
    let v_5 = env.limit - env.cursor;
    'lab1: loop {
        // (, line 174
        // [, line 174
        env.ket = env.cursor;
        if !env.in_grouping_b(G_AEI, 97, 228) {
            break 'lab1;
        }
        // ], line 174
        env.bra = env.cursor;
        if !env.out_grouping_b(G_V1, 97, 246) {
            break 'lab1;
        }
        // delete, line 174
        if !env.slice_del() {
            return false;
        }
        break 'lab1;
    }
    env.cursor = env.limit - v_5;
    // do, line 175
    let v_6 = env.limit - env.cursor;
    'lab2: loop {
        // (, line 175
        // [, line 175
        env.ket = env.cursor;
        // literal, line 175
        if !env.eq_s_b(&"j") {
            break 'lab2;
        }
        // ], line 175
        env.bra = env.cursor;
        // or, line 175
        'lab3: loop {
            let v_7 = env.limit - env.cursor;
            'lab4: loop {
                // literal, line 175
                if !env.eq_s_b(&"o") {
                    break 'lab4;
                }
                break 'lab3;
            }
            env.cursor = env.limit - v_7;
            // literal, line 175
            if !env.eq_s_b(&"u") {
                break 'lab2;
            }
            break 'lab3;
        }
        // delete, line 175
        if !env.slice_del() {
            return false;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_6;
    // do, line 176
    let v_8 = env.limit - env.cursor;
    'lab5: loop {
        // (, line 176
        // [, line 176
        env.ket = env.cursor;
        // literal, line 176
        if !env.eq_s_b(&"o") {
            break 'lab5;
        }
        // ], line 176
        env.bra = env.cursor;
        // literal, line 176
        if !env.eq_s_b(&"j") {
            break 'lab5;
        }
        // delete, line 176
        if !env.slice_del() {
            return false;
        }
        break 'lab5;
    }
    env.cursor = env.limit - v_8;
    env.limit_backward = v_2;
    // goto, line 178
    'golab6: loop {
        let v_9 = env.limit - env.cursor;
        'lab7: loop {
            if !env.out_grouping_b(G_V1, 97, 246) {
                break 'lab7;
            }
            env.cursor = env.limit - v_9;
            break 'golab6;
        }
        env.cursor = env.limit - v_9;
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
    }
    // [, line 178
    env.ket = env.cursor;
    // next, line 178
    if env.cursor <= env.limit_backward {
        return false;
    }
    env.previous_char();
    // ], line 178
    env.bra = env.cursor;
    // -> x, line 178
    context.S_x = env.slice_to();
    if context.S_x.is_empty() {
        return false;
    }
    // name x, line 178
    if !env.eq_s_b(&context.S_x) {
        return false;
    }
    // delete, line 178
    if !env.slice_del() {
        return false;
    }
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        b_ending_removed: false,
        S_x: String::new(),
        i_p2: 0,
        i_p1: 0,
    };
    // (, line 182
    // do, line 184
    let v_1 = env.cursor;
    'lab0: loop {
        // call mark_regions, line 184
        if !r_mark_regions(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = v_1;
    // unset ending_removed, line 185
    context.b_ending_removed = false;
    // backwards, line 186
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 186
    // do, line 187
    let v_2 = env.limit - env.cursor;
    'lab1: loop {
        // call particle_etc, line 187
        if !r_particle_etc(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = env.limit - v_2;
    // do, line 188
    let v_3 = env.limit - env.cursor;
    'lab2: loop {
        // call possessive, line 188
        if !r_possessive(env, context) {
            break 'lab2;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_3;
    // do, line 189
    let v_4 = env.limit - env.cursor;
    'lab3: loop {
        // call case_ending, line 189
        if !r_case_ending(env, context) {
            break 'lab3;
        }
        break 'lab3;
    }
    env.cursor = env.limit - v_4;
    // do, line 190
    let v_5 = env.limit - env.cursor;
    'lab4: loop {
        // call other_endings, line 190
        if !r_other_endings(env, context) {
            break 'lab4;
        }
        break 'lab4;
    }
    env.cursor = env.limit - v_5;
    // or, line 191
    'lab5: loop {
        let v_6 = env.limit - env.cursor;
        'lab6: loop {
            // (, line 191
            // Boolean test ending_removed, line 191
            if !context.b_ending_removed {
                break 'lab6;
            }
            // do, line 191
            let v_7 = env.limit - env.cursor;
            'lab7: loop {
                // call i_plural, line 191
                if !r_i_plural(env, context) {
                    break 'lab7;
                }
                break 'lab7;
            }
            env.cursor = env.limit - v_7;
            break 'lab5;
        }
        env.cursor = env.limit - v_6;
        // do, line 191
        let v_8 = env.limit - env.cursor;
        'lab8: loop {
            // call t_plural, line 191
            if !r_t_plural(env, context) {
                break 'lab8;
            }
            break 'lab8;
        }
        env.cursor = env.limit - v_8;
        break 'lab5;
    }
    // do, line 192
    let v_9 = env.limit - env.cursor;
    'lab9: loop {
        // call tidy, line 192
        if !r_tidy(env, context) {
            break 'lab9;
        }
        break 'lab9;
    }
    env.cursor = env.limit - v_9;
    env.cursor = env.limit_backward;
    return true;
}
