portuguese_stemmer.go

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

package portuguese

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

var A_0 = []*snowballRuntime.Among{
	{Str: "", A: -1, B: 3, F: nil},
	{Str: "\u00E3", A: 0, B: 1, F: nil},
	{Str: "\u00F5", A: 0, B: 2, F: nil},
}

var A_1 = []*snowballRuntime.Among{
	{Str: "", A: -1, B: 3, F: nil},
	{Str: "a~", A: 0, B: 1, F: nil},
	{Str: "o~", A: 0, B: 2, F: nil},
}

var A_2 = []*snowballRuntime.Among{
	{Str: "ic", A: -1, B: -1, F: nil},
	{Str: "ad", A: -1, B: -1, F: nil},
	{Str: "os", A: -1, B: -1, F: nil},
	{Str: "iv", A: -1, B: 1, F: nil},
}

var A_3 = []*snowballRuntime.Among{
	{Str: "ante", A: -1, B: 1, F: nil},
	{Str: "avel", A: -1, B: 1, F: nil},
	{Str: "\u00EDvel", A: -1, B: 1, F: nil},
}

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

var A_5 = []*snowballRuntime.Among{
	{Str: "ica", A: -1, B: 1, F: nil},
	{Str: "\u00E2ncia", A: -1, B: 1, F: nil},
	{Str: "\u00EAncia", A: -1, B: 4, F: nil},
	{Str: "logia", A: -1, B: 2, F: nil},
	{Str: "ira", A: -1, B: 9, F: nil},
	{Str: "adora", A: -1, B: 1, F: nil},
	{Str: "osa", A: -1, B: 1, F: nil},
	{Str: "ista", A: -1, B: 1, F: nil},
	{Str: "iva", A: -1, B: 8, F: nil},
	{Str: "eza", A: -1, B: 1, F: nil},
	{Str: "idade", A: -1, B: 7, F: nil},
	{Str: "ante", A: -1, B: 1, F: nil},
	{Str: "mente", A: -1, B: 6, F: nil},
	{Str: "amente", A: 12, B: 5, F: nil},
	{Str: "\u00E1vel", A: -1, B: 1, F: nil},
	{Str: "\u00EDvel", A: -1, B: 1, F: nil},
	{Str: "ico", A: -1, B: 1, F: nil},
	{Str: "ismo", A: -1, B: 1, F: nil},
	{Str: "oso", A: -1, B: 1, F: nil},
	{Str: "amento", A: -1, B: 1, F: nil},
	{Str: "imento", A: -1, B: 1, F: nil},
	{Str: "ivo", A: -1, B: 8, F: nil},
	{Str: "a\u00E7a~o", A: -1, B: 1, F: nil},
	{Str: "u\u00E7a~o", A: -1, B: 3, F: nil},
	{Str: "ador", A: -1, B: 1, F: nil},
	{Str: "icas", A: -1, B: 1, F: nil},
	{Str: "\u00EAncias", A: -1, B: 4, F: nil},
	{Str: "logias", A: -1, B: 2, F: nil},
	{Str: "iras", A: -1, B: 9, F: nil},
	{Str: "adoras", A: -1, B: 1, F: nil},
	{Str: "osas", A: -1, B: 1, F: nil},
	{Str: "istas", A: -1, B: 1, F: nil},
	{Str: "ivas", A: -1, B: 8, F: nil},
	{Str: "ezas", A: -1, B: 1, F: nil},
	{Str: "idades", A: -1, B: 7, F: nil},
	{Str: "adores", A: -1, B: 1, F: nil},
	{Str: "antes", A: -1, B: 1, F: nil},
	{Str: "a\u00E7o~es", A: -1, B: 1, F: nil},
	{Str: "u\u00E7o~es", A: -1, B: 3, F: nil},
	{Str: "icos", A: -1, B: 1, F: nil},
	{Str: "ismos", A: -1, B: 1, F: nil},
	{Str: "osos", A: -1, B: 1, F: nil},
	{Str: "amentos", A: -1, B: 1, F: nil},
	{Str: "imentos", A: -1, B: 1, F: nil},
	{Str: "ivos", A: -1, B: 8, F: nil},
}

