//! This file was generated automatically by the Snowball to Go compiler
//! http://snowballstem.org/

package turkish

import (
	snowballRuntime "github.com/blevesearch/snowballstem"
)

var A_0 = []*snowballRuntime.Among{
	{Str: "m", A: -1, B: -1, F: nil},
	{Str: "n", A: -1, B: -1, F: nil},
	{Str: "miz", A: -1, B: -1, F: nil},
	{Str: "niz", A: -1, B: -1, F: nil},
	{Str: "muz", A: -1, B: -1, F: nil},
	{Str: "nuz", A: -1, B: -1, F: nil},
	{Str: "m\u0131z", A: -1, B: -1, F: nil},
	{Str: "n\u0131z", A: -1, B: -1, F: nil},
	{Str: "m\u00FCz", A: -1, B: -1, F: nil},
	{Str: "n\u00FCz", A: -1, B: -1, F: nil},
}

var A_1 = []*snowballRuntime.Among{
	{Str: "leri", A: -1, B: -1, F: nil},
	{Str: "lar\u0131", A: -1, B: -1, F: nil},
}

var A_2 = []*snowballRuntime.Among{
	{Str: "ni", A: -1, B: -1, F: nil},
	{Str: "nu", A: -1, B: -1, F: nil},
	{Str: "n\u0131", A: -1, B: -1, F: nil},
	{Str: "n\u00FC", A: -1, B: -1, F: nil},
}

var A_3 = []*snowballRuntime.Among{
	{Str: "in", A: -1, B: -1, F: nil},
	{Str: "un", A: -1, B: -1, F: nil},
	{Str: "\u0131n", A: -1, B: -1, F: nil},
	{Str: "\u00FCn", A: -1, B: -1, F: nil},
}

var A_4 = []*snowballRuntime.Among{
	{Str: "a", A: -1, B: -1, F: nil},
	{Str: "e", A: -1, B: -1, F: nil},
}

var A_5 = []*snowballRuntime.Among{
	{Str: "na", A: -1, B: -1, F: nil},
	{Str: "ne", A: -1, B: -1, F: nil},
}

var A_6 = []*snowballRuntime.Among{
	{Str: "da", A: -1, B: -1, F: nil},
	{Str: "ta", A: -1, B: -1, F: nil},
	{Str: "de", A: -1, B: -1, F: nil},
	{Str: "te", A: -1, B: -1, F: nil},
}

var A_7 = []*snowballRuntime.Among{
	{Str: "nda", A: -1, B: -1, F: nil},
	{Str: "nde", A: -1, B: -1, F: nil},
}

var A_8 = []*snowballRuntime.Among{
	{Str: "dan", A: -1, B: -1, F: nil},
	{Str: "tan", A: -1, B: -1, F: nil},
	{Str: "den", A: -1, B: -1, F: nil},
	{Str: "ten", A: -1, B: -1, F: nil},
}

var A_9 = []*snowballRuntime.Among{
	{Str: "ndan", A: -1, B: -1, F: nil},
	{Str: "nden", A: -1, B: -1, F: nil},
}

var A_10 = []*snowballRuntime.Among{
	{Str: "la", A: -1, B: -1, F: nil},
	{Str: "le", A: -1, B: -1, F: nil},
}

var A_11 = []*snowballRuntime.Among{
	{Str: "ca", A: -1, B: -1, F: nil},
	{Str: "ce", A: -1, B: -1, F: nil},
}

var A_12 = []*snowballRuntime.Among{
	{Str: "im", A: -1, B: -1, F: nil},
	{Str: "um", A: -1, B: -1, F: nil},
	{Str: "\u0131m", A: -1, B: -1, F: nil},
	{Str: "\u00FCm", A: -1, B: -1, F: nil},
}

var A_13 = []*snowballRuntime.Among{
	{Str: "sin", A: -1, B: -1, F: nil},
	{Str: "sun", A: -1, B: -1, F: nil},
	{Str: "s\u0131n", A: -1, B: -1, F: nil},
	{Str: "s\u00FCn", A: -1, B: -1, F: nil},
}

var A_14 = []*snowballRuntime.Among{
	{Str: "iz", A: -1, B: -1, F: nil},
	{Str: "uz", A: -1, B: -1, F: nil},
	{Str: "\u0131z", A: -1, B: -1, F: nil},
	{Str: "\u00FCz", A: -1, B: -1, F: nil},
}

var A_15 = []*snowballRuntime.Among{
	{Str: "siniz", A: -1, B: -1, F: nil},
	{Str: "sunuz", A: -1, B: -1, F: nil},
	{Str: "s\u0131n\u0131z", A: -1, B: -1, F: nil},
	{Str: "s\u00FCn\u00FCz", A: -1, B: -1, F: nil},
}

var A_16 = []*snowballRuntime.Among{
	{Str: "lar", A: -1, B: -1, F: nil},
	{Str: "ler", A: -1, B: -1, F: nil},
}

var A_17 = []*snowballRuntime.Among{
	{Str: "niz", A: -1, B: -1, F: nil},
	{Str: "nuz", A: -1, B: -1, F: nil},
	{Str: "n\u0131z", A: -1, B: -1, F: nil},
	{Str: "n\u00FCz", A: -1, B: -1, F: nil},
}

