//! 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("m", -1, -1, None),
    Among("n", -1, -1, None),
    Among("miz", -1, -1, None),
    Among("niz", -1, -1, None),
    Among("muz", -1, -1, None),
    Among("nuz", -1, -1, None),
    Among("m\u{0131}z", -1, -1, None),
    Among("n\u{0131}z", -1, -1, None),
    Among("m\u{00FC}z", -1, -1, None),
    Among("n\u{00FC}z", -1, -1, None),
];

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

static A_2: &'static [Among<Context>; 4] = &[
    Among("ni", -1, -1, None),
    Among("nu", -1, -1, None),
    Among("n\u{0131}", -1, -1, None),
    Among("n\u{00FC}", -1, -1, None),
];

static A_3: &'static [Among<Context>; 4] = &[
    Among("in", -1, -1, None),
    Among("un", -1, -1, None),
    Among("\u{0131}n", -1, -1, None),
    Among("\u{00FC}n", -1, -1, None),
];

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

static A_5: &'static [Among<Context>; 2] = &[
    Among("na", -1, -1, None),
    Among("ne", -1, -1, None),
];

static A_6: &'static [Among<Context>; 4] = &[
    Among("da", -1, -1, None),
    Among("ta", -1, -1, None),
    Among("de", -1, -1, None),
    Among("te", -1, -1, None),
];

static A_7: &'static [Among<Context>; 2] = &[
    Among("nda", -1, -1, None),
    Among("nde", -1, -1, None),
];

static A_8: &'static [Among<Context>; 4] = &[
    Among("dan", -1, -1, None),
    Among("tan", -1, -1, None),
    Among("den", -1, -1, None),
    Among("ten", -1, -1, None),
];

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

static A_10: &'static [Among<Context>; 2] = &[
    Among("la", -1, -1, None),
    Among("le", -1, -1, None),
];

static A_11: &'static [Among<Context>; 2] = &[
    Among("ca", -1, -1, None),
    Among("ce", -1, -1, None),
];

static A_12: &'static [Among<Context>; 4] = &[
    Among("im", -1, -1, None),
    Among("um", -1, -1, None),
    Among("\u{0131}m", -1, -1, None),
    Among("\u{00FC}m", -1, -1, None),
];

static A_13: &'static [Among<Context>; 4] = &[
    Among("sin", -1, -1, None),
    Among("sun", -1, -1, None),
    Among("s\u{0131}n", -1, -1, None),
    Among("s\u{00FC}n", -1, -1, None),
];

static A_14: &'static [Among<Context>; 4] = &[
    Among("iz", -1, -1, None),
    Among("uz", -1, -1, None),
    Among("\u{0131}z", -1, -1, None),
    Among("\u{00FC}z", -1, -1, None),
];

static A_15: &'static [Among<Context>; 4] = &[
    Among("siniz", -1, -1, None),
    Among("sunuz", -1, -1, None),
    Among("s\u{0131}n\u{0131}z", -1, -1, None),
    Among("s\u{00FC}n\u{00FC}z", -1, -1, None),
];

static A_16: &'static [Among<Context>; 2] = &[
    Among("lar", -1, -1, None),
    Among("ler", -1, -1, None),
];

static A_17: &'static [Among<Context>; 4] = &[
    Among("niz", -1, -1, None),
    Among("nuz", -1, -1, None),
    Among("n\u{0131}z", -1, -1, None),
    Among("n\u{00FC}z", -1, -1, None),
];

static A_18: &'static [Among<Context>; 8] = &[
    Among("dir", -1, -1, None),
    Among("tir", -1, -1, None),
    Among("dur", -1, -1, None),
    Among("tur", -1, -1, None),
    Among("d\u{0131}r", -1, -1, None),
    Among("t\u{0131}r", -1, -1, None),
    Among("d\u{00FC}r", -1, -1, None),
    Among("t\u{00FC}r", -1, -1, None),
];

static A_19: &'static [Among<Context>; 2] = &[
    Among("cas\u{0131}na", -1, -1, None),
    Among("cesine", -1, -1, None),
];

static A_20: &'static [Among<Context>; 32] = &[
    Among("di", -1, -1, None),
    Among("ti", -1, -1, None),
    Among("dik", -1, -1, None),
    Among("tik", -1, -1, None),
    Among("duk", -1, -1, None),
    Among("tuk", -1, -1, None),
    Among("d\u{0131}k", -1, -1, None),
    Among("t\u{0131}k", -1, -1, None),
    Among("d\u{00FC}k", -1, -1, None),
    Among("t\u{00FC}k", -1, -1, None),
    Among("dim", -1, -1, None),
    Among("tim", -1, -1, None),
    Among("dum", -1, -1, None),
    Among("tum", -1, -1, None),
    Among("d\u{0131}m", -1, -1, None),
    Among("t\u{0131}m", -1, -1, None),
    Among("d\u{00FC}m", -1, -1, None),
    Among("t\u{00FC}m", -1, -1, None),
    Among("din", -1, -1, None),
    Among("tin", -1, -1, None),
    Among("dun", -1, -1, None),
    Among("tun", -1, -1, None),
    Among("d\u{0131}n", -1, -1, None),
    Among("t\u{0131}n", -1, -1, None),
    Among("d\u{00FC}n", -1, -1, None),
    Among("t\u{00FC}n", -1, -1, None),
    Among("du", -1, -1, None),
    Among("tu", -1, -1, None),
    Among("d\u{0131}", -1, -1, None),
    Among("t\u{0131}", -1, -1, None),
    Among("d\u{00FC}", -1, -1, None),
    Among("t\u{00FC}", -1, -1, None),
];

static A_21: &'static [Among<Context>; 8] = &[
    Among("sa", -1, -1, None),
    Among("se", -1, -1, None),
    Among("sak", -1, -1, None),
    Among("sek", -1, -1, None),
    Among("sam", -1, -1, None),
    Among("sem", -1, -1, None),
    Among("san", -1, -1, None),
    Among("sen", -1, -1, None),
];

static A_22: &'static [Among<Context>; 4] = &[
    Among("mi\u{015F}", -1, -1, None),
    Among("mu\u{015F}", -1, -1, None),
    Among("m\u{0131}\u{015F}", -1, -1, None),
    Among("m\u{00FC}\u{015F}", -1, -1, None),
];

static A_23: &'static [Among<Context>; 4] = &[
    Among("b", -1, 1, None),
    Among("c", -1, 2, None),
    Among("d", -1, 3, None),
    Among("\u{011F}", -1, 4, None),
];

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

static G_U: &'static [u8; 26] = &[1, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1];

static G_vowel1: &'static [u8; 27] = &[1, 64, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];

static G_vowel2: &'static [u8; 19] = &[17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130];

static G_vowel3: &'static [u8; 27] = &[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];

static G_vowel4: &'static [u8; 1] = &[17];

static G_vowel5: &'static [u8; 1] = &[65];

static G_vowel6: &'static [u8; 1] = &[65];

#[derive(Clone)]
struct Context {
    b_continue_stemming_noun_suffixes: bool,
    i_strlen: usize,
}