var A_6 = []*snowballRuntime.Among{
	{Str: "ada", A: -1, B: 1, F: nil},
	{Str: "ida", A: -1, B: 1, F: nil},
	{Str: "ia", A: -1, B: 1, F: nil},
	{Str: "aria", A: 2, B: 1, F: nil},
	{Str: "eria", A: 2, B: 1, F: nil},
	{Str: "iria", A: 2, B: 1, F: nil},
	{Str: "ara", A: -1, B: 1, F: nil},
	{Str: "era", A: -1, B: 1, F: nil},
	{Str: "ira", A: -1, B: 1, F: nil},
	{Str: "ava", A: -1, B: 1, F: nil},
	{Str: "asse", A: -1, B: 1, F: nil},
	{Str: "esse", A: -1, B: 1, F: nil},
	{Str: "isse", A: -1, B: 1, F: nil},
	{Str: "aste", A: -1, B: 1, F: nil},
	{Str: "este", A: -1, B: 1, F: nil},
	{Str: "iste", A: -1, B: 1, F: nil},
	{Str: "ei", A: -1, B: 1, F: nil},
	{Str: "arei", A: 16, B: 1, F: nil},
	{Str: "erei", A: 16, B: 1, F: nil},
	{Str: "irei", A: 16, B: 1, F: nil},
	{Str: "am", A: -1, B: 1, F: nil},
	{Str: "iam", A: 20, B: 1, F: nil},
	{Str: "ariam", A: 21, B: 1, F: nil},
	{Str: "eriam", A: 21, B: 1, F: nil},
	{Str: "iriam", A: 21, B: 1, F: nil},
	{Str: "aram", A: 20, B: 1, F: nil},
	{Str: "eram", A: 20, B: 1, F: nil},
	{Str: "iram", A: 20, B: 1, F: nil},
	{Str: "avam", A: 20, B: 1, F: nil},
	{Str: "em", A: -1, B: 1, F: nil},
	{Str: "arem", A: 29, B: 1, F: nil},
	{Str: "erem", A: 29, B: 1, F: nil},
	{Str: "irem", A: 29, B: 1, F: nil},
	{Str: "assem", A: 29, B: 1, F: nil},
	{Str: "essem", A: 29, B: 1, F: nil},
	{Str: "issem", A: 29, B: 1, F: nil},
	{Str: "ado", A: -1, B: 1, F: nil},
	{Str: "ido", A: -1, B: 1, F: nil},
	{Str: "ando", A: -1, B: 1, F: nil},
	{Str: "endo", A: -1, B: 1, F: nil},
	{Str: "indo", A: -1, B: 1, F: nil},
	{Str: "ara~o", A: -1, B: 1, F: nil},
	{Str: "era~o", A: -1, B: 1, F: nil},
	{Str: "ira~o", A: -1, B: 1, F: nil},
	{Str: "ar", A: -1, B: 1, F: nil},
	{Str: "er", A: -1, B: 1, F: nil},
	{Str: "ir", A: -1, B: 1, F: nil},
	{Str: "as", A: -1, B: 1, F: nil},
	{Str: "adas", A: 47, B: 1, F: nil},
	{Str: "idas", A: 47, B: 1, F: nil},
	{Str: "ias", A: 47, B: 1, F: nil},
	{Str: "arias", A: 50, B: 1, F: nil},
	{Str: "erias", A: 50, B: 1, F: nil},
	{Str: "irias", A: 50, B: 1, F: nil},
	{Str: "aras", A: 47, B: 1, F: nil},
	{Str: "eras", A: 47, B: 1, F: nil},
	{Str: "iras", A: 47, B: 1, F: nil},
	{Str: "avas", A: 47, B: 1, F: nil},
	{Str: "es", A: -1, B: 1, F: nil},
	{Str: "ardes", A: 58, B: 1, F: nil},
	{Str: "erdes", A: 58, B: 1, F: nil},
	{Str: "irdes", A: 58, B: 1, F: nil},
	{Str: "ares", A: 58, B: 1, F: nil},
	{Str: "eres", A: 58, B: 1, F: nil},
	{Str: "ires", A: 58, B: 1, F: nil},
	{Str: "asses", A: 58, B: 1, F: nil},
	{Str: "esses", A: 58, B: 1, F: nil},
	{Str: "isses", A: 58, B: 1, F: nil},
	{Str: "astes", A: 58, B: 1, F: nil},
	{Str: "estes", A: 58, B: 1, F: nil},
	{Str: "istes", A: 58, B: 1, F: nil},
	{Str: "is", A: -1, B: 1, F: nil},
	{Str: "ais", A: 71, B: 1, F: nil},
	{Str: "eis", A: 71, B: 1, F: nil},
	{Str: "areis", A: 73, B: 1, F: nil},
	{Str: "ereis", A: 73, B: 1, F: nil},
	{Str: "ireis", A: 73, B: 1, F: nil},
	{Str: "\u00E1reis", A: 73, B: 1, F: nil},
	{Str: "\u00E9reis", A: 73, B: 1, F: nil},
	{Str: "\u00EDreis", A: 73, B: 1, F: nil},
	{Str: "\u00E1sseis", A: 73, B: 1, F: nil},
	{Str: "\u00E9sseis", A: 73, B: 1, F: nil},
	{Str: "\u00EDsseis", A: 73, B: 1, F: nil},
	{Str: "\u00E1veis", A: 73, B: 1, F: nil},
	{Str: "\u00EDeis", A: 73, B: 1, F: nil},
	{Str: "ar\u00EDeis", A: 84, B: 1, F: nil},
	{Str: "er\u00EDeis", A: 84, B: 1, F: nil},
	{Str: "ir\u00EDeis", A: 84, B: 1, F: nil},
	{Str: "ados", A: -1, B: 1, F: nil},
	{Str: "idos", A: -1, B: 1, F: nil},
	{Str: "amos", A: -1, B: 1, F: nil},
	{Str: "\u00E1ramos", A: 90, B: 1, F: nil},
	{Str: "\u00E9ramos", A: 90, B: 1, F: nil},
	{Str: "\u00EDramos", A: 90, B: 1, F: nil},
	{Str: "\u00E1vamos", A: 90, B: 1, F: nil},
	{Str: "\u00EDamos", A: 90, B: 1, F: nil},
	{Str: "ar\u00EDamos", A: 95, B: 1, F: nil},
	{Str: "er\u00EDamos", A: 95, B: 1, F: nil},
	{Str: "ir\u00EDamos", A: 95, B: 1, F: nil},
	{Str: "emos", A: -1, B: 1, F: nil},
	{Str: "aremos", A: 99, B: 1, F: nil},
	{Str: "eremos", A: 99, B: 1, F: nil},
	{Str: "iremos", A: 99, B: 1, F: nil},
	{Str: "\u00E1ssemos", A: 99, B: 1, F: nil},
	{Str: "\u00EAssemos", A: 99, B: 1, F: nil},
	{Str: "\u00EDssemos", A: 99, B: 1, F: nil},
	{Str: "imos", A: -1, B: 1, F: nil},
	{Str: "armos", A: -1, B: 1, F: nil},
	{Str: "ermos", A: -1, B: 1, F: nil},
	{Str: "irmos", A: -1, B: 1, F: nil},
	{Str: "\u00E1mos", A: -1, B: 1, F: nil},
	{Str: "ar\u00E1s", A: -1, B: 1, F: nil},
	{Str: "er\u00E1s", A: -1, B: 1, F: nil},
	{Str: "ir\u00E1s", A: -1, B: 1, F: nil},
	{Str: "eu", A: -1, B: 1, F: nil},
	{Str: "iu", A: -1, B: 1, F: nil},
	{Str: "ou", A: -1, B: 1, F: nil},
	{Str: "ar\u00E1", A: -1, B: 1, F: nil},
	{Str: "er\u00E1", A: -1, B: 1, F: nil},
	{Str: "ir\u00E1", A: -1, B: 1, F: nil},
}