var A_18 = []*snowballRuntime.Among{
	{Str: "dir", A: -1, B: -1, F: nil},
	{Str: "tir", A: -1, B: -1, F: nil},
	{Str: "dur", A: -1, B: -1, F: nil},
	{Str: "tur", A: -1, B: -1, F: nil},
	{Str: "d\u0131r", A: -1, B: -1, F: nil},
	{Str: "t\u0131r", A: -1, B: -1, F: nil},
	{Str: "d\u00FCr", A: -1, B: -1, F: nil},
	{Str: "t\u00FCr", A: -1, B: -1, F: nil},
}

var A_19 = []*snowballRuntime.Among{
	{Str: "cas\u0131na", A: -1, B: -1, F: nil},
	{Str: "cesine", A: -1, B: -1, F: nil},
}

var A_20 = []*snowballRuntime.Among{
	{Str: "di", A: -1, B: -1, F: nil},
	{Str: "ti", A: -1, B: -1, F: nil},
	{Str: "dik", A: -1, B: -1, F: nil},
	{Str: "tik", A: -1, B: -1, F: nil},
	{Str: "duk", A: -1, B: -1, F: nil},
	{Str: "tuk", A: -1, B: -1, F: nil},
	{Str: "d\u0131k", A: -1, B: -1, F: nil},
	{Str: "t\u0131k", A: -1, B: -1, F: nil},
	{Str: "d\u00FCk", A: -1, B: -1, F: nil},
	{Str: "t\u00FCk", A: -1, B: -1, F: nil},
	{Str: "dim", A: -1, B: -1, F: nil},
	{Str: "tim", A: -1, B: -1, F: nil},
	{Str: "dum", A: -1, B: -1, F: nil},
	{Str: "tum", A: -1, B: -1, F: nil},
	{Str: "d\u0131m", A: -1, B: -1, F: nil},
	{Str: "t\u0131m", A: -1, B: -1, F: nil},
	{Str: "d\u00FCm", A: -1, B: -1, F: nil},
	{Str: "t\u00FCm", A: -1, B: -1, F: nil},
	{Str: "din", A: -1, B: -1, F: nil},
	{Str: "tin", A: -1, B: -1, F: nil},
	{Str: "dun", A: -1, B: -1, F: nil},
	{Str: "tun", A: -1, B: -1, F: nil},
	{Str: "d\u0131n", A: -1, B: -1, F: nil},
	{Str: "t\u0131n", A: -1, B: -1, F: nil},
	{Str: "d\u00FCn", A: -1, B: -1, F: nil},
	{Str: "t\u00FCn", A: -1, B: -1, F: nil},
	{Str: "du", A: -1, B: -1, F: nil},
	{Str: "tu", A: -1, B: -1, F: nil},
	{Str: "d\u0131", A: -1, B: -1, F: nil},
	{Str: "t\u0131", A: -1, B: -1, F: nil},
	{Str: "d\u00FC", A: -1, B: -1, F: nil},
	{Str: "t\u00FC", A: -1, B: -1, F: nil},
}

var A_21 = []*snowballRuntime.Among{
	{Str: "sa", A: -1, B: -1, F: nil},
	{Str: "se", A: -1, B: -1, F: nil},
	{Str: "sak", A: -1, B: -1, F: nil},
	{Str: "sek", A: -1, B: -1, F: nil},
	{Str: "sam", A: -1, B: -1, F: nil},
	{Str: "sem", A: -1, B: -1, F: nil},
	{Str: "san", A: -1, B: -1, F: nil},
	{Str: "sen", A: -1, B: -1, F: nil},
}

var A_22 = []*snowballRuntime.Among{
	{Str: "mi\u015F", A: -1, B: -1, F: nil},
	{Str: "mu\u015F", A: -1, B: -1, F: nil},
	{Str: "m\u0131\u015F", A: -1, B: -1, F: nil},
	{Str: "m\u00FC\u015F", A: -1, B: -1, F: nil},
}

var A_23 = []*snowballRuntime.Among{
	{Str: "b", A: -1, B: 1, F: nil},
	{Str: "c", A: -1, B: 2, F: nil},
	{Str: "d", A: -1, B: 3, F: nil},
	{Str: "\u011F", A: -1, B: 4, F: nil},
}

var G_vowel = []byte{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}

var G_U = []byte{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}

var G_vowel1 = []byte{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}

var G_vowel2 = []byte{17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130}

var G_vowel3 = []byte{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}

var G_vowel4 = []byte{17}

var G_vowel5 = []byte{65}

var G_vowel6 = []byte{65}

type Context struct {
	b_continue_stemming_noun_suffixes bool
	i_strlen                          int
}