fn r_check_vowel_harmony(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 111
    // test, line 112
    let v_1 = env.limit - env.cursor;
    // (, line 113
    // (, line 114
    // goto, line 114
    'golab0: loop {
        let v_2 = env.limit - env.cursor;
        'lab1: loop {
            if !env.in_grouping_b(G_vowel, 97, 305) {
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            break 'golab0;
        }
        env.cursor = env.limit - v_2;
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
    }
    // (, line 115
    // or, line 116
    'lab2: loop {
        let v_3 = env.limit - env.cursor;
        'lab3: loop {
            // (, line 116
            // literal, line 116
            if !env.eq_s_b(&"a") {
                break 'lab3;
            }
            // goto, line 116
            'golab4: loop {
                let v_4 = env.limit - env.cursor;
                'lab5: loop {
                    if !env.in_grouping_b(G_vowel1, 97, 305) {
                        break 'lab5;
                    }
                    env.cursor = env.limit - v_4;
                    break 'golab4;
                }
                env.cursor = env.limit - v_4;
                if env.cursor <= env.limit_backward {
                    break 'lab3;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab6: loop {
            // (, line 117
            // literal, line 117
            if !env.eq_s_b(&"e") {
                break 'lab6;
            }
            // goto, line 117
            'golab7: loop {
                let v_5 = env.limit - env.cursor;
                'lab8: loop {
                    if !env.in_grouping_b(G_vowel2, 101, 252) {
                        break 'lab8;
                    }
                    env.cursor = env.limit - v_5;
                    break 'golab7;
                }
                env.cursor = env.limit - v_5;
                if env.cursor <= env.limit_backward {
                    break 'lab6;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab9: loop {
            // (, line 118
            // literal, line 118
            if !env.eq_s_b(&"\u{0131}") {
                break 'lab9;
            }
            // goto, line 118
            'golab10: loop {
                let v_6 = env.limit - env.cursor;
                'lab11: loop {
                    if !env.in_grouping_b(G_vowel3, 97, 305) {
                        break 'lab11;
                    }
                    env.cursor = env.limit - v_6;
                    break 'golab10;
                }
                env.cursor = env.limit - v_6;
                if env.cursor <= env.limit_backward {
                    break 'lab9;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab12: loop {
            // (, line 119
            // literal, line 119
            if !env.eq_s_b(&"i") {
                break 'lab12;
            }
            // goto, line 119
            'golab13: loop {
                let v_7 = env.limit - env.cursor;
                'lab14: loop {
                    if !env.in_grouping_b(G_vowel4, 101, 105) {
                        break 'lab14;
                    }
                    env.cursor = env.limit - v_7;
                    break 'golab13;
                }
                env.cursor = env.limit - v_7;
                if env.cursor <= env.limit_backward {
                    break 'lab12;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab15: loop {
            // (, line 120
            // literal, line 120
            if !env.eq_s_b(&"o") {
                break 'lab15;
            }
            // goto, line 120
            'golab16: loop {
                let v_8 = env.limit - env.cursor;
                'lab17: loop {
                    if !env.in_grouping_b(G_vowel5, 111, 117) {
                        break 'lab17;
                    }
                    env.cursor = env.limit - v_8;
                    break 'golab16;
                }
                env.cursor = env.limit - v_8;
                if env.cursor <= env.limit_backward {
                    break 'lab15;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab18: loop {
            // (, line 121
            // literal, line 121
            if !env.eq_s_b(&"\u{00F6}") {
                break 'lab18;
            }
            // goto, line 121
            'golab19: loop {
                let v_9 = env.limit - env.cursor;
                'lab20: loop {
                    if !env.in_grouping_b(G_vowel6, 246, 252) {
                        break 'lab20;
                    }
                    env.cursor = env.limit - v_9;
                    break 'golab19;
                }
                env.cursor = env.limit - v_9;
                if env.cursor <= env.limit_backward {
                    break 'lab18;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab21: loop {
            // (, line 122
            // literal, line 122
            if !env.eq_s_b(&"u") {
                break 'lab21;
            }
            // goto, line 122
            'golab22: loop {
                let v_10 = env.limit - env.cursor;
                'lab23: loop {
                    if !env.in_grouping_b(G_vowel5, 111, 117) {
                        break 'lab23;
                    }
                    env.cursor = env.limit - v_10;
                    break 'golab22;
                }
                env.cursor = env.limit - v_10;
                if env.cursor <= env.limit_backward {
                    break 'lab21;
                }
                env.previous_char();
            }
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        // (, line 123
        // literal, line 123
        if !env.eq_s_b(&"\u{00FC}") {
            return false;
        }
        // goto, line 123
        'golab24: loop {
            let v_11 = env.limit - env.cursor;
            'lab25: loop {
                if !env.in_grouping_b(G_vowel6, 246, 252) {
                    break 'lab25;
                }
                env.cursor = env.limit - v_11;
                break 'golab24;
            }
            env.cursor = env.limit - v_11;
            if env.cursor <= env.limit_backward {
                return false;
            }
            env.previous_char();
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_1;
    return true;
}

fn r_mark_suffix_with_optional_n_consonant(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 132
    // or, line 134
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 133
            // literal, line 133
            if !env.eq_s_b(&"n") {
                break 'lab1;
            }
            // (, line 133
            // test, line 133
            let v_2 = env.limit - env.cursor;
            if !env.in_grouping_b(G_vowel, 97, 305) {
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 135
        // (, line 135
        // not, line 135
        let v_3 = env.limit - env.cursor;
        'lab2: loop {
            // (, line 135
            // test, line 135
            let v_4 = env.limit - env.cursor;
            // literal, line 135
            if !env.eq_s_b(&"n") {
                break 'lab2;
            }
            env.cursor = env.limit - v_4;
            return false;
        }
        env.cursor = env.limit - v_3;
        // test, line 135
        let v_5 = env.limit - env.cursor;
        // (, line 135
        // next, line 135
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
        if !env.in_grouping_b(G_vowel, 97, 305) {
            return false;
        }
        env.cursor = env.limit - v_5;
        break 'lab0;
    }
    return true;
}

fn r_mark_suffix_with_optional_s_consonant(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 143
    // or, line 145
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 144
            // literal, line 144
            if !env.eq_s_b(&"s") {
                break 'lab1;
            }
            // (, line 144
            // test, line 144
            let v_2 = env.limit - env.cursor;
            if !env.in_grouping_b(G_vowel, 97, 305) {
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 146
        // (, line 146
        // not, line 146
        let v_3 = env.limit - env.cursor;
        'lab2: loop {
            // (, line 146
            // test, line 146
            let v_4 = env.limit - env.cursor;
            // literal, line 146
            if !env.eq_s_b(&"s") {
                break 'lab2;
            }
            env.cursor = env.limit - v_4;
            return false;
        }
        env.cursor = env.limit - v_3;
        // test, line 146
        let v_5 = env.limit - env.cursor;
        // (, line 146
        // next, line 146
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
        if !env.in_grouping_b(G_vowel, 97, 305) {
            return false;
        }
        env.cursor = env.limit - v_5;
        break 'lab0;
    }
    return true;
}

fn r_mark_suffix_with_optional_y_consonant(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 153
    // or, line 155
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 154
            // literal, line 154
            if !env.eq_s_b(&"y") {
                break 'lab1;
            }
            // (, line 154
            // test, line 154
            let v_2 = env.limit - env.cursor;
            if !env.in_grouping_b(G_vowel, 97, 305) {
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 156
        // (, line 156
        // not, line 156
        let v_3 = env.limit - env.cursor;
        'lab2: loop {
            // (, line 156
            // test, line 156
            let v_4 = env.limit - env.cursor;
            // literal, line 156
            if !env.eq_s_b(&"y") {
                break 'lab2;
            }
            env.cursor = env.limit - v_4;
            return false;
        }
        env.cursor = env.limit - v_3;
        // test, line 156
        let v_5 = env.limit - env.cursor;
        // (, line 156
        // next, line 156
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
        if !env.in_grouping_b(G_vowel, 97, 305) {
            return false;
        }
        env.cursor = env.limit - v_5;
        break 'lab0;
    }
    return true;
}

fn r_mark_suffix_with_optional_U_vowel(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 159
    // or, line 161
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 160
            if !env.in_grouping_b(G_U, 105, 305) {
                break 'lab1;
            }
            // (, line 160
            // test, line 160
            let v_2 = env.limit - env.cursor;
            if !env.out_grouping_b(G_vowel, 97, 305) {
                break 'lab1;
            }
            env.cursor = env.limit - v_2;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 162
        // (, line 162
        // not, line 162
        let v_3 = env.limit - env.cursor;
        'lab2: loop {
            // (, line 162
            // test, line 162
            let v_4 = env.limit - env.cursor;
            if !env.in_grouping_b(G_U, 105, 305) {
                break 'lab2;
            }
            env.cursor = env.limit - v_4;
            return false;
        }
        env.cursor = env.limit - v_3;
        // test, line 162
        let v_5 = env.limit - env.cursor;
        // (, line 162
        // next, line 162
        if env.cursor <= env.limit_backward {
            return false;
        }
        env.previous_char();
        if !env.out_grouping_b(G_vowel, 97, 305) {
            return false;
        }
        env.cursor = env.limit - v_5;
        break 'lab0;
    }
    return true;
}