var A_7 = []*snowballRuntime.Among{
	{Str: "a", A: -1, B: 1, F: nil},
	{Str: "i", A: -1, B: 1, F: nil},
	{Str: "o", A: -1, B: 1, F: nil},
	{Str: "os", A: -1, B: 1, F: nil},
	{Str: "\u00E1", A: -1, B: 1, F: nil},
	{Str: "\u00ED", A: -1, B: 1, F: nil},
	{Str: "\u00F3", A: -1, B: 1, F: nil},
}

var A_8 = []*snowballRuntime.Among{
	{Str: "e", A: -1, B: 1, F: nil},
	{Str: "\u00E7", A: -1, B: 2, F: nil},
	{Str: "\u00E9", A: -1, B: 1, F: nil},
	{Str: "\u00EA", A: -1, B: 1, F: nil},
}

var G_v = []byte{17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 19, 12, 2}

type Context struct {
	i_p2 int
	i_p1 int
	i_pV int
}

func r_prelude(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// repeat, line 36
replab0:
	for {
		var v_1 = env.Cursor
	lab1:
		for range [2]struct{}{} {
			// (, line 36
			// [, line 37
			env.Bra = env.Cursor
			// substring, line 37
			among_var = env.FindAmong(A_0, context)
			if among_var == 0 {
				break lab1
			}
			// ], line 37
			env.Ket = env.Cursor
			if among_var == 0 {
				break lab1
			} else if among_var == 1 {
				// (, line 38
				// <-, line 38
				if !env.SliceFrom("a~") {
					return false
				}
			} else if among_var == 2 {
				// (, line 39
				// <-, line 39
				if !env.SliceFrom("o~") {
					return false
				}
			} else if among_var == 3 {
				// (, line 40
				// next, line 40
				if env.Cursor >= env.Limit {
					break lab1
				}
				env.NextChar()
			}
			continue replab0
		}
		env.Cursor = v_1
		break replab0
	}
	return true
}