func r_check_vowel_harmony(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 111
	// test, line 112
	var v_1 = env.Limit - env.Cursor
	// (, line 113
	// (, line 114
	// goto, line 114
golab0:
	for {
		var v_2 = env.Limit - env.Cursor
	lab1:
		for {
			if !env.InGroupingB(G_vowel, 97, 305) {
				break lab1
			}
			env.Cursor = env.Limit - v_2
			break golab0
		}
		env.Cursor = env.Limit - v_2
		if env.Cursor <= env.LimitBackward {
			return false
		}
		env.PrevChar()
	}
	// (, line 115
	// or, line 116
lab2:
	for {
		var v_3 = env.Limit - env.Cursor
	lab3:
		for {
			// (, line 116
			// literal, line 116
			if !env.EqSB("a") {
				break lab3
			}
			// goto, line 116
		golab4:
			for {
				var v_4 = env.Limit - env.Cursor
			lab5:
				for {
					if !env.InGroupingB(G_vowel1, 97, 305) {
						break lab5
					}
					env.Cursor = env.Limit - v_4
					break golab4
				}
				env.Cursor = env.Limit - v_4
				if env.Cursor <= env.LimitBackward {
					break lab3
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab6:
		for {
			// (, line 117
			// literal, line 117
			if !env.EqSB("e") {
				break lab6
			}
			// goto, line 117
		golab7:
			for {
				var v_5 = env.Limit - env.Cursor
			lab8:
				for {
					if !env.InGroupingB(G_vowel2, 101, 252) {
						break lab8
					}
					env.Cursor = env.Limit - v_5
					break golab7
				}
				env.Cursor = env.Limit - v_5
				if env.Cursor <= env.LimitBackward {
					break lab6
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab9:
		for {
			// (, line 118
			// literal, line 118
			if !env.EqSB("\u0131") {
				break lab9
			}
			// goto, line 118
		golab10:
			for {
				var v_6 = env.Limit - env.Cursor
			lab11:
				for {
					if !env.InGroupingB(G_vowel3, 97, 305) {
						break lab11
					}
					env.Cursor = env.Limit - v_6
					break golab10
				}
				env.Cursor = env.Limit - v_6
				if env.Cursor <= env.LimitBackward {
					break lab9
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab12:
		for {
			// (, line 119
			// literal, line 119
			if !env.EqSB("i") {
				break lab12
			}
			// goto, line 119
		golab13:
			for {
				var v_7 = env.Limit - env.Cursor
			lab14:
				for {
					if !env.InGroupingB(G_vowel4, 101, 105) {
						break lab14
					}
					env.Cursor = env.Limit - v_7
					break golab13
				}
				env.Cursor = env.Limit - v_7
				if env.Cursor <= env.LimitBackward {
					break lab12
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab15:
		for {
			// (, line 120
			// literal, line 120
			if !env.EqSB("o") {
				break lab15
			}
			// goto, line 120
		golab16:
			for {
				var v_8 = env.Limit - env.Cursor
			lab17:
				for {
					if !env.InGroupingB(G_vowel5, 111, 117) {
						break lab17
					}
					env.Cursor = env.Limit - v_8
					break golab16
				}
				env.Cursor = env.Limit - v_8
				if env.Cursor <= env.LimitBackward {
					break lab15
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab18:
		for {
			// (, line 121
			// literal, line 121
			if !env.EqSB("\u00F6") {
				break lab18
			}
			// goto, line 121
		golab19:
			for {
				var v_9 = env.Limit - env.Cursor
			lab20:
				for {
					if !env.InGroupingB(G_vowel6, 246, 252) {
						break lab20
					}
					env.Cursor = env.Limit - v_9
					break golab19
				}
				env.Cursor = env.Limit - v_9
				if env.Cursor <= env.LimitBackward {
					break lab18
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab21:
		for {
			// (, line 122
			// literal, line 122
			if !env.EqSB("u") {
				break lab21
			}
			// goto, line 122
		golab22:
			for {
				var v_10 = env.Limit - env.Cursor
			lab23:
				for {
					if !env.InGroupingB(G_vowel5, 111, 117) {
						break lab23
					}
					env.Cursor = env.Limit - v_10
					break golab22
				}
				env.Cursor = env.Limit - v_10
				if env.Cursor <= env.LimitBackward {
					break lab21
				}
				env.PrevChar()
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
		// (, line 123
		// literal, line 123
		if !env.EqSB("\u00FC") {
			return false
		}
		// goto, line 123
	golab24:
		for {
			var v_11 = env.Limit - env.Cursor
		lab25:
			for {
				if !env.InGroupingB(G_vowel6, 246, 252) {
					break lab25
				}
				env.Cursor = env.Limit - v_11
				break golab24
			}
			env.Cursor = env.Limit - v_11
			if env.Cursor <= env.LimitBackward {
				return false
			}
			env.PrevChar()
		}
		break lab2
	}
	env.Cursor = env.Limit - v_1
	return true
}

func r_mark_suffix_with_optional_n_consonant(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 132
	// or, line 134
lab0:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, line 133
			// literal, line 133
			if !env.EqSB("n") {
				break lab1
			}
			// (, line 133
			// test, line 133
			var v_2 = env.Limit - env.Cursor
			if !env.InGroupingB(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
		var v_3 = env.Limit - env.Cursor
	lab2:
		for {
			// (, line 135
			// test, line 135
			var v_4 = env.Limit - env.Cursor
			// literal, line 135
			if !env.EqSB("n") {
				break lab2
			}
			env.Cursor = env.Limit - v_4
			return false
		}
		env.Cursor = env.Limit - v_3
		// test, line 135
		var v_5 = env.Limit - env.Cursor
		// (, line 135
		// next, line 135
		if env.Cursor <= env.LimitBackward {
			return false
		}
		env.PrevChar()
		if !env.InGroupingB(G_vowel, 97, 305) {
			return false
		}
		env.Cursor = env.Limit - v_5
		break lab0
	}
	return true
}

func r_mark_suffix_with_optional_s_consonant(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 143
	// or, line 145
lab0:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, line 144
			// literal, line 144
			if !env.EqSB("s") {
				break lab1
			}
			// (, line 144
			// test, line 144
			var v_2 = env.Limit - env.Cursor
			if !env.InGroupingB(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
		var v_3 = env.Limit - env.Cursor
	lab2:
		for {
			// (, line 146
			// test, line 146
			var v_4 = env.Limit - env.Cursor
			// literal, line 146
			if !env.EqSB("s") {
				break lab2
			}
			env.Cursor = env.Limit - v_4
			return false
		}
		env.Cursor = env.Limit - v_3
		// test, line 146
		var v_5 = env.Limit - env.Cursor
		// (, line 146
		// next, line 146
		if env.Cursor <= env.LimitBackward {
			return false
		}
		env.PrevChar()
		if !env.InGroupingB(G_vowel, 97, 305) {
			return false
		}
		env.Cursor = env.Limit - v_5
		break lab0
	}
	return true
}

func r_mark_suffix_with_optional_y_consonant(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 153
	// or, line 155
lab0:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, line 154
			// literal, line 154
			if !env.EqSB("y") {
				break lab1
			}
			// (, line 154
			// test, line 154
			var v_2 = env.Limit - env.Cursor
			if !env.InGroupingB(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
		var v_3 = env.Limit - env.Cursor
	lab2:
		for {
			// (, line 156
			// test, line 156
			var v_4 = env.Limit - env.Cursor
			// literal, line 156
			if !env.EqSB("y") {
				break lab2
			}
			env.Cursor = env.Limit - v_4
			return false
		}
		env.Cursor = env.Limit - v_3
		// test, line 156
		var v_5 = env.Limit - env.Cursor
		// (, line 156
		// next, line 156
		if env.Cursor <= env.LimitBackward {
			return false
		}
		env.PrevChar()
		if !env.InGroupingB(G_vowel, 97, 305) {
			return false
		}
		env.Cursor = env.Limit - v_5
		break lab0
	}
	return true
}

func r_mark_suffix_with_optional_U_vowel(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 159
	// or, line 161
lab0:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, line 160
			if !env.InGroupingB(G_U, 105, 305) {
				break lab1
			}
			// (, line 160
			// test, line 160
			var v_2 = env.Limit - env.Cursor
			if !env.OutGroupingB(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
		var v_3 = env.Limit - env.Cursor
	lab2:
		for {
			// (, line 162
			// test, line 162
			var v_4 = env.Limit - env.Cursor
			if !env.InGroupingB(G_U, 105, 305) {
				break lab2
			}
			env.Cursor = env.Limit - v_4
			return false
		}
		env.Cursor = env.Limit - v_3
		// test, line 162
		var v_5 = env.Limit - env.Cursor
		// (, line 162
		// next, line 162
		if env.Cursor <= env.LimitBackward {
			return false
		}
		env.PrevChar()
		if !env.OutGroupingB(G_vowel, 97, 305) {
			return false
		}
		env.Cursor = env.Limit - v_5
		break lab0
	}
	return true
}

func r_mark_possessives(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 166
	// among, line 167
	if env.FindAmongB(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
}

func r_mark_sU(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 172
	// call check_vowel_harmony, line 173
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	if !env.InGroupingB(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
}

func r_mark_lArI(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 178
	// among, line 179
	if env.FindAmongB(A_1, context) == 0 {
		return false
	}
	return true
}

func r_mark_yU(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 182
	// call check_vowel_harmony, line 183
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	if !env.InGroupingB(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
}

func r_mark_nU(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 188
	// call check_vowel_harmony, line 189
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 190
	if env.FindAmongB(A_2, context) == 0 {
		return false
	}
	return true
}

func r_mark_nUn(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 193
	// call check_vowel_harmony, line 194
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 195
	if env.FindAmongB(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
}

func r_mark_yA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 199
	// call check_vowel_harmony, line 200
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 201
	if env.FindAmongB(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
}

func r_mark_nA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 205
	// call check_vowel_harmony, line 206
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 207
	if env.FindAmongB(A_5, context) == 0 {
		return false
	}
	return true
}

func r_mark_DA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 210
	// call check_vowel_harmony, line 211
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 212
	if env.FindAmongB(A_6, context) == 0 {
		return false
	}
	return true
}

func r_mark_ndA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 215
	// call check_vowel_harmony, line 216
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 217
	if env.FindAmongB(A_7, context) == 0 {
		return false
	}
	return true
}

func r_mark_DAn(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 220
	// call check_vowel_harmony, line 221
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 222
	if env.FindAmongB(A_8, context) == 0 {
		return false
	}
	return true
}

func r_mark_ndAn(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 225
	// call check_vowel_harmony, line 226
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 227
	if env.FindAmongB(A_9, context) == 0 {
		return false
	}
	return true
}

func r_mark_ylA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 230
	// call check_vowel_harmony, line 231
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 232
	if env.FindAmongB(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
}

func r_mark_ki(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 236
	// literal, line 237
	if !env.EqSB("ki") {
		return false
	}
	return true
}

func r_mark_ncA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 240
	// call check_vowel_harmony, line 241
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 242
	if env.FindAmongB(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
}

func r_mark_yUm(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 246
	// call check_vowel_harmony, line 247
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 248
	if env.FindAmongB(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
}

func r_mark_sUn(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 252
	// call check_vowel_harmony, line 253
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 254
	if env.FindAmongB(A_13, context) == 0 {
		return false
	}
	return true
}

func r_mark_yUz(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 257
	// call check_vowel_harmony, line 258
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 259
	if env.FindAmongB(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
}

func r_mark_sUnUz(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 263
	// among, line 264
	if env.FindAmongB(A_15, context) == 0 {
		return false
	}
	return true
}

func r_mark_lAr(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 267
	// call check_vowel_harmony, line 268
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 269
	if env.FindAmongB(A_16, context) == 0 {
		return false
	}
	return true
}

func r_mark_nUz(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 272
	// call check_vowel_harmony, line 273
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 274
	if env.FindAmongB(A_17, context) == 0 {
		return false
	}
	return true
}

func r_mark_DUr(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 277
	// call check_vowel_harmony, line 278
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 279
	if env.FindAmongB(A_18, context) == 0 {
		return false
	}
	return true
}

func r_mark_cAsInA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 282
	// among, line 283
	if env.FindAmongB(A_19, context) == 0 {
		return false
	}
	return true
}

func r_mark_yDU(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 286
	// call check_vowel_harmony, line 287
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 288
	if env.FindAmongB(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
}

func r_mark_ysA(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 296
	// among, line 297
	if env.FindAmongB(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
}

func r_mark_ymUs_(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 301
	// call check_vowel_harmony, line 302
	if !r_check_vowel_harmony(env, context) {
		return false
	}
	// among, line 303
	if env.FindAmongB(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
}

func r_mark_yken(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 307
	// literal, line 308
	if !env.EqSB("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
}

func r_stem_nominal_verb_suffixes(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, 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:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, line 314
			// or, line 314
		lab2:
			for {
				var v_2 = env.Limit - env.Cursor
			lab3:
				for {
					// call mark_ymUs_, line 314
					if !r_mark_ymUs_(env, context) {
						break lab3
					}
					break lab2
				}
				env.Cursor = env.Limit - v_2
			lab4:
				for {
					// call mark_yDU, line 314
					if !r_mark_yDU(env, context) {
						break lab4
					}
					break lab2
				}
				env.Cursor = env.Limit - v_2
			lab5:
				for {
					// 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:
		for {
			// (, line 316
			// call mark_cAsInA, line 316
			if !r_mark_cAsInA(env, context) {
				break lab6
			}
			// (, line 316
			// or, line 316
		lab7:
			for {
				var v_3 = env.Limit - env.Cursor
			lab8:
				for {
					// call mark_sUnUz, line 316
					if !r_mark_sUnUz(env, context) {
						break lab8
					}
					break lab7
				}
				env.Cursor = env.Limit - v_3
			lab9:
				for {
					// call mark_lAr, line 316
					if !r_mark_lAr(env, context) {
						break lab9
					}
					break lab7
				}
				env.Cursor = env.Limit - v_3
			lab10:
				for {
					// call mark_yUm, line 316
					if !r_mark_yUm(env, context) {
						break lab10
					}
					break lab7
				}
				env.Cursor = env.Limit - v_3
			lab11:
				for {
					// call mark_sUn, line 316
					if !r_mark_sUn(env, context) {
						break lab11
					}
					break lab7
				}
				env.Cursor = env.Limit - v_3
			lab12:
				for {
					// 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:
		for {
			// (, 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.SliceDel() {
				return false
			}
			// try, line 319
			var v_4 = env.Limit - env.Cursor
		lab14:
			for {
				// (, line 319
				// [, line 319
				env.Ket = env.Cursor
				// (, line 319
				// or, line 319
			lab15:
				for {
					var v_5 = env.Limit - env.Cursor
				lab16:
					for {
						// call mark_DUr, line 319
						if !r_mark_DUr(env, context) {
							break lab16
						}
						break lab15
					}
					env.Cursor = env.Limit - v_5
				lab17:
					for {
						// call mark_yDU, line 319
						if !r_mark_yDU(env, context) {
							break lab17
						}
						break lab15
					}
					env.Cursor = env.Limit - v_5
				lab18:
					for {
						// 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:
		for {
			// (, line 323
			// call mark_nUz, line 323
			if !r_mark_nUz(env, context) {
				break lab19
			}
			// (, line 323
			// or, line 323
		lab20:
			for {
				var v_6 = env.Limit - env.Cursor
			lab21:
				for {
					// 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:
		for {
			// (, line 325
			// (, line 325
			// or, line 325
		lab23:
			for {
				var v_7 = env.Limit - env.Cursor
			lab24:
				for {
					// call mark_sUnUz, line 325
					if !r_mark_sUnUz(env, context) {
						break lab24
					}
					break lab23
				}
				env.Cursor = env.Limit - v_7
			lab25:
				for {
					// call mark_yUz, line 325
					if !r_mark_yUz(env, context) {
						break lab25
					}
					break lab23
				}
				env.Cursor = env.Limit - v_7
			lab26:
				for {
					// 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.SliceDel() {
				return false
			}
			// try, line 325
			var v_8 = env.Limit - env.Cursor
		lab27:
			for {
				// (, 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.SliceDel() {
			return false
		}
		// try, line 327
		var v_9 = env.Limit - env.Cursor
	lab28:
		for {
			// (, line 327
			// [, line 327
			env.Ket = env.Cursor
			// (, line 327
			// or, line 327
		lab29:
			for {
				var v_10 = env.Limit - env.Cursor
			lab30:
				for {
					// call mark_sUnUz, line 327
					if !r_mark_sUnUz(env, context) {
						break lab30
					}
					break lab29
				}
				env.Cursor = env.Limit - v_10
			lab31:
				for {
					// call mark_lAr, line 327
					if !r_mark_lAr(env, context) {
						break lab31
					}
					break lab29
				}
				env.Cursor = env.Limit - v_10
			lab32:
				for {
					// call mark_yUm, line 327
					if !r_mark_yUm(env, context) {
						break lab32
					}
					break lab29
				}
				env.Cursor = env.Limit - v_10
			lab33:
				for {
					// call mark_sUn, line 327
					if !r_mark_sUn(env, context) {
						break lab33
					}
					break lab29
				}
				env.Cursor = env.Limit - v_10
			lab34:
				for {
					// 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.SliceDel() {
		return false
	}
	return true
}

func r_stem_suffix_chain_before_ki(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, 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:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, 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.SliceDel() {
				return false
			}
			// try, line 336
			var v_2 = env.Limit - env.Cursor
		lab2:
			for {
				// (, line 336
				// [, line 336
				env.Ket = env.Cursor
				// or, line 338
			lab3:
				for {
					var v_3 = env.Limit - env.Cursor
				lab4:
					for {
						// (, 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.SliceDel() {
							return false
						}
						// try, line 337
						var v_4 = env.Limit - env.Cursor
					lab5:
						for {
							// (, 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.SliceDel() {
						return false
					}
					// try, line 339
					var v_5 = env.Limit - env.Cursor
				lab6:
					for {
						// (, 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.SliceDel() {
							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:
		for {
			// (, 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.SliceDel() {
				return false
			}
			// try, line 343
			var v_6 = env.Limit - env.Cursor
		lab8:
			for {
				// (, line 343
				// [, line 343
				env.Ket = env.Cursor
				// or, line 345
			lab9:
				for {
					var v_7 = env.Limit - env.Cursor
				lab10:
					for {
						// (, 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.SliceDel() {
							return false
						}
						break lab9
					}
					env.Cursor = env.Limit - v_7
				lab11:
					for {
						// (, line 346
						// [, line 346
						env.Ket = env.Cursor
						// or, line 346
					lab12:
						for {
							var v_8 = env.Limit - env.Cursor
						lab13:
							for {
								// 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.SliceDel() {
							return false
						}
						// try, line 346
						var v_9 = env.Limit - env.Cursor
					lab14:
						for {
							// (, 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.SliceDel() {
								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:
		for {
			var v_10 = env.Limit - env.Cursor
		lab16:
			for {
				// (, 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.SliceDel() {
					return false
				}
				break lab15
			}
			env.Cursor = env.Limit - v_10
		lab17:
			for {
				// (, 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.SliceDel() {
					return false
				}
				// try, line 354
				var v_11 = env.Limit - env.Cursor
			lab18:
				for {
					// (, 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.SliceDel() {
						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
}

func r_stem_noun_suffixes(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 361
	// or, line 363
lab0:
	for {
		var v_1 = env.Limit - env.Cursor
	lab1:
		for {
			// (, 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.SliceDel() {
				return false
			}
			// try, line 362
			var v_2 = env.Limit - env.Cursor
		lab2:
			for {
				// (, 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:
		for {
			// (, 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.SliceDel() {
				return false
			}
			// try, line 365
			var v_3 = env.Limit - env.Cursor
		lab4:
			for {
				// (, line 365
				// or, line 367
			lab5:
				for {
					var v_4 = env.Limit - env.Cursor
				lab6:
					for {
						// (, 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.SliceDel() {
							return false
						}
						break lab5
					}
					env.Cursor = env.Limit - v_4
				lab7:
					for {
						// (, line 368
						// [, line 368
						env.Ket = env.Cursor
						// or, line 368
					lab8:
						for {
							var v_5 = env.Limit - env.Cursor
						lab9:
							for {
								// 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.SliceDel() {
							return false
						}
						// try, line 368
						var v_6 = env.Limit - env.Cursor
					lab10:
						for {
							// (, 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.SliceDel() {
								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.SliceDel() {
						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:
		for {
			// (, line 374
			// [, line 374
			env.Ket = env.Cursor
			// (, line 374
			// or, line 374
		lab12:
			for {
				var v_7 = env.Limit - env.Cursor
			lab13:
				for {
					// 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:
			for {
				var v_8 = env.Limit - env.Cursor
			lab15:
				for {
					// (, 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.SliceDel() {
						return false
					}
					break lab14
				}
				env.Cursor = env.Limit - v_8
			lab16:
				for {
					// (, 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.SliceDel() {
						return false
					}
					// try, line 378
					var v_9 = env.Limit - env.Cursor
				lab17:
					for {
						// (, 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.SliceDel() {
							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:
		for {
			// (, line 384
			// [, line 384
			env.Ket = env.Cursor
			// (, line 384
			// or, line 384
		lab19:
			for {
				var v_10 = env.Limit - env.Cursor
			lab20:
				for {
					// 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:
			for {
				var v_11 = env.Limit - env.Cursor
			lab22:
				for {
					// (, 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.SliceDel() {
						return false
					}
					// try, line 384
					var v_12 = env.Limit - env.Cursor
				lab23:
					for {
						// (, 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.SliceDel() {
							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:
		for {
			// (, 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.SliceDel() {
				return false
			}
			// try, line 386
			var v_13 = env.Limit - env.Cursor
		lab25:
			for {
				// (, line 386
				// [, line 386
				env.Ket = env.Cursor
				// (, line 387
				// or, line 389
			lab26:
				for {
					var v_14 = env.Limit - env.Cursor
				lab27:
					for {
						// (, 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.SliceDel() {
							return false
						}
						// try, line 388
						var v_15 = env.Limit - env.Cursor
					lab28:
						for {
							// (, 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.SliceDel() {
								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:
					for {
						// (, 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.SliceDel() {
							return false
						}
						// try, line 390
						var v_16 = env.Limit - env.Cursor
					lab30:
						for {
							// (, 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:
		for {
			// (, line 396
			// [, line 396
			env.Ket = env.Cursor
			// or, line 396
		lab32:
			for {
				var v_17 = env.Limit - env.Cursor
			lab33:
				for {
					// 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.SliceDel() {
				return false
			}
			// try, line 397
			var v_18 = env.Limit - env.Cursor
		lab34:
			for {
				// (, line 397
				// or, line 399
			lab35:
				for {
					var v_19 = env.Limit - env.Cursor
				lab36:
					for {
						// (, 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.SliceDel() {
							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:
					for {
						// (, line 400
						// [, line 400
						env.Ket = env.Cursor
						// or, line 400
					lab38:
						for {
							var v_20 = env.Limit - env.Cursor
						lab39:
							for {
								// 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.SliceDel() {
							return false
						}
						// try, line 400
						var v_21 = env.Limit - env.Cursor
					lab40:
						for {
							// (, 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.SliceDel() {
								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:
		for {
			// (, 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.SliceDel() {
				return false
			}
			break lab0
		}
		env.Cursor = env.Limit - v_1
	lab42:
		for {
			// (, 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:
		for {
			// (, line 410
			// [, line 410
			env.Ket = env.Cursor
			// or, line 410
		lab44:
			for {
				var v_22 = env.Limit - env.Cursor
			lab45:
				for {
					// call mark_DA, line 410
					if !r_mark_DA(env, context) {
						break lab45
					}
					break lab44
				}
				env.Cursor = env.Limit - v_22
			lab46:
				for {
					// 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.SliceDel() {
				return false
			}
			// try, line 410
			var v_23 = env.Limit - env.Cursor
		lab47:
			for {
				// (, line 410
				// [, line 410
				env.Ket = env.Cursor
				// (, line 410
				// or, line 410
			lab48:
				for {
					var v_24 = env.Limit - env.Cursor
				lab49:
					for {
						// (, 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.SliceDel() {
							return false
						}
						// try, line 410
						var v_25 = env.Limit - env.Cursor
					lab50:
						for {
							// (, 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.SliceDel() {
					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:
		for {
			var v_26 = env.Limit - env.Cursor
		lab52:
			for {
				// 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.SliceDel() {
			return false
		}
		// try, line 412
		var v_27 = env.Limit - env.Cursor
	lab53:
		for {
			// (, 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.SliceDel() {
				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
}

func r_post_process_last_consonants(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 415
	// [, line 416
	env.Ket = env.Cursor
	// substring, line 416
	among_var = env.FindAmongB(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.SliceFrom("p") {
			return false
		}
	} else if among_var == 2 {
		// (, line 418
		// <-, line 418
		if !env.SliceFrom("\u00E7") {
			return false
		}
	} else if among_var == 3 {
		// (, line 419
		// <-, line 419
		if !env.SliceFrom("t") {
			return false
		}
	} else if among_var == 4 {
		// (, line 420
		// <-, line 420
		if !env.SliceFrom("k") {
			return false
		}
	}
	return true
}

func r_append_U_to_stems_ending_with_d_or_g(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 430
	// test, line 431
	var v_1 = env.Limit - env.Cursor
	// (, line 431
	// or, line 431
lab0:
	for {
		var v_2 = env.Limit - env.Cursor
	lab1:
		for {
			// literal, line 431
			if !env.EqSB("d") {
				break lab1
			}
			break lab0
		}
		env.Cursor = env.Limit - v_2
		// literal, line 431
		if !env.EqSB("g") {
			return false
		}
		break lab0
	}
	env.Cursor = env.Limit - v_1
	// or, line 433
lab2:
	for {
		var v_3 = env.Limit - env.Cursor
	lab3:
		for {
			// (, line 432
			// test, line 432
			var v_4 = env.Limit - env.Cursor
			// (, line 432
			// (, line 432
			// goto, line 432
		golab4:
			for {
				var v_5 = env.Limit - env.Cursor
			lab5:
				for {
					if !env.InGroupingB(G_vowel, 97, 305) {
						break lab5
					}
					env.Cursor = env.Limit - v_5
					break golab4
				}
				env.Cursor = env.Limit - v_5
				if env.Cursor <= env.LimitBackward {
					break lab3
				}
				env.PrevChar()
			}
			// or, line 432
		lab6:
			for {
				var v_6 = env.Limit - env.Cursor
			lab7:
				for {
					// literal, line 432
					if !env.EqSB("a") {
						break lab7
					}
					break lab6
				}
				env.Cursor = env.Limit - v_6
				// literal, line 432
				if !env.EqSB("\u0131") {
					break lab3
				}
				break lab6
			}
			env.Cursor = env.Limit - v_4
			{
				// <+, line 432
				var c = env.Cursor
				bra, ket := env.Cursor, env.Cursor
				env.Insert(bra, ket, "\u0131")
				env.Cursor = c
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab8:
		for {
			// (, line 434
			// test, line 434
			var v_7 = env.Limit - env.Cursor
			// (, line 434
			// (, line 434
			// goto, line 434
		golab9:
			for {
				var v_8 = env.Limit - env.Cursor
			lab10:
				for {
					if !env.InGroupingB(G_vowel, 97, 305) {
						break lab10
					}
					env.Cursor = env.Limit - v_8
					break golab9
				}
				env.Cursor = env.Limit - v_8
				if env.Cursor <= env.LimitBackward {
					break lab8
				}
				env.PrevChar()
			}
			// or, line 434
		lab11:
			for {
				var v_9 = env.Limit - env.Cursor
			lab12:
				for {
					// literal, line 434
					if !env.EqSB("e") {
						break lab12
					}
					break lab11
				}
				env.Cursor = env.Limit - v_9
				// literal, line 434
				if !env.EqSB("i") {
					break lab8
				}
				break lab11
			}
			env.Cursor = env.Limit - v_7
			{
				// <+, line 434
				var c = env.Cursor
				bra, ket := env.Cursor, env.Cursor
				env.Insert(bra, ket, "i")
				env.Cursor = c
			}
			break lab2
		}
		env.Cursor = env.Limit - v_3
	lab13:
		for {
			// (, line 436
			// test, line 436
			var v_10 = env.Limit - env.Cursor
			// (, line 436
			// (, line 436
			// goto, line 436
		golab14:
			for {
				var v_11 = env.Limit - env.Cursor
			lab15:
				for {
					if !env.InGroupingB(G_vowel, 97, 305) {
						break lab15
					}
					env.Cursor = env.Limit - v_11
					break golab14
				}
				env.Cursor = env.Limit - v_11
				if env.Cursor <= env.LimitBackward {
					break lab13
				}
				env.PrevChar()
			}
			// or, line 436
		lab16:
			for {
				var v_12 = env.Limit - env.Cursor
			lab17:
				for {
					// literal, line 436
					if !env.EqSB("o") {
						break lab17
					}
					break lab16
				}
				env.Cursor = env.Limit - v_12
				// literal, line 436
				if !env.EqSB("u") {
					break lab13
				}
				break lab16
			}
			env.Cursor = env.Limit - v_10
			{
				// <+, line 436
				var c = env.Cursor
				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
		var v_13 = env.Limit - env.Cursor
		// (, line 438
		// (, line 438
		// goto, line 438
	golab18:
		for {
			var v_14 = env.Limit - env.Cursor
		lab19:
			for {
				if !env.InGroupingB(G_vowel, 97, 305) {
					break lab19
				}
				env.Cursor = env.Limit - v_14
				break golab18
			}
			env.Cursor = env.Limit - v_14
			if env.Cursor <= env.LimitBackward {
				return false
			}
			env.PrevChar()
		}
		// or, line 438
	lab20:
		for {
			var v_15 = env.Limit - env.Cursor
		lab21:
			for {
				// literal, line 438
				if !env.EqSB("\u00F6") {
					break lab21
				}
				break lab20
			}
			env.Cursor = env.Limit - v_15
			// literal, line 438
			if !env.EqSB("\u00FC") {
				return false
			}
			break lab20
		}
		env.Cursor = env.Limit - v_13
		{
			// <+, line 438
			var c = env.Cursor
			bra, ket := env.Cursor, env.Cursor
			env.Insert(bra, ket, "\u00FC")
			env.Cursor = c
		}
		break lab2
	}
	return true
}

func r_more_than_one_syllable_word(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 445
	// test, line 446
	var v_1 = env.Cursor
	// (, line 446
	// atleast, line 446
	var v_2 = 2
	// atleast, line 446
replab0:
	for {
		var v_3 = env.Cursor
	lab1:
		for range [2]struct{}{} {
			// (, line 446
			// gopast, line 446
		golab2:
			for {
			lab3:
				for {
					if !env.InGrouping(G_vowel, 97, 305) {
						break lab3
					}
					break golab2
				}
				if env.Cursor >= env.Limit {
					break lab1
				}
				env.NextChar()
			}
			v_2--
			continue replab0
		}
		env.Cursor = v_3
		break replab0
	}
	if v_2 > 0 {
		return false
	}
	env.Cursor = v_1
	return true
}

func r_is_reserved_word(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 449
	// or, line 451
lab0:
	for {
		var v_1 = env.Cursor
	lab1:
		for {
			// test, line 450
			var v_2 = env.Cursor
			// (, line 450
			// gopast, line 450
		golab2:
			for {
			lab3:
				for {
					// literal, line 450
					if !env.EqS("ad") {
						break lab3
					}
					break golab2
				}
				if env.Cursor >= env.Limit {
					break lab1
				}
				env.NextChar()
			}
			// (, 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
		var v_4 = env.Cursor
		// (, line 452
		// gopast, line 452
	golab4:
		for {
		lab5:
			for {
				// literal, line 452
				if !env.EqS("soyad") {
					break lab5
				}
				break golab4
			}
			if env.Cursor >= env.Limit {
				return false
			}
			env.NextChar()
		}
		// (, line 452
		context.i_strlen = 5
		// (, line 452
		if !(context.i_strlen == env.Limit) {
			return false
		}
		env.Cursor = v_4
		break lab0
	}
	return true
}

func r_postlude(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 455
	// not, line 456
	var v_1 = env.Cursor
lab0:
	for {
		// (, 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.LimitBackward = env.Cursor
	env.Cursor = env.Limit
	// (, line 457
	// do, line 458
	var v_2 = env.Limit - env.Cursor
lab1:
	for {
		// 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
	var v_3 = env.Limit - env.Cursor
lab2:
	for {
		// 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.LimitBackward
	return true
}

func Stem(env *snowballRuntime.Env) bool {
	var context = &Context{
		b_continue_stemming_noun_suffixes: false,
		i_strlen: 0,
	}
	_ = context
	// (, 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.LimitBackward = env.Cursor
	env.Cursor = env.Limit
	// (, line 467
	// do, line 468
	var v_1 = env.Limit - env.Cursor
lab0:
	for {
		// 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
	var v_2 = env.Limit - env.Cursor
lab1:
	for {
		// 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.LimitBackward
	// call postlude, line 473
	if !r_postlude(env, context) {
		return false
	}
	return true
}