fn r_mark_possessives(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 166
    // among, line 167
    if env.find_among_b(A_0, context) == 0 {
        return false;
    }
    // (, line 169
    // call mark_suffix_with_optional_U_vowel, line 169
    if !r_mark_suffix_with_optional_U_vowel(env, context) {
        return false;
    }
    return true;
}

fn r_mark_sU(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 172
    // call check_vowel_harmony, line 173
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    if !env.in_grouping_b(G_U, 105, 305) {
        return false;
    }
    // (, line 175
    // call mark_suffix_with_optional_s_consonant, line 175
    if !r_mark_suffix_with_optional_s_consonant(env, context) {
        return false;
    }
    return true;
}

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

fn r_mark_yU(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 182
    // call check_vowel_harmony, line 183
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    if !env.in_grouping_b(G_U, 105, 305) {
        return false;
    }
    // (, line 185
    // call mark_suffix_with_optional_y_consonant, line 185
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_nU(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 188
    // call check_vowel_harmony, line 189
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 190
    if env.find_among_b(A_2, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_nUn(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 193
    // call check_vowel_harmony, line 194
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 195
    if env.find_among_b(A_3, context) == 0 {
        return false;
    }
    // (, line 196
    // call mark_suffix_with_optional_n_consonant, line 196
    if !r_mark_suffix_with_optional_n_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_yA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 199
    // call check_vowel_harmony, line 200
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 201
    if env.find_among_b(A_4, context) == 0 {
        return false;
    }
    // (, line 202
    // call mark_suffix_with_optional_y_consonant, line 202
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_nA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 205
    // call check_vowel_harmony, line 206
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 207
    if env.find_among_b(A_5, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_DA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 210
    // call check_vowel_harmony, line 211
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 212
    if env.find_among_b(A_6, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_ndA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 215
    // call check_vowel_harmony, line 216
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 217
    if env.find_among_b(A_7, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_DAn(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 220
    // call check_vowel_harmony, line 221
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 222
    if env.find_among_b(A_8, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_ndAn(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 225
    // call check_vowel_harmony, line 226
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 227
    if env.find_among_b(A_9, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_ylA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 230
    // call check_vowel_harmony, line 231
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 232
    if env.find_among_b(A_10, context) == 0 {
        return false;
    }
    // (, line 233
    // call mark_suffix_with_optional_y_consonant, line 233
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_ki(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 236
    // literal, line 237
    if !env.eq_s_b(&"ki") {
        return false;
    }
    return true;
}

fn r_mark_ncA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 240
    // call check_vowel_harmony, line 241
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 242
    if env.find_among_b(A_11, context) == 0 {
        return false;
    }
    // (, line 243
    // call mark_suffix_with_optional_n_consonant, line 243
    if !r_mark_suffix_with_optional_n_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_yUm(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 246
    // call check_vowel_harmony, line 247
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 248
    if env.find_among_b(A_12, context) == 0 {
        return false;
    }
    // (, line 249
    // call mark_suffix_with_optional_y_consonant, line 249
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_sUn(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 252
    // call check_vowel_harmony, line 253
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 254
    if env.find_among_b(A_13, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_yUz(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 257
    // call check_vowel_harmony, line 258
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 259
    if env.find_among_b(A_14, context) == 0 {
        return false;
    }
    // (, line 260
    // call mark_suffix_with_optional_y_consonant, line 260
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

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

fn r_mark_lAr(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 267
    // call check_vowel_harmony, line 268
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 269
    if env.find_among_b(A_16, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_nUz(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 272
    // call check_vowel_harmony, line 273
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 274
    if env.find_among_b(A_17, context) == 0 {
        return false;
    }
    return true;
}

fn r_mark_DUr(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 277
    // call check_vowel_harmony, line 278
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 279
    if env.find_among_b(A_18, context) == 0 {
        return false;
    }
    return true;
}

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

fn r_mark_yDU(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 286
    // call check_vowel_harmony, line 287
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 288
    if env.find_among_b(A_20, context) == 0 {
        return false;
    }
    // (, line 292
    // call mark_suffix_with_optional_y_consonant, line 292
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_ysA(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 296
    // among, line 297
    if env.find_among_b(A_21, context) == 0 {
        return false;
    }
    // (, line 298
    // call mark_suffix_with_optional_y_consonant, line 298
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_ymUs_(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 301
    // call check_vowel_harmony, line 302
    if !r_check_vowel_harmony(env, context) {
        return false;
    }
    // among, line 303
    if env.find_among_b(A_22, context) == 0 {
        return false;
    }
    // (, line 304
    // call mark_suffix_with_optional_y_consonant, line 304
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_mark_yken(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 307
    // literal, line 308
    if !env.eq_s_b(&"ken") {
        return false;
    }
    // (, line 308
    // call mark_suffix_with_optional_y_consonant, line 308
    if !r_mark_suffix_with_optional_y_consonant(env, context) {
        return false;
    }
    return true;
}

fn r_stem_nominal_verb_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 311
    // [, line 312
    env.ket = env.cursor;
    // set continue_stemming_noun_suffixes, line 313
    context.b_continue_stemming_noun_suffixes = true;
    // or, line 315
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 314
            // or, line 314
            'lab2: loop {
                let v_2 = env.limit - env.cursor;
                'lab3: loop {
                    // call mark_ymUs_, line 314
                    if !r_mark_ymUs_(env, context) {
                        break 'lab3;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_2;
                'lab4: loop {
                    // call mark_yDU, line 314
                    if !r_mark_yDU(env, context) {
                        break 'lab4;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_2;
                'lab5: loop {
                    // call mark_ysA, line 314
                    if !r_mark_ysA(env, context) {
                        break 'lab5;
                    }
                    break 'lab2;
                }
                env.cursor = env.limit - v_2;
                // call mark_yken, line 314
                if !r_mark_yken(env, context) {
                    break 'lab1;
                }
                break 'lab2;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab6: loop {
            // (, line 316
            // call mark_cAsInA, line 316
            if !r_mark_cAsInA(env, context) {
                break 'lab6;
            }
            // (, line 316
            // or, line 316
            'lab7: loop {
                let v_3 = env.limit - env.cursor;
                'lab8: loop {
                    // call mark_sUnUz, line 316
                    if !r_mark_sUnUz(env, context) {
                        break 'lab8;
                    }
                    break 'lab7;
                }
                env.cursor = env.limit - v_3;
                'lab9: loop {
                    // call mark_lAr, line 316
                    if !r_mark_lAr(env, context) {
                        break 'lab9;
                    }
                    break 'lab7;
                }
                env.cursor = env.limit - v_3;
                'lab10: loop {
                    // call mark_yUm, line 316
                    if !r_mark_yUm(env, context) {
                        break 'lab10;
                    }
                    break 'lab7;
                }
                env.cursor = env.limit - v_3;
                'lab11: loop {
                    // call mark_sUn, line 316
                    if !r_mark_sUn(env, context) {
                        break 'lab11;
                    }
                    break 'lab7;
                }
                env.cursor = env.limit - v_3;
                'lab12: loop {
                    // call mark_yUz, line 316
                    if !r_mark_yUz(env, context) {
                        break 'lab12;
                    }
                    break 'lab7;
                }
                env.cursor = env.limit - v_3;
                break 'lab7;
            }
            // call mark_ymUs_, line 316
            if !r_mark_ymUs_(env, context) {
                break 'lab6;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab13: loop {
            // (, line 318
            // call mark_lAr, line 319
            if !r_mark_lAr(env, context) {
                break 'lab13;
            }
            // ], line 319
            env.bra = env.cursor;
            // delete, line 319
            if !env.slice_del() {
                return false;
            }
            // try, line 319
            let v_4 = env.limit - env.cursor;
            'lab14: loop {
                // (, line 319
                // [, line 319
                env.ket = env.cursor;
                // (, line 319
                // or, line 319
                'lab15: loop {
                    let v_5 = env.limit - env.cursor;
                    'lab16: loop {
                        // call mark_DUr, line 319
                        if !r_mark_DUr(env, context) {
                            break 'lab16;
                        }
                        break 'lab15;
                    }
                    env.cursor = env.limit - v_5;
                    'lab17: loop {
                        // call mark_yDU, line 319
                        if !r_mark_yDU(env, context) {
                            break 'lab17;
                        }
                        break 'lab15;
                    }
                    env.cursor = env.limit - v_5;
                    'lab18: loop {
                        // call mark_ysA, line 319
                        if !r_mark_ysA(env, context) {
                            break 'lab18;
                        }
                        break 'lab15;
                    }
                    env.cursor = env.limit - v_5;
                    // call mark_ymUs_, line 319
                    if !r_mark_ymUs_(env, context) {
                        env.cursor = env.limit - v_4;
                        break 'lab14;
                    }
                    break 'lab15;
                }
                break 'lab14;
            }
            // unset continue_stemming_noun_suffixes, line 320
            context.b_continue_stemming_noun_suffixes = false;
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab19: loop {
            // (, line 323
            // call mark_nUz, line 323
            if !r_mark_nUz(env, context) {
                break 'lab19;
            }
            // (, line 323
            // or, line 323
            'lab20: loop {
                let v_6 = env.limit - env.cursor;
                'lab21: loop {
                    // call mark_yDU, line 323
                    if !r_mark_yDU(env, context) {
                        break 'lab21;
                    }
                    break 'lab20;
                }
                env.cursor = env.limit - v_6;
                // call mark_ysA, line 323
                if !r_mark_ysA(env, context) {
                    break 'lab19;
                }
                break 'lab20;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab22: loop {
            // (, line 325
            // (, line 325
            // or, line 325
            'lab23: loop {
                let v_7 = env.limit - env.cursor;
                'lab24: loop {
                    // call mark_sUnUz, line 325
                    if !r_mark_sUnUz(env, context) {
                        break 'lab24;
                    }
                    break 'lab23;
                }
                env.cursor = env.limit - v_7;
                'lab25: loop {
                    // call mark_yUz, line 325
                    if !r_mark_yUz(env, context) {
                        break 'lab25;
                    }
                    break 'lab23;
                }
                env.cursor = env.limit - v_7;
                'lab26: loop {
                    // call mark_sUn, line 325
                    if !r_mark_sUn(env, context) {
                        break 'lab26;
                    }
                    break 'lab23;
                }
                env.cursor = env.limit - v_7;
                // call mark_yUm, line 325
                if !r_mark_yUm(env, context) {
                    break 'lab22;
                }
                break 'lab23;
            }
            // ], line 325
            env.bra = env.cursor;
            // delete, line 325
            if !env.slice_del() {
                return false;
            }
            // try, line 325
            let v_8 = env.limit - env.cursor;
            'lab27: loop {
                // (, line 325
                // [, line 325
                env.ket = env.cursor;
                // call mark_ymUs_, line 325
                if !r_mark_ymUs_(env, context) {
                    env.cursor = env.limit - v_8;
                    break 'lab27;
                }
                break 'lab27;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 327
        // call mark_DUr, line 327
        if !r_mark_DUr(env, context) {
            return false;
        }
        // ], line 327
        env.bra = env.cursor;
        // delete, line 327
        if !env.slice_del() {
            return false;
        }
        // try, line 327
        let v_9 = env.limit - env.cursor;
        'lab28: loop {
            // (, line 327
            // [, line 327
            env.ket = env.cursor;
            // (, line 327
            // or, line 327
            'lab29: loop {
                let v_10 = env.limit - env.cursor;
                'lab30: loop {
                    // call mark_sUnUz, line 327
                    if !r_mark_sUnUz(env, context) {
                        break 'lab30;
                    }
                    break 'lab29;
                }
                env.cursor = env.limit - v_10;
                'lab31: loop {
                    // call mark_lAr, line 327
                    if !r_mark_lAr(env, context) {
                        break 'lab31;
                    }
                    break 'lab29;
                }
                env.cursor = env.limit - v_10;
                'lab32: loop {
                    // call mark_yUm, line 327
                    if !r_mark_yUm(env, context) {
                        break 'lab32;
                    }
                    break 'lab29;
                }
                env.cursor = env.limit - v_10;
                'lab33: loop {
                    // call mark_sUn, line 327
                    if !r_mark_sUn(env, context) {
                        break 'lab33;
                    }
                    break 'lab29;
                }
                env.cursor = env.limit - v_10;
                'lab34: loop {
                    // call mark_yUz, line 327
                    if !r_mark_yUz(env, context) {
                        break 'lab34;
                    }
                    break 'lab29;
                }
                env.cursor = env.limit - v_10;
                break 'lab29;
            }
            // call mark_ymUs_, line 327
            if !r_mark_ymUs_(env, context) {
                env.cursor = env.limit - v_9;
                break 'lab28;
            }
            break 'lab28;
        }
        break 'lab0;
    }
    // ], line 328
    env.bra = env.cursor;
    // delete, line 328
    if !env.slice_del() {
        return false;
    }
    return true;
}