func r_mark_regions(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 44
	context.i_pV = env.Limit
	context.i_p1 = env.Limit
	context.i_p2 = env.Limit
	// do, line 50
	var v_1 = env.Cursor
lab0:
	for {
		// (, line 50
		// or, line 52
	lab1:
		for {
			var v_2 = env.Cursor
		lab2:
			for {
				// (, line 51
				if !env.InGrouping(G_v, 97, 250) {
					break lab2
				}
				// or, line 51
			lab3:
				for {
					var v_3 = env.Cursor
				lab4:
					for {
						// (, line 51
						if !env.OutGrouping(G_v, 97, 250) {
							break lab4
						}
						// gopast, line 51
					golab5:
						for {
						lab6:
							for {
								if !env.InGrouping(G_v, 97, 250) {
									break lab6
								}
								break golab5
							}
							if env.Cursor >= env.Limit {
								break lab4
							}
							env.NextChar()
						}
						break lab3
					}
					env.Cursor = v_3
					// (, line 51
					if !env.InGrouping(G_v, 97, 250) {
						break lab2
					}
					// gopast, line 51
				golab7:
					for {
					lab8:
						for {
							if !env.OutGrouping(G_v, 97, 250) {
								break lab8
							}
							break golab7
						}
						if env.Cursor >= env.Limit {
							break lab2
						}
						env.NextChar()
					}
					break lab3
				}
				break lab1
			}
			env.Cursor = v_2
			// (, line 53
			if !env.OutGrouping(G_v, 97, 250) {
				break lab0
			}
			// or, line 53
		lab9:
			for {
				var v_6 = env.Cursor
			lab10:
				for {
					// (, line 53
					if !env.OutGrouping(G_v, 97, 250) {
						break lab10
					}
					// gopast, line 53
				golab11:
					for {
					lab12:
						for {
							if !env.InGrouping(G_v, 97, 250) {
								break lab12
							}
							break golab11
						}
						if env.Cursor >= env.Limit {
							break lab10
						}
						env.NextChar()
					}
					break lab9
				}
				env.Cursor = v_6
				// (, line 53
				if !env.InGrouping(G_v, 97, 250) {
					break lab0
				}
				// next, line 53
				if env.Cursor >= env.Limit {
					break lab0
				}
				env.NextChar()
				break lab9
			}
			break lab1
		}
		// setmark pV, line 54
		context.i_pV = env.Cursor
		break lab0
	}
	env.Cursor = v_1
	// do, line 56
	var v_8 = env.Cursor
lab13:
	for {
		// (, line 56
		// gopast, line 57
	golab14:
		for {
		lab15:
			for {
				if !env.InGrouping(G_v, 97, 250) {
					break lab15
				}
				break golab14
			}
			if env.Cursor >= env.Limit {
				break lab13
			}
			env.NextChar()
		}
		// gopast, line 57
	golab16:
		for {
		lab17:
			for {
				if !env.OutGrouping(G_v, 97, 250) {
					break lab17
				}
				break golab16
			}
			if env.Cursor >= env.Limit {
				break lab13
			}
			env.NextChar()
		}
		// setmark p1, line 57
		context.i_p1 = env.Cursor
		// gopast, line 58
	golab18:
		for {
		lab19:
			for {
				if !env.InGrouping(G_v, 97, 250) {
					break lab19
				}
				break golab18
			}
			if env.Cursor >= env.Limit {
				break lab13
			}
			env.NextChar()
		}
		// gopast, line 58
	golab20:
		for {
		lab21:
			for {
				if !env.OutGrouping(G_v, 97, 250) {
					break lab21
				}
				break golab20
			}
			if env.Cursor >= env.Limit {
				break lab13
			}
			env.NextChar()
		}
		// setmark p2, line 58
		context.i_p2 = env.Cursor
		break lab13
	}
	env.Cursor = v_8
	return true
}

func r_postlude(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// repeat, line 62
replab0:
	for {
		var v_1 = env.Cursor
	lab1:
		for range [2]struct{}{} {
			// (, line 62
			// [, line 63
			env.Bra = env.Cursor
			// substring, line 63
			among_var = env.FindAmong(A_1, context)
			if among_var == 0 {
				break lab1
			}
			// ], line 63
			env.Ket = env.Cursor
			if among_var == 0 {
				break lab1
			} else if among_var == 1 {
				// (, line 64
				// <-, line 64
				if !env.SliceFrom("\u00E3") {
					return false
				}
			} else if among_var == 2 {
				// (, line 65
				// <-, line 65
				if !env.SliceFrom("\u00F5") {
					return false
				}
			} else if among_var == 3 {
				// (, line 66
				// next, line 66
				if env.Cursor >= env.Limit {
					break lab1
				}
				env.NextChar()
			}
			continue replab0
		}
		env.Cursor = v_1
		break replab0
	}
	return true
}

func r_RV(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	if !(context.i_pV <= env.Cursor) {
		return false
	}
	return true
}

func r_R1(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	if !(context.i_p1 <= env.Cursor) {
		return false
	}
	return true
}

func r_R2(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	if !(context.i_p2 <= env.Cursor) {
		return false
	}
	return true
}