fn r_stem_suffix_chain_before_ki(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 332
    // [, line 333
    env.ket = env.cursor;
    // call mark_ki, line 334
    if !r_mark_ki(env, context) {
        return false;
    }
    // (, line 335
    // or, line 342
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 336
            // call mark_DA, line 336
            if !r_mark_DA(env, context) {
                break 'lab1;
            }
            // ], line 336
            env.bra = env.cursor;
            // delete, line 336
            if !env.slice_del() {
                return false;
            }
            // try, line 336
            let v_2 = env.limit - env.cursor;
            'lab2: loop {
                // (, line 336
                // [, line 336
                env.ket = env.cursor;
                // or, line 338
                'lab3: loop {
                    let v_3 = env.limit - env.cursor;
                    'lab4: loop {
                        // (, line 337
                        // call mark_lAr, line 337
                        if !r_mark_lAr(env, context) {
                            break 'lab4;
                        }
                        // ], line 337
                        env.bra = env.cursor;
                        // delete, line 337
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 337
                        let v_4 = env.limit - env.cursor;
                        'lab5: loop {
                            // (, line 337
                            // call stem_suffix_chain_before_ki, line 337
                            if !r_stem_suffix_chain_before_ki(env, context) {
                                env.cursor = env.limit - v_4;
                                break 'lab5;
                            }
                            break 'lab5;
                        }
                        break 'lab3;
                    }
                    env.cursor = env.limit - v_3;
                    // (, line 339
                    // call mark_possessives, line 339
                    if !r_mark_possessives(env, context) {
                        env.cursor = env.limit - v_2;
                        break 'lab2;
                    }
                    // ], line 339
                    env.bra = env.cursor;
                    // delete, line 339
                    if !env.slice_del() {
                        return false;
                    }
                    // try, line 339
                    let v_5 = env.limit - env.cursor;
                    'lab6: loop {
                        // (, line 339
                        // [, line 339
                        env.ket = env.cursor;
                        // call mark_lAr, line 339
                        if !r_mark_lAr(env, context) {
                            env.cursor = env.limit - v_5;
                            break 'lab6;
                        }
                        // ], line 339
                        env.bra = env.cursor;
                        // delete, line 339
                        if !env.slice_del() {
                            return false;
                        }
                        // call stem_suffix_chain_before_ki, line 339
                        if !r_stem_suffix_chain_before_ki(env, context) {
                            env.cursor = env.limit - v_5;
                            break 'lab6;
                        }
                        break 'lab6;
                    }
                    break 'lab3;
                }
                break 'lab2;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab7: loop {
            // (, line 343
            // call mark_nUn, line 343
            if !r_mark_nUn(env, context) {
                break 'lab7;
            }
            // ], line 343
            env.bra = env.cursor;
            // delete, line 343
            if !env.slice_del() {
                return false;
            }
            // try, line 343
            let v_6 = env.limit - env.cursor;
            'lab8: loop {
                // (, line 343
                // [, line 343
                env.ket = env.cursor;
                // or, line 345
                'lab9: loop {
                    let v_7 = env.limit - env.cursor;
                    'lab10: loop {
                        // (, line 344
                        // call mark_lArI, line 344
                        if !r_mark_lArI(env, context) {
                            break 'lab10;
                        }
                        // ], line 344
                        env.bra = env.cursor;
                        // delete, line 344
                        if !env.slice_del() {
                            return false;
                        }
                        break 'lab9;
                    }
                    env.cursor = env.limit - v_7;
                    'lab11: loop {
                        // (, line 346
                        // [, line 346
                        env.ket = env.cursor;
                        // or, line 346
                        'lab12: loop {
                            let v_8 = env.limit - env.cursor;
                            'lab13: loop {
                                // call mark_possessives, line 346
                                if !r_mark_possessives(env, context) {
                                    break 'lab13;
                                }
                                break 'lab12;
                            }
                            env.cursor = env.limit - v_8;
                            // call mark_sU, line 346
                            if !r_mark_sU(env, context) {
                                break 'lab11;
                            }
                            break 'lab12;
                        }
                        // ], line 346
                        env.bra = env.cursor;
                        // delete, line 346
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 346
                        let v_9 = env.limit - env.cursor;
                        'lab14: loop {
                            // (, line 346
                            // [, line 346
                            env.ket = env.cursor;
                            // call mark_lAr, line 346
                            if !r_mark_lAr(env, context) {
                                env.cursor = env.limit - v_9;
                                break 'lab14;
                            }
                            // ], line 346
                            env.bra = env.cursor;
                            // delete, line 346
                            if !env.slice_del() {
                                return false;
                            }
                            // call stem_suffix_chain_before_ki, line 346
                            if !r_stem_suffix_chain_before_ki(env, context) {
                                env.cursor = env.limit - v_9;
                                break 'lab14;
                            }
                            break 'lab14;
                        }
                        break 'lab9;
                    }
                    env.cursor = env.limit - v_7;
                    // (, line 348
                    // call stem_suffix_chain_before_ki, line 348
                    if !r_stem_suffix_chain_before_ki(env, context) {
                        env.cursor = env.limit - v_6;
                        break 'lab8;
                    }
                    break 'lab9;
                }
                break 'lab8;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 351
        // call mark_ndA, line 351
        if !r_mark_ndA(env, context) {
            return false;
        }
        // (, line 351
        // or, line 353
        'lab15: loop {
            let v_10 = env.limit - env.cursor;
            'lab16: loop {
                // (, line 352
                // call mark_lArI, line 352
                if !r_mark_lArI(env, context) {
                    break 'lab16;
                }
                // ], line 352
                env.bra = env.cursor;
                // delete, line 352
                if !env.slice_del() {
                    return false;
                }
                break 'lab15;
            }
            env.cursor = env.limit - v_10;
            'lab17: loop {
                // (, line 354
                // (, line 354
                // call mark_sU, line 354
                if !r_mark_sU(env, context) {
                    break 'lab17;
                }
                // ], line 354
                env.bra = env.cursor;
                // delete, line 354
                if !env.slice_del() {
                    return false;
                }
                // try, line 354
                let v_11 = env.limit - env.cursor;
                'lab18: loop {
                    // (, line 354
                    // [, line 354
                    env.ket = env.cursor;
                    // call mark_lAr, line 354
                    if !r_mark_lAr(env, context) {
                        env.cursor = env.limit - v_11;
                        break 'lab18;
                    }
                    // ], line 354
                    env.bra = env.cursor;
                    // delete, line 354
                    if !env.slice_del() {
                        return false;
                    }
                    // call stem_suffix_chain_before_ki, line 354
                    if !r_stem_suffix_chain_before_ki(env, context) {
                        env.cursor = env.limit - v_11;
                        break 'lab18;
                    }
                    break 'lab18;
                }
                break 'lab15;
            }
            env.cursor = env.limit - v_10;
            // (, line 356
            // call stem_suffix_chain_before_ki, line 356
            if !r_stem_suffix_chain_before_ki(env, context) {
                return false;
            }
            break 'lab15;
        }
        break 'lab0;
    }
    return true;
}