func r_standard_suffix(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 76
	// [, line 77
	env.Ket = env.Cursor
	// substring, line 77
	among_var = env.FindAmongB(A_5, context)
	if among_var == 0 {
		return false
	}
	// ], line 77
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 92
		// call R2, line 93
		if !r_R2(env, context) {
			return false
		}
		// delete, line 93
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 97
		// call R2, line 98
		if !r_R2(env, context) {
			return false
		}
		// <-, line 98
		if !env.SliceFrom("log") {
			return false
		}
	} else if among_var == 3 {
		// (, line 101
		// call R2, line 102
		if !r_R2(env, context) {
			return false
		}
		// <-, line 102
		if !env.SliceFrom("u") {
			return false
		}
	} else if among_var == 4 {
		// (, line 105
		// call R2, line 106
		if !r_R2(env, context) {
			return false
		}
		// <-, line 106
		if !env.SliceFrom("ente") {
			return false
		}
	} else if among_var == 5 {
		// (, line 109
		// call R1, line 110
		if !r_R1(env, context) {
			return false
		}
		// delete, line 110
		if !env.SliceDel() {
			return false
		}
		// try, line 111
		var v_1 = env.Limit - env.Cursor
	lab0:
		for {
			// (, line 111
			// [, line 112
			env.Ket = env.Cursor
			// substring, line 112
			among_var = env.FindAmongB(A_2, context)
			if among_var == 0 {
				env.Cursor = env.Limit - v_1
				break lab0
			}
			// ], line 112
			env.Bra = env.Cursor
			// call R2, line 112
			if !r_R2(env, context) {
				env.Cursor = env.Limit - v_1
				break lab0
			}
			// delete, line 112
			if !env.SliceDel() {
				return false
			}
			if among_var == 0 {
				env.Cursor = env.Limit - v_1
				break lab0
			} else if among_var == 1 {
				// (, line 113
				// [, line 113
				env.Ket = env.Cursor
				// literal, line 113
				if !env.EqSB("at") {
					env.Cursor = env.Limit - v_1
					break lab0
				}
				// ], line 113
				env.Bra = env.Cursor
				// call R2, line 113
				if !r_R2(env, context) {
					env.Cursor = env.Limit - v_1
					break lab0
				}
				// delete, line 113
				if !env.SliceDel() {
					return false
				}
			}
			break lab0
		}
	} else if among_var == 6 {
		// (, line 121
		// call R2, line 122
		if !r_R2(env, context) {
			return false
		}
		// delete, line 122
		if !env.SliceDel() {
			return false
		}
		// try, line 123
		var v_2 = env.Limit - env.Cursor
	lab1:
		for {
			// (, line 123
			// [, line 124
			env.Ket = env.Cursor
			// substring, line 124
			among_var = env.FindAmongB(A_3, context)
			if among_var == 0 {
				env.Cursor = env.Limit - v_2
				break lab1
			}
			// ], line 124
			env.Bra = env.Cursor
			if among_var == 0 {
				env.Cursor = env.Limit - v_2
				break lab1
			} else if among_var == 1 {
				// (, line 127
				// call R2, line 127
				if !r_R2(env, context) {
					env.Cursor = env.Limit - v_2
					break lab1
				}
				// delete, line 127
				if !env.SliceDel() {
					return false
				}
			}
			break lab1
		}
	} else if among_var == 7 {
		// (, line 133
		// call R2, line 134
		if !r_R2(env, context) {
			return false
		}
		// delete, line 134
		if !env.SliceDel() {
			return false
		}
		// try, line 135
		var v_3 = env.Limit - env.Cursor
	lab2:
		for {
			// (, line 135
			// [, line 136
			env.Ket = env.Cursor
			// substring, line 136
			among_var = env.FindAmongB(A_4, context)
			if among_var == 0 {
				env.Cursor = env.Limit - v_3
				break lab2
			}
			// ], line 136
			env.Bra = env.Cursor
			if among_var == 0 {
				env.Cursor = env.Limit - v_3
				break lab2
			} else if among_var == 1 {
				// (, line 139
				// call R2, line 139
				if !r_R2(env, context) {
					env.Cursor = env.Limit - v_3
					break lab2
				}
				// delete, line 139
				if !env.SliceDel() {
					return false
				}
			}
			break lab2
		}
	} else if among_var == 8 {
		// (, line 145
		// call R2, line 146
		if !r_R2(env, context) {
			return false
		}
		// delete, line 146
		if !env.SliceDel() {
			return false
		}
		// try, line 147
		var v_4 = env.Limit - env.Cursor
	lab3:
		for {
			// (, line 147
			// [, line 148
			env.Ket = env.Cursor
			// literal, line 148
			if !env.EqSB("at") {
				env.Cursor = env.Limit - v_4
				break lab3
			}
			// ], line 148
			env.Bra = env.Cursor
			// call R2, line 148
			if !r_R2(env, context) {
				env.Cursor = env.Limit - v_4
				break lab3
			}
			// delete, line 148
			if !env.SliceDel() {
				return false
			}
			break lab3
		}
	} else if among_var == 9 {
		// (, line 152
		// call RV, line 153
		if !r_RV(env, context) {
			return false
		}
		// literal, line 153
		if !env.EqSB("e") {
			return false
		}
		// <-, line 154
		if !env.SliceFrom("ir") {
			return false
		}
	}
	return true
}

func r_verb_suffix(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// setlimit, line 159
	var v_1 = env.Limit - env.Cursor
	// tomark, line 159
	if env.Cursor < context.i_pV {
		return false
	}
	env.Cursor = context.i_pV
	var v_2 = env.LimitBackward
	env.LimitBackward = env.Cursor
	env.Cursor = env.Limit - v_1
	// (, line 159
	// [, line 160
	env.Ket = env.Cursor
	// substring, line 160
	among_var = env.FindAmongB(A_6, context)
	if among_var == 0 {
		env.LimitBackward = v_2
		return false
	}
	// ], line 160
	env.Bra = env.Cursor
	if among_var == 0 {
		env.LimitBackward = v_2
		return false
	} else if among_var == 1 {
		// (, line 179
		// delete, line 179
		if !env.SliceDel() {
			return false
		}
	}
	env.LimitBackward = v_2
	return true
}