fn r_stem_noun_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 361
    // or, line 363
    'lab0: loop {
        let v_1 = env.limit - env.cursor;
        'lab1: loop {
            // (, line 362
            // [, line 362
            env.ket = env.cursor;
            // call mark_lAr, line 362
            if !r_mark_lAr(env, context) {
                break 'lab1;
            }
            // ], line 362
            env.bra = env.cursor;
            // delete, line 362
            if !env.slice_del() {
                return false;
            }
            // try, line 362
            let v_2 = env.limit - env.cursor;
            'lab2: loop {
                // (, line 362
                // call stem_suffix_chain_before_ki, line 362
                if !r_stem_suffix_chain_before_ki(env, context) {
                    env.cursor = env.limit - v_2;
                    break 'lab2;
                }
                break 'lab2;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab3: loop {
            // (, line 364
            // [, line 364
            env.ket = env.cursor;
            // call mark_ncA, line 364
            if !r_mark_ncA(env, context) {
                break 'lab3;
            }
            // ], line 364
            env.bra = env.cursor;
            // delete, line 364
            if !env.slice_del() {
                return false;
            }
            // try, line 365
            let v_3 = env.limit - env.cursor;
            'lab4: loop {
                // (, line 365
                // or, line 367
                'lab5: loop {
                    let v_4 = env.limit - env.cursor;
                    'lab6: loop {
                        // (, line 366
                        // [, line 366
                        env.ket = env.cursor;
                        // call mark_lArI, line 366
                        if !r_mark_lArI(env, context) {
                            break 'lab6;
                        }
                        // ], line 366
                        env.bra = env.cursor;
                        // delete, line 366
                        if !env.slice_del() {
                            return false;
                        }
                        break 'lab5;
                    }
                    env.cursor = env.limit - v_4;
                    'lab7: loop {
                        // (, line 368
                        // [, line 368
                        env.ket = env.cursor;
                        // or, line 368
                        'lab8: loop {
                            let v_5 = env.limit - env.cursor;
                            'lab9: loop {
                                // call mark_possessives, line 368
                                if !r_mark_possessives(env, context) {
                                    break 'lab9;
                                }
                                break 'lab8;
                            }
                            env.cursor = env.limit - v_5;
                            // call mark_sU, line 368
                            if !r_mark_sU(env, context) {
                                break 'lab7;
                            }
                            break 'lab8;
                        }
                        // ], line 368
                        env.bra = env.cursor;
                        // delete, line 368
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 368
                        let v_6 = env.limit - env.cursor;
                        'lab10: loop {
                            // (, line 368
                            // [, line 368
                            env.ket = env.cursor;
                            // call mark_lAr, line 368
                            if !r_mark_lAr(env, context) {
                                env.cursor = env.limit - v_6;
                                break 'lab10;
                            }
                            // ], line 368
                            env.bra = env.cursor;
                            // delete, line 368
                            if !env.slice_del() {
                                return false;
                            }
                            // call stem_suffix_chain_before_ki, line 368
                            if !r_stem_suffix_chain_before_ki(env, context) {
                                env.cursor = env.limit - v_6;
                                break 'lab10;
                            }
                            break 'lab10;
                        }
                        break 'lab5;
                    }
                    env.cursor = env.limit - v_4;
                    // (, line 370
                    // [, line 370
                    env.ket = env.cursor;
                    // call mark_lAr, line 370
                    if !r_mark_lAr(env, context) {
                        env.cursor = env.limit - v_3;
                        break 'lab4;
                    }
                    // ], line 370
                    env.bra = env.cursor;
                    // delete, line 370
                    if !env.slice_del() {
                        return false;
                    }
                    // call stem_suffix_chain_before_ki, line 370
                    if !r_stem_suffix_chain_before_ki(env, context) {
                        env.cursor = env.limit - v_3;
                        break 'lab4;
                    }
                    break 'lab5;
                }
                break 'lab4;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab11: loop {
            // (, line 374
            // [, line 374
            env.ket = env.cursor;
            // (, line 374
            // or, line 374
            'lab12: loop {
                let v_7 = env.limit - env.cursor;
                'lab13: loop {
                    // call mark_ndA, line 374
                    if !r_mark_ndA(env, context) {
                        break 'lab13;
                    }
                    break 'lab12;
                }
                env.cursor = env.limit - v_7;
                // call mark_nA, line 374
                if !r_mark_nA(env, context) {
                    break 'lab11;
                }
                break 'lab12;
            }
            // (, line 375
            // or, line 377
            'lab14: loop {
                let v_8 = env.limit - env.cursor;
                'lab15: loop {
                    // (, line 376
                    // call mark_lArI, line 376
                    if !r_mark_lArI(env, context) {
                        break 'lab15;
                    }
                    // ], line 376
                    env.bra = env.cursor;
                    // delete, line 376
                    if !env.slice_del() {
                        return false;
                    }
                    break 'lab14;
                }
                env.cursor = env.limit - v_8;
                'lab16: loop {
                    // (, line 378
                    // call mark_sU, line 378
                    if !r_mark_sU(env, context) {
                        break 'lab16;
                    }
                    // ], line 378
                    env.bra = env.cursor;
                    // delete, line 378
                    if !env.slice_del() {
                        return false;
                    }
                    // try, line 378
                    let v_9 = env.limit - env.cursor;
                    'lab17: loop {
                        // (, line 378
                        // [, line 378
                        env.ket = env.cursor;
                        // call mark_lAr, line 378
                        if !r_mark_lAr(env, context) {
                            env.cursor = env.limit - v_9;
                            break 'lab17;
                        }
                        // ], line 378
                        env.bra = env.cursor;
                        // delete, line 378
                        if !env.slice_del() {
                            return false;
                        }
                        // call stem_suffix_chain_before_ki, line 378
                        if !r_stem_suffix_chain_before_ki(env, context) {
                            env.cursor = env.limit - v_9;
                            break 'lab17;
                        }
                        break 'lab17;
                    }
                    break 'lab14;
                }
                env.cursor = env.limit - v_8;
                // (, line 380
                // call stem_suffix_chain_before_ki, line 380
                if !r_stem_suffix_chain_before_ki(env, context) {
                    break 'lab11;
                }
                break 'lab14;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab18: loop {
            // (, line 384
            // [, line 384
            env.ket = env.cursor;
            // (, line 384
            // or, line 384
            'lab19: loop {
                let v_10 = env.limit - env.cursor;
                'lab20: loop {
                    // call mark_ndAn, line 384
                    if !r_mark_ndAn(env, context) {
                        break 'lab20;
                    }
                    break 'lab19;
                }
                env.cursor = env.limit - v_10;
                // call mark_nU, line 384
                if !r_mark_nU(env, context) {
                    break 'lab18;
                }
                break 'lab19;
            }
            // (, line 384
            // or, line 384
            'lab21: loop {
                let v_11 = env.limit - env.cursor;
                'lab22: loop {
                    // (, line 384
                    // call mark_sU, line 384
                    if !r_mark_sU(env, context) {
                        break 'lab22;
                    }
                    // ], line 384
                    env.bra = env.cursor;
                    // delete, line 384
                    if !env.slice_del() {
                        return false;
                    }
                    // try, line 384
                    let v_12 = env.limit - env.cursor;
                    'lab23: loop {
                        // (, line 384
                        // [, line 384
                        env.ket = env.cursor;
                        // call mark_lAr, line 384
                        if !r_mark_lAr(env, context) {
                            env.cursor = env.limit - v_12;
                            break 'lab23;
                        }
                        // ], line 384
                        env.bra = env.cursor;
                        // delete, line 384
                        if !env.slice_del() {
                            return false;
                        }
                        // call stem_suffix_chain_before_ki, line 384
                        if !r_stem_suffix_chain_before_ki(env, context) {
                            env.cursor = env.limit - v_12;
                            break 'lab23;
                        }
                        break 'lab23;
                    }
                    break 'lab21;
                }
                env.cursor = env.limit - v_11;
                // (, line 384
                // call mark_lArI, line 384
                if !r_mark_lArI(env, context) {
                    break 'lab18;
                }
                break 'lab21;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab24: loop {
            // (, line 386
            // [, line 386
            env.ket = env.cursor;
            // call mark_DAn, line 386
            if !r_mark_DAn(env, context) {
                break 'lab24;
            }
            // ], line 386
            env.bra = env.cursor;
            // delete, line 386
            if !env.slice_del() {
                return false;
            }
            // try, line 386
            let v_13 = env.limit - env.cursor;
            'lab25: loop {
                // (, line 386
                // [, line 386
                env.ket = env.cursor;
                // (, line 387
                // or, line 389
                'lab26: loop {
                    let v_14 = env.limit - env.cursor;
                    'lab27: loop {
                        // (, line 388
                        // call mark_possessives, line 388
                        if !r_mark_possessives(env, context) {
                            break 'lab27;
                        }
                        // ], line 388
                        env.bra = env.cursor;
                        // delete, line 388
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 388
                        let v_15 = env.limit - env.cursor;
                        'lab28: loop {
                            // (, line 388
                            // [, line 388
                            env.ket = env.cursor;
                            // call mark_lAr, line 388
                            if !r_mark_lAr(env, context) {
                                env.cursor = env.limit - v_15;
                                break 'lab28;
                            }
                            // ], line 388
                            env.bra = env.cursor;
                            // delete, line 388
                            if !env.slice_del() {
                                return false;
                            }
                            // call stem_suffix_chain_before_ki, line 388
                            if !r_stem_suffix_chain_before_ki(env, context) {
                                env.cursor = env.limit - v_15;
                                break 'lab28;
                            }
                            break 'lab28;
                        }
                        break 'lab26;
                    }
                    env.cursor = env.limit - v_14;
                    'lab29: loop {
                        // (, line 390
                        // call mark_lAr, line 390
                        if !r_mark_lAr(env, context) {
                            break 'lab29;
                        }
                        // ], line 390
                        env.bra = env.cursor;
                        // delete, line 390
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 390
                        let v_16 = env.limit - env.cursor;
                        'lab30: loop {
                            // (, line 390
                            // call stem_suffix_chain_before_ki, line 390
                            if !r_stem_suffix_chain_before_ki(env, context) {
                                env.cursor = env.limit - v_16;
                                break 'lab30;
                            }
                            break 'lab30;
                        }
                        break 'lab26;
                    }
                    env.cursor = env.limit - v_14;
                    // (, line 392
                    // call stem_suffix_chain_before_ki, line 392
                    if !r_stem_suffix_chain_before_ki(env, context) {
                        env.cursor = env.limit - v_13;
                        break 'lab25;
                    }
                    break 'lab26;
                }
                break 'lab25;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab31: loop {
            // (, line 396
            // [, line 396
            env.ket = env.cursor;
            // or, line 396
            'lab32: loop {
                let v_17 = env.limit - env.cursor;
                'lab33: loop {
                    // call mark_nUn, line 396
                    if !r_mark_nUn(env, context) {
                        break 'lab33;
                    }
                    break 'lab32;
                }
                env.cursor = env.limit - v_17;
                // call mark_ylA, line 396
                if !r_mark_ylA(env, context) {
                    break 'lab31;
                }
                break 'lab32;
            }
            // ], line 396
            env.bra = env.cursor;
            // delete, line 396
            if !env.slice_del() {
                return false;
            }
            // try, line 397
            let v_18 = env.limit - env.cursor;
            'lab34: loop {
                // (, line 397
                // or, line 399
                'lab35: loop {
                    let v_19 = env.limit - env.cursor;
                    'lab36: loop {
                        // (, line 398
                        // [, line 398
                        env.ket = env.cursor;
                        // call mark_lAr, line 398
                        if !r_mark_lAr(env, context) {
                            break 'lab36;
                        }
                        // ], line 398
                        env.bra = env.cursor;
                        // delete, line 398
                        if !env.slice_del() {
                            return false;
                        }
                        // call stem_suffix_chain_before_ki, line 398
                        if !r_stem_suffix_chain_before_ki(env, context) {
                            break 'lab36;
                        }
                        break 'lab35;
                    }
                    env.cursor = env.limit - v_19;
                    'lab37: loop {
                        // (, line 400
                        // [, line 400
                        env.ket = env.cursor;
                        // or, line 400
                        'lab38: loop {
                            let v_20 = env.limit - env.cursor;
                            'lab39: loop {
                                // call mark_possessives, line 400
                                if !r_mark_possessives(env, context) {
                                    break 'lab39;
                                }
                                break 'lab38;
                            }
                            env.cursor = env.limit - v_20;
                            // call mark_sU, line 400
                            if !r_mark_sU(env, context) {
                                break 'lab37;
                            }
                            break 'lab38;
                        }
                        // ], line 400
                        env.bra = env.cursor;
                        // delete, line 400
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 400
                        let v_21 = env.limit - env.cursor;
                        'lab40: loop {
                            // (, line 400
                            // [, line 400
                            env.ket = env.cursor;
                            // call mark_lAr, line 400
                            if !r_mark_lAr(env, context) {
                                env.cursor = env.limit - v_21;
                                break 'lab40;
                            }
                            // ], line 400
                            env.bra = env.cursor;
                            // delete, line 400
                            if !env.slice_del() {
                                return false;
                            }
                            // call stem_suffix_chain_before_ki, line 400
                            if !r_stem_suffix_chain_before_ki(env, context) {
                                env.cursor = env.limit - v_21;
                                break 'lab40;
                            }
                            break 'lab40;
                        }
                        break 'lab35;
                    }
                    env.cursor = env.limit - v_19;
                    // call stem_suffix_chain_before_ki, line 402
                    if !r_stem_suffix_chain_before_ki(env, context) {
                        env.cursor = env.limit - v_18;
                        break 'lab34;
                    }
                    break 'lab35;
                }
                break 'lab34;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab41: loop {
            // (, line 406
            // [, line 406
            env.ket = env.cursor;
            // call mark_lArI, line 406
            if !r_mark_lArI(env, context) {
                break 'lab41;
            }
            // ], line 406
            env.bra = env.cursor;
            // delete, line 406
            if !env.slice_del() {
                return false;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab42: loop {
            // (, line 408
            // call stem_suffix_chain_before_ki, line 408
            if !r_stem_suffix_chain_before_ki(env, context) {
                break 'lab42;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        'lab43: loop {
            // (, line 410
            // [, line 410
            env.ket = env.cursor;
            // or, line 410
            'lab44: loop {
                let v_22 = env.limit - env.cursor;
                'lab45: loop {
                    // call mark_DA, line 410
                    if !r_mark_DA(env, context) {
                        break 'lab45;
                    }
                    break 'lab44;
                }
                env.cursor = env.limit - v_22;
                'lab46: loop {
                    // call mark_yU, line 410
                    if !r_mark_yU(env, context) {
                        break 'lab46;
                    }
                    break 'lab44;
                }
                env.cursor = env.limit - v_22;
                // call mark_yA, line 410
                if !r_mark_yA(env, context) {
                    break 'lab43;
                }
                break 'lab44;
            }
            // ], line 410
            env.bra = env.cursor;
            // delete, line 410
            if !env.slice_del() {
                return false;
            }
            // try, line 410
            let v_23 = env.limit - env.cursor;
            'lab47: loop {
                // (, line 410
                // [, line 410
                env.ket = env.cursor;
                // (, line 410
                // or, line 410
                'lab48: loop {
                    let v_24 = env.limit - env.cursor;
                    'lab49: loop {
                        // (, line 410
                        // call mark_possessives, line 410
                        if !r_mark_possessives(env, context) {
                            break 'lab49;
                        }
                        // ], line 410
                        env.bra = env.cursor;
                        // delete, line 410
                        if !env.slice_del() {
                            return false;
                        }
                        // try, line 410
                        let v_25 = env.limit - env.cursor;
                        'lab50: loop {
                            // (, line 410
                            // [, line 410
                            env.ket = env.cursor;
                            // call mark_lAr, line 410
                            if !r_mark_lAr(env, context) {
                                env.cursor = env.limit - v_25;
                                break 'lab50;
                            }
                            break 'lab50;
                        }
                        break 'lab48;
                    }
                    env.cursor = env.limit - v_24;
                    // call mark_lAr, line 410
                    if !r_mark_lAr(env, context) {
                        env.cursor = env.limit - v_23;
                        break 'lab47;
                    }
                    break 'lab48;
                }
                // ], line 410
                env.bra = env.cursor;
                // delete, line 410
                if !env.slice_del() {
                    return false;
                }
                // [, line 410
                env.ket = env.cursor;
                // call stem_suffix_chain_before_ki, line 410
                if !r_stem_suffix_chain_before_ki(env, context) {
                    env.cursor = env.limit - v_23;
                    break 'lab47;
                }
                break 'lab47;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_1;
        // (, line 412
        // [, line 412
        env.ket = env.cursor;
        // or, line 412
        'lab51: loop {
            let v_26 = env.limit - env.cursor;
            'lab52: loop {
                // call mark_possessives, line 412
                if !r_mark_possessives(env, context) {
                    break 'lab52;
                }
                break 'lab51;
            }
            env.cursor = env.limit - v_26;
            // call mark_sU, line 412
            if !r_mark_sU(env, context) {
                return false;
            }
            break 'lab51;
        }
        // ], line 412
        env.bra = env.cursor;
        // delete, line 412
        if !env.slice_del() {
            return false;
        }
        // try, line 412
        let v_27 = env.limit - env.cursor;
        'lab53: loop {
            // (, line 412
            // [, line 412
            env.ket = env.cursor;
            // call mark_lAr, line 412
            if !r_mark_lAr(env, context) {
                env.cursor = env.limit - v_27;
                break 'lab53;
            }
            // ], line 412
            env.bra = env.cursor;
            // delete, line 412
            if !env.slice_del() {
                return false;
            }
            // call stem_suffix_chain_before_ki, line 412
            if !r_stem_suffix_chain_before_ki(env, context) {
                env.cursor = env.limit - v_27;
                break 'lab53;
            }
            break 'lab53;
        }
        break 'lab0;
    }
    return true;
}