func r_residual_suffix(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 183
	// [, line 184
	env.Ket = env.Cursor
	// substring, line 184
	among_var = env.FindAmongB(A_7, context)
	if among_var == 0 {
		return false
	}
	// ], line 184
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 187
		// call RV, line 187
		if !r_RV(env, context) {
			return false
		}
		// delete, line 187
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_residual_form(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 191
	// [, line 192
	env.Ket = env.Cursor
	// substring, line 192
	among_var = env.FindAmongB(A_8, context)
	if among_var == 0 {
		return false
	}
	// ], line 192
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 194
		// call RV, line 194
		if !r_RV(env, context) {
			return false
		}
		// delete, line 194
		if !env.SliceDel() {
			return false
		}
		// [, line 194
		env.Ket = env.Cursor
		// or, line 194
	lab0:
		for {
			var v_1 = env.Limit - env.Cursor
		lab1:
			for {
				// (, line 194
				// literal, line 194
				if !env.EqSB("u") {
					break lab1
				}
				// ], line 194
				env.Bra = env.Cursor
				// test, line 194
				var v_2 = env.Limit - env.Cursor
				// literal, line 194
				if !env.EqSB("g") {
					break lab1
				}
				env.Cursor = env.Limit - v_2
				break lab0
			}
			env.Cursor = env.Limit - v_1
			// (, line 195
			// literal, line 195
			if !env.EqSB("i") {
				return false
			}
			// ], line 195
			env.Bra = env.Cursor
			// test, line 195
			var v_3 = env.Limit - env.Cursor
			// literal, line 195
			if !env.EqSB("c") {
				return false
			}
			env.Cursor = env.Limit - v_3
			break lab0
		}
		// call RV, line 195
		if !r_RV(env, context) {
			return false
		}
		// delete, line 195
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 196
		// <-, line 196
		if !env.SliceFrom("c") {
			return false
		}
	}
	return true
}

func Stem(env *snowballRuntime.Env) bool {
	var context = &Context{
		i_p2: 0,
		i_p1: 0,
		i_pV: 0,
	}
	_ = context
	// (, line 201
	// do, line 202
	var v_1 = env.Cursor
lab0:
	for {
		// call prelude, line 202
		if !r_prelude(env, context) {
			break lab0
		}
		break lab0
	}
	env.Cursor = v_1
	// do, line 203
	var v_2 = env.Cursor
lab1:
	for {
		// call mark_regions, line 203
		if !r_mark_regions(env, context) {
			break lab1
		}
		break lab1
	}
	env.Cursor = v_2
	// backwards, line 204
	env.LimitBackward = env.Cursor
	env.Cursor = env.Limit
	// (, line 204
	// do, line 205
	var v_3 = env.Limit - env.Cursor
lab2:
	for {
		// (, line 205
		// or, line 209
	lab3:
		for {
			var v_4 = env.Limit - env.Cursor
		lab4:
			for {
				// (, line 206
				// and, line 207
				var v_5 = env.Limit - env.Cursor
				// (, line 206
				// or, line 206
			lab5:
				for {
					var v_6 = env.Limit - env.Cursor
				lab6:
					for {
						// call standard_suffix, line 206
						if !r_standard_suffix(env, context) {
							break lab6
						}
						break lab5
					}
					env.Cursor = env.Limit - v_6
					// call verb_suffix, line 206
					if !r_verb_suffix(env, context) {
						break lab4
					}
					break lab5
				}
				env.Cursor = env.Limit - v_5
				// do, line 207
				var v_7 = env.Limit - env.Cursor
			lab7:
				for {
					// (, line 207
					// [, line 207
					env.Ket = env.Cursor
					// literal, line 207
					if !env.EqSB("i") {
						break lab7
					}
					// ], line 207
					env.Bra = env.Cursor
					// test, line 207
					var v_8 = env.Limit - env.Cursor
					// literal, line 207
					if !env.EqSB("c") {
						break lab7
					}
					env.Cursor = env.Limit - v_8
					// call RV, line 207
					if !r_RV(env, context) {
						break lab7
					}
					// delete, line 207
					if !env.SliceDel() {
						return false
					}
					break lab7
				}
				env.Cursor = env.Limit - v_7
				break lab3
			}
			env.Cursor = env.Limit - v_4
			// call residual_suffix, line 209
			if !r_residual_suffix(env, context) {
				break lab2
			}
			break lab3
		}
		break lab2
	}
	env.Cursor = env.Limit - v_3
	// do, line 211
	var v_9 = env.Limit - env.Cursor
lab8:
	for {
		// call residual_form, line 211
		if !r_residual_form(env, context) {
			break lab8
		}
		break lab8
	}
	env.Cursor = env.Limit - v_9
	env.Cursor = env.LimitBackward
	// do, line 213
	var v_10 = env.Cursor
lab9:
	for {
		// call postlude, line 213
		if !r_postlude(env, context) {
			break lab9
		}
		break lab9
	}
	env.Cursor = v_10
	return true
}