fn r_post_process_last_consonants(env: &mut SnowballEnv, context: &mut Context) -> bool {
    let mut among_var;
    // (, line 415
    // [, line 416
    env.ket = env.cursor;
    // substring, line 416
    among_var = env.find_among_b(A_23, context);
    if among_var == 0 {
        return false;
    }
    // ], line 416
    env.bra = env.cursor;
    if among_var == 0 {
        return false;
    } else if among_var == 1 {
        // (, line 417
        // <-, line 417
        if !env.slice_from("p") {
            return false;
        }
    } else if among_var == 2 {
        // (, line 418
        // <-, line 418
        if !env.slice_from("\u{00E7}") {
            return false;
        }
    } else if among_var == 3 {
        // (, line 419
        // <-, line 419
        if !env.slice_from("t") {
            return false;
        }
    } else if among_var == 4 {
        // (, line 420
        // <-, line 420
        if !env.slice_from("k") {
            return false;
        }
    }
    return true;
}

fn r_append_U_to_stems_ending_with_d_or_g(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 430
    // test, line 431
    let v_1 = env.limit - env.cursor;
    // (, line 431
    // or, line 431
    'lab0: loop {
        let v_2 = env.limit - env.cursor;
        'lab1: loop {
            // literal, line 431
            if !env.eq_s_b(&"d") {
                break 'lab1;
            }
            break 'lab0;
        }
        env.cursor = env.limit - v_2;
        // literal, line 431
        if !env.eq_s_b(&"g") {
            return false;
        }
        break 'lab0;
    }
    env.cursor = env.limit - v_1;
    // or, line 433
    'lab2: loop {
        let v_3 = env.limit - env.cursor;
        'lab3: loop {
            // (, line 432
            // test, line 432
            let v_4 = env.limit - env.cursor;
            // (, line 432
            // (, line 432
            // goto, line 432
            'golab4: loop {
                let v_5 = env.limit - env.cursor;
                'lab5: loop {
                    if !env.in_grouping_b(G_vowel, 97, 305) {
                        break 'lab5;
                    }
                    env.cursor = env.limit - v_5;
                    break 'golab4;
                }
                env.cursor = env.limit - v_5;
                if env.cursor <= env.limit_backward {
                    break 'lab3;
                }
                env.previous_char();
            }
            // or, line 432
            'lab6: loop {
                let v_6 = env.limit - env.cursor;
                'lab7: loop {
                    // literal, line 432
                    if !env.eq_s_b(&"a") {
                        break 'lab7;
                    }
                    break 'lab6;
                }
                env.cursor = env.limit - v_6;
                // literal, line 432
                if !env.eq_s_b(&"\u{0131}") {
                    break 'lab3;
                }
                break 'lab6;
            }
            env.cursor = env.limit - v_4;
            // <+, line 432
            let c = env.cursor;
            let (bra, ket) = (env.cursor, env.cursor);
            env.insert(bra, ket, "\u{0131}");
            env.cursor = c;
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab8: loop {
            // (, line 434
            // test, line 434
            let v_7 = env.limit - env.cursor;
            // (, line 434
            // (, line 434
            // goto, line 434
            'golab9: loop {
                let v_8 = env.limit - env.cursor;
                'lab10: loop {
                    if !env.in_grouping_b(G_vowel, 97, 305) {
                        break 'lab10;
                    }
                    env.cursor = env.limit - v_8;
                    break 'golab9;
                }
                env.cursor = env.limit - v_8;
                if env.cursor <= env.limit_backward {
                    break 'lab8;
                }
                env.previous_char();
            }
            // or, line 434
            'lab11: loop {
                let v_9 = env.limit - env.cursor;
                'lab12: loop {
                    // literal, line 434
                    if !env.eq_s_b(&"e") {
                        break 'lab12;
                    }
                    break 'lab11;
                }
                env.cursor = env.limit - v_9;
                // literal, line 434
                if !env.eq_s_b(&"i") {
                    break 'lab8;
                }
                break 'lab11;
            }
            env.cursor = env.limit - v_7;
            // <+, line 434
            let c = env.cursor;
            let (bra, ket) = (env.cursor, env.cursor);
            env.insert(bra, ket, "i");
            env.cursor = c;
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        'lab13: loop {
            // (, line 436
            // test, line 436
            let v_10 = env.limit - env.cursor;
            // (, line 436
            // (, line 436
            // goto, line 436
            'golab14: loop {
                let v_11 = env.limit - env.cursor;
                'lab15: loop {
                    if !env.in_grouping_b(G_vowel, 97, 305) {
                        break 'lab15;
                    }
                    env.cursor = env.limit - v_11;
                    break 'golab14;
                }
                env.cursor = env.limit - v_11;
                if env.cursor <= env.limit_backward {
                    break 'lab13;
                }
                env.previous_char();
            }
            // or, line 436
            'lab16: loop {
                let v_12 = env.limit - env.cursor;
                'lab17: loop {
                    // literal, line 436
                    if !env.eq_s_b(&"o") {
                        break 'lab17;
                    }
                    break 'lab16;
                }
                env.cursor = env.limit - v_12;
                // literal, line 436
                if !env.eq_s_b(&"u") {
                    break 'lab13;
                }
                break 'lab16;
            }
            env.cursor = env.limit - v_10;
            // <+, line 436
            let c = env.cursor;
            let (bra, ket) = (env.cursor, env.cursor);
            env.insert(bra, ket, "u");
            env.cursor = c;
            break 'lab2;
        }
        env.cursor = env.limit - v_3;
        // (, line 438
        // test, line 438
        let v_13 = env.limit - env.cursor;
        // (, line 438
        // (, line 438
        // goto, line 438
        'golab18: loop {
            let v_14 = env.limit - env.cursor;
            'lab19: loop {
                if !env.in_grouping_b(G_vowel, 97, 305) {
                    break 'lab19;
                }
                env.cursor = env.limit - v_14;
                break 'golab18;
            }
            env.cursor = env.limit - v_14;
            if env.cursor <= env.limit_backward {
                return false;
            }
            env.previous_char();
        }
        // or, line 438
        'lab20: loop {
            let v_15 = env.limit - env.cursor;
            'lab21: loop {
                // literal, line 438
                if !env.eq_s_b(&"\u{00F6}") {
                    break 'lab21;
                }
                break 'lab20;
            }
            env.cursor = env.limit - v_15;
            // literal, line 438
            if !env.eq_s_b(&"\u{00FC}") {
                return false;
            }
            break 'lab20;
        }
        env.cursor = env.limit - v_13;
        // <+, line 438
        let c = env.cursor;
        let (bra, ket) = (env.cursor, env.cursor);
        env.insert(bra, ket, "\u{00FC}");
        env.cursor = c;
        break 'lab2;
    }
    return true;
}

fn r_more_than_one_syllable_word(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 445
    // test, line 446
    let v_1 = env.cursor;
    // (, line 446
    // atleast, line 446
    let mut v_2 = 2;
    // atleast, line 446
    'replab0: loop{
        let v_3 = env.cursor;
        'lab1: for _ in 0..1 {
            // (, line 446
            // gopast, line 446
            'golab2: loop {
                'lab3: loop {
                    if !env.in_grouping(G_vowel, 97, 305) {
                        break 'lab3;
                    }
                    break 'golab2;
                }
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            v_2 -= 1;
            continue 'replab0;
        }
        env.cursor = v_3;
        break 'replab0;
    }
    if v_2 > 0 {
        return false;
    }
    env.cursor = v_1;
    return true;
}

fn r_is_reserved_word(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 449
    // or, line 451
    'lab0: loop {
        let v_1 = env.cursor;
        'lab1: loop {
            // test, line 450
            let v_2 = env.cursor;
            // (, line 450
            // gopast, line 450
            'golab2: loop {
                'lab3: loop {
                    // literal, line 450
                    if !env.eq_s(&"ad") {
                        break 'lab3;
                    }
                    break 'golab2;
                }
                if env.cursor >= env.limit {
                    break 'lab1;
                }
                env.next_char();
            }
            // (, line 450
            context.i_strlen = 2;
            // (, line 450
            if !(context.i_strlen == env.limit){
                break 'lab1;
            }
            env.cursor = v_2;
            break 'lab0;
        }
        env.cursor = v_1;
        // test, line 452
        let v_4 = env.cursor;
        // (, line 452
        // gopast, line 452
        'golab4: loop {
            'lab5: loop {
                // literal, line 452
                if !env.eq_s(&"soyad") {
                    break 'lab5;
                }
                break 'golab4;
            }
            if env.cursor >= env.limit {
                return false;
            }
            env.next_char();
        }
        // (, line 452
        context.i_strlen = 5;
        // (, line 452
        if !(context.i_strlen == env.limit){
            return false;
        }
        env.cursor = v_4;
        break 'lab0;
    }
    return true;
}

fn r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool {
    // (, line 455
    // not, line 456
    let v_1 = env.cursor;
    'lab0: loop {
        // (, line 456
        // call is_reserved_word, line 456
        if !r_is_reserved_word(env, context) {
            break 'lab0;
        }
        return false;
    }
    env.cursor = v_1;
    // backwards, line 457
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 457
    // do, line 458
    let v_2 = env.limit - env.cursor;
    'lab1: loop {
        // call append_U_to_stems_ending_with_d_or_g, line 458
        if !r_append_U_to_stems_ending_with_d_or_g(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = env.limit - v_2;
    // do, line 459
    let v_3 = env.limit - env.cursor;
    'lab2: loop {
        // call post_process_last_consonants, line 459
        if !r_post_process_last_consonants(env, context) {
            break 'lab2;
        }
        break 'lab2;
    }
    env.cursor = env.limit - v_3;
    env.cursor = env.limit_backward;
    return true;
}

pub fn stem(env: &mut SnowballEnv) -> bool {
    let mut context = &mut Context {
        b_continue_stemming_noun_suffixes: false,
        i_strlen: 0,
    };
    // (, line 464
    // (, line 465
    // call more_than_one_syllable_word, line 465
    if !r_more_than_one_syllable_word(env, context) {
        return false;
    }
    // (, line 466
    // backwards, line 467
    env.limit_backward = env.cursor;
    env.cursor = env.limit;
    // (, line 467
    // do, line 468
    let v_1 = env.limit - env.cursor;
    'lab0: loop {
        // call stem_nominal_verb_suffixes, line 468
        if !r_stem_nominal_verb_suffixes(env, context) {
            break 'lab0;
        }
        break 'lab0;
    }
    env.cursor = env.limit - v_1;
    // Boolean test continue_stemming_noun_suffixes, line 469
    if !context.b_continue_stemming_noun_suffixes {
        return false;
    }
    // do, line 470
    let v_2 = env.limit - env.cursor;
    'lab1: loop {
        // call stem_noun_suffixes, line 470
        if !r_stem_noun_suffixes(env, context) {
            break 'lab1;
        }
        break 'lab1;
    }
    env.cursor = env.limit - v_2;
    env.cursor = env.limit_backward;
    // call postlude, line 473
    if !r_postlude(env, context) {
        return false;
    }
    return true;
}
