arabic_stemmer.go

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

package arabic

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

var A_0 = []*snowballRuntime.Among{
	{Str: "\u0640", A: -1, B: 2, F: nil},
	{Str: "\u064B", A: -1, B: 1, F: nil},
	{Str: "\u064C", A: -1, B: 1, F: nil},
	{Str: "\u064D", A: -1, B: 1, F: nil},
	{Str: "\u064E", A: -1, B: 1, F: nil},
	{Str: "\u064F", A: -1, B: 1, F: nil},
	{Str: "\u0650", A: -1, B: 1, F: nil},
	{Str: "\u0651", A: -1, B: 1, F: nil},
	{Str: "\u0652", A: -1, B: 1, F: nil},
	{Str: "\u0660", A: -1, B: 3, F: nil},
	{Str: "\u0661", A: -1, B: 4, F: nil},
	{Str: "\u0662", A: -1, B: 5, F: nil},
	{Str: "\u0663", A: -1, B: 6, F: nil},
	{Str: "\u0664", A: -1, B: 7, F: nil},
	{Str: "\u0665", A: -1, B: 8, F: nil},
	{Str: "\u0666", A: -1, B: 9, F: nil},
	{Str: "\u0667", A: -1, B: 10, F: nil},
	{Str: "\u0668", A: -1, B: 11, F: nil},
	{Str: "\u0669", A: -1, B: 12, F: nil},
	{Str: "\uFE80", A: -1, B: 13, F: nil},
	{Str: "\uFE81", A: -1, B: 17, F: nil},
	{Str: "\uFE82", A: -1, B: 17, F: nil},
	{Str: "\uFE83", A: -1, B: 14, F: nil},
	{Str: "\uFE84", A: -1, B: 14, F: nil},
	{Str: "\uFE85", A: -1, B: 18, F: nil},
	{Str: "\uFE86", A: -1, B: 18, F: nil},
	{Str: "\uFE87", A: -1, B: 15, F: nil},
	{Str: "\uFE88", A: -1, B: 15, F: nil},
	{Str: "\uFE89", A: -1, B: 16, F: nil},
	{Str: "\uFE8A", A: -1, B: 16, F: nil},
	{Str: "\uFE8B", A: -1, B: 16, F: nil},
	{Str: "\uFE8C", A: -1, B: 16, F: nil},
	{Str: "\uFE8D", A: -1, B: 19, F: nil},
	{Str: "\uFE8E", A: -1, B: 19, F: nil},
	{Str: "\uFE8F", A: -1, B: 20, F: nil},
	{Str: "\uFE90", A: -1, B: 20, F: nil},
	{Str: "\uFE91", A: -1, B: 20, F: nil},
	{Str: "\uFE92", A: -1, B: 20, F: nil},
	{Str: "\uFE93", A: -1, B: 21, F: nil},
	{Str: "\uFE94", A: -1, B: 21, F: nil},
	{Str: "\uFE95", A: -1, B: 22, F: nil},
	{Str: "\uFE96", A: -1, B: 22, F: nil},
	{Str: "\uFE97", A: -1, B: 22, F: nil},
	{Str: "\uFE98", A: -1, B: 22, F: nil},
	{Str: "\uFE99", A: -1, B: 23, F: nil},
	{Str: "\uFE9A", A: -1, B: 23, F: nil},
	{Str: "\uFE9B", A: -1, B: 23, F: nil},
	{Str: "\uFE9C", A: -1, B: 23, F: nil},
	{Str: "\uFE9D", A: -1, B: 24, F: nil},
	{Str: "\uFE9E", A: -1, B: 24, F: nil},
	{Str: "\uFE9F", A: -1, B: 24, F: nil},
	{Str: "\uFEA0", A: -1, B: 24, F: nil},
	{Str: "\uFEA1", A: -1, B: 25, F: nil},
	{Str: "\uFEA2", A: -1, B: 25, F: nil},
	{Str: "\uFEA3", A: -1, B: 25, F: nil},
	{Str: "\uFEA4", A: -1, B: 25, F: nil},
	{Str: "\uFEA5", A: -1, B: 26, F: nil},
	{Str: "\uFEA6", A: -1, B: 26, F: nil},
	{Str: "\uFEA7", A: -1, B: 26, F: nil},
	{Str: "\uFEA8", A: -1, B: 26, F: nil},
	{Str: "\uFEA9", A: -1, B: 27, F: nil},
	{Str: "\uFEAA", A: -1, B: 27, F: nil},
	{Str: "\uFEAB", A: -1, B: 28, F: nil},
	{Str: "\uFEAC", A: -1, B: 28, F: nil},
	{Str: "\uFEAD", A: -1, B: 29, F: nil},
	{Str: "\uFEAE", A: -1, B: 29, F: nil},
	{Str: "\uFEAF", A: -1, B: 30, F: nil},
	{Str: "\uFEB0", A: -1, B: 30, F: nil},
	{Str: "\uFEB1", A: -1, B: 31, F: nil},
	{Str: "\uFEB2", A: -1, B: 31, F: nil},
	{Str: "\uFEB3", A: -1, B: 31, F: nil},
	{Str: "\uFEB4", A: -1, B: 31, F: nil},
	{Str: "\uFEB5", A: -1, B: 32, F: nil},
	{Str: "\uFEB6", A: -1, B: 32, F: nil},
	{Str: "\uFEB7", A: -1, B: 32, F: nil},
	{Str: "\uFEB8", A: -1, B: 32, F: nil},
	{Str: "\uFEB9", A: -1, B: 33, F: nil},
	{Str: "\uFEBA", A: -1, B: 33, F: nil},
	{Str: "\uFEBB", A: -1, B: 33, F: nil},
	{Str: "\uFEBC", A: -1, B: 33, F: nil},
	{Str: "\uFEBD", A: -1, B: 34, F: nil},
	{Str: "\uFEBE", A: -1, B: 34, F: nil},
	{Str: "\uFEBF", A: -1, B: 34, F: nil},
	{Str: "\uFEC0", A: -1, B: 34, F: nil},
	{Str: "\uFEC1", A: -1, B: 35, F: nil},
	{Str: "\uFEC2", A: -1, B: 35, F: nil},
	{Str: "\uFEC3", A: -1, B: 35, F: nil},
	{Str: "\uFEC4", A: -1, B: 35, F: nil},
	{Str: "\uFEC5", A: -1, B: 36, F: nil},
	{Str: "\uFEC6", A: -1, B: 36, F: nil},
	{Str: "\uFEC7", A: -1, B: 36, F: nil},
	{Str: "\uFEC8", A: -1, B: 36, F: nil},
	{Str: "\uFEC9", A: -1, B: 37, F: nil},
	{Str: "\uFECA", A: -1, B: 37, F: nil},
	{Str: "\uFECB", A: -1, B: 37, F: nil},
	{Str: "\uFECC", A: -1, B: 37, F: nil},
	{Str: "\uFECD", A: -1, B: 38, F: nil},
	{Str: "\uFECE", A: -1, B: 38, F: nil},
	{Str: "\uFECF", A: -1, B: 38, F: nil},
	{Str: "\uFED0", A: -1, B: 38, F: nil},
	{Str: "\uFED1", A: -1, B: 39, F: nil},
	{Str: "\uFED2", A: -1, B: 39, F: nil},
	{Str: "\uFED3", A: -1, B: 39, F: nil},
	{Str: "\uFED4", A: -1, B: 39, F: nil},
	{Str: "\uFED5", A: -1, B: 40, F: nil},
	{Str: "\uFED6", A: -1, B: 40, F: nil},
	{Str: "\uFED7", A: -1, B: 40, F: nil},
	{Str: "\uFED8", A: -1, B: 40, F: nil},
	{Str: "\uFED9", A: -1, B: 41, F: nil},
	{Str: "\uFEDA", A: -1, B: 41, F: nil},
	{Str: "\uFEDB", A: -1, B: 41, F: nil},
	{Str: "\uFEDC", A: -1, B: 41, F: nil},
	{Str: "\uFEDD", A: -1, B: 42, F: nil},
	{Str: "\uFEDE", A: -1, B: 42, F: nil},
	{Str: "\uFEDF", A: -1, B: 42, F: nil},
	{Str: "\uFEE0", A: -1, B: 42, F: nil},
	{Str: "\uFEE1", A: -1, B: 43, F: nil},
	{Str: "\uFEE2", A: -1, B: 43, F: nil},
	{Str: "\uFEE3", A: -1, B: 43, F: nil},
	{Str: "\uFEE4", A: -1, B: 43, F: nil},
	{Str: "\uFEE5", A: -1, B: 44, F: nil},
	{Str: "\uFEE6", A: -1, B: 44, F: nil},
	{Str: "\uFEE7", A: -1, B: 44, F: nil},
	{Str: "\uFEE8", A: -1, B: 44, F: nil},
	{Str: "\uFEE9", A: -1, B: 45, F: nil},
	{Str: "\uFEEA", A: -1, B: 45, F: nil},
	{Str: "\uFEEB", A: -1, B: 45, F: nil},
	{Str: "\uFEEC", A: -1, B: 45, F: nil},
	{Str: "\uFEED", A: -1, B: 46, F: nil},
	{Str: "\uFEEE", A: -1, B: 46, F: nil},
	{Str: "\uFEEF", A: -1, B: 47, F: nil},
	{Str: "\uFEF0", A: -1, B: 47, F: nil},
	{Str: "\uFEF1", A: -1, B: 48, F: nil},
	{Str: "\uFEF2", A: -1, B: 48, F: nil},
	{Str: "\uFEF3", A: -1, B: 48, F: nil},
	{Str: "\uFEF4", A: -1, B: 48, F: nil},
	{Str: "\uFEF5", A: -1, B: 52, F: nil},
	{Str: "\uFEF6", A: -1, B: 52, F: nil},
	{Str: "\uFEF7", A: -1, B: 50, F: nil},
	{Str: "\uFEF8", A: -1, B: 50, F: nil},
	{Str: "\uFEF9", A: -1, B: 51, F: nil},
	{Str: "\uFEFA", A: -1, B: 51, F: nil},
	{Str: "\uFEFB", A: -1, B: 49, F: nil},
	{Str: "\uFEFC", A: -1, B: 49, F: nil},
}

var A_1 = []*snowballRuntime.Among{
	{Str: "\u0622", A: -1, B: 1, F: nil},
	{Str: "\u0623", A: -1, B: 1, F: nil},
	{Str: "\u0624", A: -1, B: 2, F: nil},
	{Str: "\u0625", A: -1, B: 1, F: nil},
	{Str: "\u0626", A: -1, B: 3, F: nil},
}

var A_2 = []*snowballRuntime.Among{
	{Str: "\u0622", A: -1, B: 1, F: nil},
	{Str: "\u0623", A: -1, B: 1, F: nil},
	{Str: "\u0624", A: -1, B: 2, F: nil},
	{Str: "\u0625", A: -1, B: 1, F: nil},
	{Str: "\u0626", A: -1, B: 3, F: nil},
}

var A_3 = []*snowballRuntime.Among{
	{Str: "\u0627\u0644", A: -1, B: 2, F: nil},
	{Str: "\u0628\u0627\u0644", A: -1, B: 1, F: nil},
	{Str: "\u0643\u0627\u0644", A: -1, B: 1, F: nil},
	{Str: "\u0644\u0644", A: -1, B: 2, F: nil},
}

var A_4 = []*snowballRuntime.Among{
	{Str: "\u0623\u0622", A: -1, B: 2, F: nil},
	{Str: "\u0623\u0623", A: -1, B: 1, F: nil},
	{Str: "\u0623\u0624", A: -1, B: 3, F: nil},
	{Str: "\u0623\u0625", A: -1, B: 5, F: nil},
	{Str: "\u0623\u0627", A: -1, B: 4, F: nil},
}

var A_5 = []*snowballRuntime.Among{
	{Str: "\u0641", A: -1, B: 1, F: nil},
	{Str: "\u0648", A: -1, B: 2, F: nil},
}

var A_6 = []*snowballRuntime.Among{
	{Str: "\u0627\u0644", A: -1, B: 2, F: nil},
	{Str: "\u0628\u0627\u0644", A: -1, B: 1, F: nil},
	{Str: "\u0643\u0627\u0644", A: -1, B: 1, F: nil},
	{Str: "\u0644\u0644", A: -1, B: 2, F: nil},
}

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

var A_8 = []*snowballRuntime.Among{
	{Str: "\u0633\u0623", A: -1, B: 4, F: nil},
	{Str: "\u0633\u062A", A: -1, B: 2, F: nil},
	{Str: "\u0633\u0646", A: -1, B: 3, F: nil},
	{Str: "\u0633\u064A", A: -1, B: 1, F: nil},
}

var A_9 = []*snowballRuntime.Among{
	{Str: "\u062A\u0633\u062A", A: -1, B: 1, F: nil},
	{Str: "\u0646\u0633\u062A", A: -1, B: 1, F: nil},
	{Str: "\u064A\u0633\u062A", A: -1, B: 1, F: nil},
}

var A_10 = []*snowballRuntime.Among{
	{Str: "\u0643", A: -1, B: 1, F: nil},
	{Str: "\u0643\u0645", A: -1, B: 2, F: nil},
	{Str: "\u0647\u0645", A: -1, B: 2, F: nil},
	{Str: "\u0647\u0646", A: -1, B: 2, F: nil},
	{Str: "\u0647", A: -1, B: 1, F: nil},
	{Str: "\u064A", A: -1, B: 1, F: nil},
	{Str: "\u0643\u0645\u0627", A: -1, B: 3, F: nil},
	{Str: "\u0647\u0645\u0627", A: -1, B: 3, F: nil},
	{Str: "\u0646\u0627", A: -1, B: 2, F: nil},
	{Str: "\u0647\u0627", A: -1, B: 2, F: nil},
}

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

var A_12 = []*snowballRuntime.Among{
	{Str: "\u0648", A: -1, B: 1, F: nil},
	{Str: "\u064A", A: -1, B: 1, F: nil},
	{Str: "\u0627", A: -1, B: 1, F: nil},
}

var A_13 = []*snowballRuntime.Among{
	{Str: "\u0627\u062A", A: -1, B: 1, F: nil},
}

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

var A_15 = []*snowballRuntime.Among{
	{Str: "\u0629", A: -1, B: 1, F: nil},
}

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

var A_17 = []*snowballRuntime.Among{
	{Str: "\u0643", A: -1, B: 1, F: nil},
	{Str: "\u0643\u0645", A: -1, B: 2, F: nil},
	{Str: "\u0647\u0645", A: -1, B: 2, F: nil},
	{Str: "\u0643\u0646", A: -1, B: 2, F: nil},
	{Str: "\u0647\u0646", A: -1, B: 2, F: nil},
	{Str: "\u0647", A: -1, B: 1, F: nil},
	{Str: "\u0643\u0645\u0648", A: -1, B: 3, F: nil},
	{Str: "\u0646\u064A", A: -1, B: 2, F: nil},
	{Str: "\u0643\u0645\u0627", A: -1, B: 3, F: nil},
	{Str: "\u0647\u0645\u0627", A: -1, B: 3, F: nil},
	{Str: "\u0646\u0627", A: -1, B: 2, F: nil},
	{Str: "\u0647\u0627", A: -1, B: 2, F: nil},
}

var A_18 = []*snowballRuntime.Among{
	{Str: "\u0646", A: -1, B: 2, F: nil},
	{Str: "\u0648\u0646", A: 0, B: 4, F: nil},
	{Str: "\u064A\u0646", A: 0, B: 4, F: nil},
	{Str: "\u0627\u0646", A: 0, B: 4, F: nil},
	{Str: "\u062A\u0646", A: 0, B: 3, F: nil},
	{Str: "\u064A", A: -1, B: 2, F: nil},
	{Str: "\u0627", A: -1, B: 2, F: nil},
	{Str: "\u062A\u0645\u0627", A: 6, B: 5, F: nil},
	{Str: "\u0646\u0627", A: 6, B: 3, F: nil},
	{Str: "\u062A\u0627", A: 6, B: 3, F: nil},
	{Str: "\u062A", A: -1, B: 1, F: nil},
}

var A_19 = []*snowballRuntime.Among{
	{Str: "\u062A\u0645", A: -1, B: 1, F: nil},
	{Str: "\u0648\u0627", A: -1, B: 1, F: nil},
}

var A_20 = []*snowballRuntime.Among{
	{Str: "\u0648", A: -1, B: 1, F: nil},
	{Str: "\u062A\u0645\u0648", A: 0, B: 2, F: nil},
}

var A_21 = []*snowballRuntime.Among{
	{Str: "\u0649", A: -1, B: 1, F: nil},
}

type Context struct {
	b_is_defined bool
	b_is_verb    bool
	b_is_noun    bool
	i_word_len   int
}

func r_Normalize_pre(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 251
	// loop, line 252
	for range make([]struct{}, snowballRuntime.RuneCountInString(env.Current())) {
		// (, line 252
		// or, line 316
	lab0:
		for {
			var v_2 = env.Cursor
		lab1:
			for {
				// (, line 253
				// [, line 254
				env.Bra = env.Cursor
				// substring, line 254
				among_var = env.FindAmong(A_0, context)
				if among_var == 0 {
					break lab1
				}
				// ], line 254
				env.Ket = env.Cursor
				if among_var == 0 {
					break lab1
				} else if among_var == 1 {
					// (, line 255
					// delete, line 255
					if !env.SliceDel() {
						return false
					}
				} else if among_var == 2 {
					// (, line 256
					// delete, line 256
					if !env.SliceDel() {
						return false
					}
				} else if among_var == 3 {
					// (, line 259
					// <-, line 259
					if !env.SliceFrom("0") {
						return false
					}
				} else if among_var == 4 {
					// (, line 260
					// <-, line 260
					if !env.SliceFrom("1") {
						return false
					}
				} else if among_var == 5 {
					// (, line 261
					// <-, line 261
					if !env.SliceFrom("2") {
						return false
					}
				} else if among_var == 6 {
					// (, line 262
					// <-, line 262
					if !env.SliceFrom("3") {
						return false
					}
				} else if among_var == 7 {
					// (, line 263
					// <-, line 263
					if !env.SliceFrom("4") {
						return false
					}
				} else if among_var == 8 {
					// (, line 264
					// <-, line 264
					if !env.SliceFrom("5") {
						return false
					}
				} else if among_var == 9 {
					// (, line 265
					// <-, line 265
					if !env.SliceFrom("6") {
						return false
					}
				} else if among_var == 10 {
					// (, line 266
					// <-, line 266
					if !env.SliceFrom("7") {
						return false
					}
				} else if among_var == 11 {
					// (, line 267
					// <-, line 267
					if !env.SliceFrom("8") {
						return false
					}
				} else if among_var == 12 {
					// (, line 268
					// <-, line 268
					if !env.SliceFrom("9") {
						return false
					}
				} else if among_var == 13 {
					// (, line 271
					// <-, line 271
					if !env.SliceFrom("\u0621") {
						return false
					}
				} else if among_var == 14 {
					// (, line 272
					// <-, line 272
					if !env.SliceFrom("\u0623") {
						return false
					}
				} else if among_var == 15 {
					// (, line 273
					// <-, line 273
					if !env.SliceFrom("\u0625") {
						return false
					}
				} else if among_var == 16 {
					// (, line 274
					// <-, line 274
					if !env.SliceFrom("\u0626") {
						return false
					}
				} else if among_var == 17 {
					// (, line 275
					// <-, line 275
					if !env.SliceFrom("\u0622") {
						return false
					}
				} else if among_var == 18 {
					// (, line 276
					// <-, line 276
					if !env.SliceFrom("\u0624") {
						return false
					}
				} else if among_var == 19 {
					// (, line 277
					// <-, line 277
					if !env.SliceFrom("\u0627") {
						return false
					}
				} else if among_var == 20 {
					// (, line 278
					// <-, line 278
					if !env.SliceFrom("\u0628") {
						return false
					}
				} else if among_var == 21 {
					// (, line 279
					// <-, line 279
					if !env.SliceFrom("\u0629") {
						return false
					}
				} else if among_var == 22 {
					// (, line 280
					// <-, line 280
					if !env.SliceFrom("\u062A") {
						return false
					}
				} else if among_var == 23 {
					// (, line 281
					// <-, line 281
					if !env.SliceFrom("\u062B") {
						return false
					}
				} else if among_var == 24 {
					// (, line 282
					// <-, line 282
					if !env.SliceFrom("\u062C") {
						return false
					}
				} else if among_var == 25 {
					// (, line 283
					// <-, line 283
					if !env.SliceFrom("\u062D") {
						return false
					}
				} else if among_var == 26 {
					// (, line 284
					// <-, line 284
					if !env.SliceFrom("\u062E") {
						return false
					}
				} else if among_var == 27 {
					// (, line 285
					// <-, line 285
					if !env.SliceFrom("\u062F") {
						return false
					}
				} else if among_var == 28 {
					// (, line 286
					// <-, line 286
					if !env.SliceFrom("\u0630") {
						return false
					}
				} else if among_var == 29 {
					// (, line 287
					// <-, line 287
					if !env.SliceFrom("\u0631") {
						return false
					}
				} else if among_var == 30 {
					// (, line 288
					// <-, line 288
					if !env.SliceFrom("\u0632") {
						return false
					}
				} else if among_var == 31 {
					// (, line 289
					// <-, line 289
					if !env.SliceFrom("\u0633") {
						return false
					}
				} else if among_var == 32 {
					// (, line 290
					// <-, line 290
					if !env.SliceFrom("\u0634") {
						return false
					}
				} else if among_var == 33 {
					// (, line 291
					// <-, line 291
					if !env.SliceFrom("\u0635") {
						return false
					}
				} else if among_var == 34 {
					// (, line 292
					// <-, line 292
					if !env.SliceFrom("\u0636") {
						return false
					}
				} else if among_var == 35 {
					// (, line 293
					// <-, line 293
					if !env.SliceFrom("\u0637") {
						return false
					}
				} else if among_var == 36 {
					// (, line 294
					// <-, line 294
					if !env.SliceFrom("\u0638") {
						return false
					}
				} else if among_var == 37 {
					// (, line 295
					// <-, line 295
					if !env.SliceFrom("\u0639") {
						return false
					}
				} else if among_var == 38 {
					// (, line 296
					// <-, line 296
					if !env.SliceFrom("\u063A") {
						return false
					}
				} else if among_var == 39 {
					// (, line 297
					// <-, line 297
					if !env.SliceFrom("\u0641") {
						return false
					}
				} else if among_var == 40 {
					// (, line 298
					// <-, line 298
					if !env.SliceFrom("\u0642") {
						return false
					}
				} else if among_var == 41 {
					// (, line 299
					// <-, line 299
					if !env.SliceFrom("\u0643") {
						return false
					}
				} else if among_var == 42 {
					// (, line 300
					// <-, line 300
					if !env.SliceFrom("\u0644") {
						return false
					}
				} else if among_var == 43 {
					// (, line 301
					// <-, line 301
					if !env.SliceFrom("\u0645") {
						return false
					}
				} else if among_var == 44 {
					// (, line 302
					// <-, line 302
					if !env.SliceFrom("\u0646") {
						return false
					}
				} else if among_var == 45 {
					// (, line 303
					// <-, line 303
					if !env.SliceFrom("\u0647") {
						return false
					}
				} else if among_var == 46 {
					// (, line 304
					// <-, line 304
					if !env.SliceFrom("\u0648") {
						return false
					}
				} else if among_var == 47 {
					// (, line 305
					// <-, line 305
					if !env.SliceFrom("\u0649") {
						return false
					}
				} else if among_var == 48 {
					// (, line 306
					// <-, line 306
					if !env.SliceFrom("\u064A") {
						return false
					}
				} else if among_var == 49 {
					// (, line 309
					// <-, line 309
					if !env.SliceFrom("\u0644\u0627") {
						return false
					}
				} else if among_var == 50 {
					// (, line 310
					// <-, line 310
					if !env.SliceFrom("\u0644\u0623") {
						return false
					}
				} else if among_var == 51 {
					// (, line 311
					// <-, line 311
					if !env.SliceFrom("\u0644\u0625") {
						return false
					}
				} else if among_var == 52 {
					// (, line 312
					// <-, line 312
					if !env.SliceFrom("\u0644\u0622") {
						return false
					}
				}
				break lab0
			}
			env.Cursor = v_2
			// next, line 317
			if env.Cursor >= env.Limit {
				return false
			}
			env.NextChar()
			break lab0
		}
	}
	return true
}

func r_Normalize_post(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 321
	// do, line 323
	var v_1 = env.Cursor
lab0:
	for {
		// (, line 323
		// backwards, line 325
		env.LimitBackward = env.Cursor
		env.Cursor = env.Limit
		// (, line 325
		// [, line 326
		env.Ket = env.Cursor
		// substring, line 326
		among_var = env.FindAmongB(A_1, context)
		if among_var == 0 {
			break lab0
		}
		// ], line 326
		env.Bra = env.Cursor
		if among_var == 0 {
			break lab0
		} else if among_var == 1 {
			// (, line 327
			// <-, line 327
			if !env.SliceFrom("\u0621") {
				return false
			}
		} else if among_var == 2 {
			// (, line 328
			// <-, line 328
			if !env.SliceFrom("\u0621") {
				return false
			}
		} else if among_var == 3 {
			// (, line 329
			// <-, line 329
			if !env.SliceFrom("\u0621") {
				return false
			}
		}
		env.Cursor = env.LimitBackward
		break lab0
	}
	env.Cursor = v_1
	// do, line 334
	var v_2 = env.Cursor
lab1:
	for {
		// loop, line 334
		for range make([]struct{}, context.i_word_len) {
			// (, line 334
			// or, line 343
		lab2:
			for {
				var v_4 = env.Cursor
			lab3:
				for {
					// (, line 335
					// [, line 337
					env.Bra = env.Cursor
					// substring, line 337
					among_var = env.FindAmong(A_2, context)
					if among_var == 0 {
						break lab3
					}
					// ], line 337
					env.Ket = env.Cursor
					if among_var == 0 {
						break lab3
					} else if among_var == 1 {
						// (, line 338
						// <-, line 338
						if !env.SliceFrom("\u0627") {
							return false
						}
					} else if among_var == 2 {
						// (, line 339
						// <-, line 339
						if !env.SliceFrom("\u0648") {
							return false
						}
					} else if among_var == 3 {
						// (, line 340
						// <-, line 340
						if !env.SliceFrom("\u064A") {
							return false
						}
					}
					break lab2
				}
				env.Cursor = v_4
				// next, line 344
				if env.Cursor >= env.Limit {
					break lab1
				}
				env.NextChar()
				break lab2
			}
		}
		break lab1
	}
	env.Cursor = v_2
	return true
}

func r_Checks1(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 349
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 351
	env.Bra = env.Cursor
	// substring, line 351
	among_var = env.FindAmong(A_3, context)
	if among_var == 0 {
		return false
	}
	// ], line 351
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 352
		if !(context.i_word_len > 4) {
			return false
		}
		// set is_noun, line 352
		context.b_is_noun = true
		// unset is_verb, line 352
		context.b_is_verb = false
		// set is_defined, line 352
		context.b_is_defined = true
	} else if among_var == 2 {
		// (, line 353
		if !(context.i_word_len > 3) {
			return false
		}
		// set is_noun, line 353
		context.b_is_noun = true
		// unset is_verb, line 353
		context.b_is_verb = false
		// set is_defined, line 353
		context.b_is_defined = true
	}
	return true
}

func r_Prefix_Step1(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 359
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 361
	env.Bra = env.Cursor
	// substring, line 361
	among_var = env.FindAmong(A_4, context)
	if among_var == 0 {
		return false
	}
	// ], line 361
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 362
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 362
		if !env.SliceFrom("\u0623") {
			return false
		}
	} else if among_var == 2 {
		// (, line 363
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 363
		if !env.SliceFrom("\u0622") {
			return false
		}
	} else if among_var == 3 {
		// (, line 364
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 364
		if !env.SliceFrom("\u0623") {
			return false
		}
	} else if among_var == 4 {
		// (, line 365
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 365
		if !env.SliceFrom("\u0627") {
			return false
		}
	} else if among_var == 5 {
		// (, line 366
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 366
		if !env.SliceFrom("\u0625") {
			return false
		}
	}
	return true
}

func r_Prefix_Step2(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 371
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// not, line 373
	var v_1 = env.Cursor
lab0:
	for {
		// literal, line 373
		if !env.EqS("\u0641\u0627") {
			break lab0
		}
		return false
	}
	env.Cursor = v_1
	// not, line 374
	var v_2 = env.Cursor
lab1:
	for {
		// literal, line 374
		if !env.EqS("\u0648\u0627") {
			break lab1
		}
		return false
	}
	env.Cursor = v_2
	// [, line 375
	env.Bra = env.Cursor
	// substring, line 375
	among_var = env.FindAmong(A_5, context)
	if among_var == 0 {
		return false
	}
	// ], line 375
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 376
		if !(context.i_word_len > 3) {
			return false
		}
		// delete, line 376
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 377
		if !(context.i_word_len > 3) {
			return false
		}
		// delete, line 377
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Prefix_Step3a_Noun(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 381
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 383
	env.Bra = env.Cursor
	// substring, line 383
	among_var = env.FindAmong(A_6, context)
	if among_var == 0 {
		return false
	}
	// ], line 383
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 384
		if !(context.i_word_len > 5) {
			return false
		}
		// delete, line 384
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 385
		if !(context.i_word_len > 4) {
			return false
		}
		// delete, line 385
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Prefix_Step3b_Noun(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 389
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// not, line 391
	var v_1 = env.Cursor
lab0:
	for {
		// literal, line 391
		if !env.EqS("\u0628\u0627") {
			break lab0
		}
		return false
	}
	env.Cursor = v_1
	// [, line 392
	env.Bra = env.Cursor
	// substring, line 392
	among_var = env.FindAmong(A_7, context)
	if among_var == 0 {
		return false
	}
	// ], line 392
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 393
		if !(context.i_word_len > 3) {
			return false
		}
		// delete, line 393
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 395
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 395
		if !env.SliceFrom("\u0628") {
			return false
		}
	} else if among_var == 3 {
		// (, line 396
		if !(context.i_word_len > 3) {
			return false
		}
		// <-, line 396
		if !env.SliceFrom("\u0643") {
			return false
		}
	}
	return true
}

func r_Prefix_Step3_Verb(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 401
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 403
	env.Bra = env.Cursor
	// substring, line 403
	among_var = env.FindAmong(A_8, context)
	if among_var == 0 {
		return false
	}
	// ], line 403
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 405
		if !(context.i_word_len > 4) {
			return false
		}
		// <-, line 405
		if !env.SliceFrom("\u064A") {
			return false
		}
	} else if among_var == 2 {
		// (, line 406
		if !(context.i_word_len > 4) {
			return false
		}
		// <-, line 406
		if !env.SliceFrom("\u062A") {
			return false
		}
	} else if among_var == 3 {
		// (, line 407
		if !(context.i_word_len > 4) {
			return false
		}
		// <-, line 407
		if !env.SliceFrom("\u0646") {
			return false
		}
	} else if among_var == 4 {
		// (, line 408
		if !(context.i_word_len > 4) {
			return false
		}
		// <-, line 408
		if !env.SliceFrom("\u0623") {
			return false
		}
	}
	return true
}

func r_Prefix_Step4_Verb(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 412
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 414
	env.Bra = env.Cursor
	// substring, line 414
	among_var = env.FindAmong(A_9, context)
	if among_var == 0 {
		return false
	}
	// ], line 414
	env.Ket = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 415
		if !(context.i_word_len > 4) {
			return false
		}
		// set is_verb, line 415
		context.b_is_verb = true
		// unset is_noun, line 415
		context.b_is_noun = false
		// <-, line 415
		if !env.SliceFrom("\u0627\u0633\u062A") {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step1a(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 422
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 424
	env.Ket = env.Cursor
	// substring, line 424
	among_var = env.FindAmongB(A_10, context)
	if among_var == 0 {
		return false
	}
	// ], line 424
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 425
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 425
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 426
		if !(context.i_word_len >= 5) {
			return false
		}
		// delete, line 426
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 3 {
		// (, line 427
		if !(context.i_word_len >= 6) {
			return false
		}
		// delete, line 427
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step1b(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 430
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 432
	env.Ket = env.Cursor
	// substring, line 432
	among_var = env.FindAmongB(A_11, context)
	if among_var == 0 {
		return false
	}
	// ], line 432
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 433
		if !(context.i_word_len > 5) {
			return false
		}
		// delete, line 433
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step2a(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 437
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 439
	env.Ket = env.Cursor
	// substring, line 439
	among_var = env.FindAmongB(A_12, context)
	if among_var == 0 {
		return false
	}
	// ], line 439
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 440
		if !(context.i_word_len > 4) {
			return false
		}
		// delete, line 440
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step2b(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 444
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 446
	env.Ket = env.Cursor
	// substring, line 446
	among_var = env.FindAmongB(A_13, context)
	if among_var == 0 {
		return false
	}
	// ], line 446
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 447
		if !(context.i_word_len >= 5) {
			return false
		}
		// delete, line 447
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step2c1(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 451
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 453
	env.Ket = env.Cursor
	// substring, line 453
	among_var = env.FindAmongB(A_14, context)
	if among_var == 0 {
		return false
	}
	// ], line 453
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 454
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 454
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step2c2(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 457
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 459
	env.Ket = env.Cursor
	// substring, line 459
	among_var = env.FindAmongB(A_15, context)
	if among_var == 0 {
		return false
	}
	// ], line 459
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 460
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 460
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Noun_Step3(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 463
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 465
	env.Ket = env.Cursor
	// substring, line 465
	among_var = env.FindAmongB(A_16, context)
	if among_var == 0 {
		return false
	}
	// ], line 465
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 466
		if !(context.i_word_len >= 3) {
			return false
		}
		// delete, line 466
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Verb_Step1(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 470
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 472
	env.Ket = env.Cursor
	// substring, line 472
	among_var = env.FindAmongB(A_17, context)
	if among_var == 0 {
		return false
	}
	// ], line 472
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 473
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 473
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 474
		if !(context.i_word_len >= 5) {
			return false
		}
		// delete, line 474
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 3 {
		// (, line 475
		if !(context.i_word_len >= 6) {
			return false
		}
		// delete, line 475
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Verb_Step2a(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 478
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 480
	env.Ket = env.Cursor
	// substring, line 480
	among_var = env.FindAmongB(A_18, context)
	if among_var == 0 {
		return false
	}
	// ], line 480
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 481
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 481
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 482
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 482
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 3 {
		// (, line 483
		if !(context.i_word_len >= 5) {
			return false
		}
		// delete, line 483
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 4 {
		// (, line 484
		if !(context.i_word_len > 5) {
			return false
		}
		// delete, line 484
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 5 {
		// (, line 485
		if !(context.i_word_len >= 6) {
			return false
		}
		// delete, line 485
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Verb_Step2b(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 489
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 491
	env.Ket = env.Cursor
	// substring, line 491
	among_var = env.FindAmongB(A_19, context)
	if among_var == 0 {
		return false
	}
	// ], line 491
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 492
		if !(context.i_word_len >= 5) {
			return false
		}
		// delete, line 492
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_Verb_Step2c(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 497
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 499
	env.Ket = env.Cursor
	// substring, line 499
	among_var = env.FindAmongB(A_20, context)
	if among_var == 0 {
		return false
	}
	// ], line 499
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 500
		if !(context.i_word_len >= 4) {
			return false
		}
		// delete, line 500
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 501
		if !(context.i_word_len >= 6) {
			return false
		}
		// delete, line 501
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_Suffix_All_alef_maqsura(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 505
	context.i_word_len = snowballRuntime.RuneCountInString(env.Current())
	// [, line 507
	env.Ket = env.Cursor
	// substring, line 507
	among_var = env.FindAmongB(A_21, context)
	if among_var == 0 {
		return false
	}
	// ], line 507
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 508
		// <-, line 508
		if !env.SliceFrom("\u064A") {
			return false
		}
	}
	return true
}

func Stem(env *snowballRuntime.Env) bool {
	var context = &Context{
		b_is_defined: false,
		b_is_verb:    false,
		b_is_noun:    false,
		i_word_len:   0,
	}
	_ = context
	// (, line 515
	// set is_noun, line 517
	context.b_is_noun = true
	// set is_verb, line 518
	context.b_is_verb = true
	// unset is_defined, line 519
	context.b_is_defined = false
	// do, line 522
	var v_1 = env.Cursor
lab0:
	for {
		// call Checks1, line 522
		if !r_Checks1(env, context) {
			break lab0
		}
		break lab0
	}
	env.Cursor = v_1
	// do, line 525
	var v_2 = env.Cursor
lab1:
	for {
		// call Normalize_pre, line 525
		if !r_Normalize_pre(env, context) {
			break lab1
		}
		break lab1
	}
	env.Cursor = v_2
	// backwards, line 528
	env.LimitBackward = env.Cursor
	env.Cursor = env.Limit
	// (, line 528
	// do, line 530
	var v_3 = env.Limit - env.Cursor
lab2:
	for {
		// (, line 530
		// or, line 544
	lab3:
		for {
			var v_4 = env.Limit - env.Cursor
		lab4:
			for {
				// (, line 532
				// Boolean test is_verb, line 533
				if !context.b_is_verb {
					break lab4
				}
				// (, line 534
				// or, line 539
			lab5:
				for {
					var v_5 = env.Limit - env.Cursor
				lab6:
					for {
						// (, line 535
						// (, line 536
						// atleast, line 536
						var v_6 = 1
						// atleast, line 536
					replab7:
						for {
							var v_7 = env.Limit - env.Cursor
						lab8:
							for range [2]struct{}{} {
								// call Suffix_Verb_Step1, line 536
								if !r_Suffix_Verb_Step1(env, context) {
									break lab8
								}
								v_6--
								continue replab7
							}
							env.Cursor = env.Limit - v_7
							break replab7
						}
						if v_6 > 0 {
							break lab6
						}
						// (, line 537
						// or, line 537
					lab9:
						for {
							var v_8 = env.Limit - env.Cursor
						lab10:
							for {
								// call Suffix_Verb_Step2a, line 537
								if !r_Suffix_Verb_Step2a(env, context) {
									break lab10
								}
								break lab9
							}
							env.Cursor = env.Limit - v_8
						lab11:
							for {
								// call Suffix_Verb_Step2c, line 537
								if !r_Suffix_Verb_Step2c(env, context) {
									break lab11
								}
								break lab9
							}
							env.Cursor = env.Limit - v_8
							// next, line 537
							if env.Cursor <= env.LimitBackward {
								break lab6
							}
							env.PrevChar()
							break lab9
						}
						break lab5
					}
					env.Cursor = env.Limit - v_5
				lab12:
					for {
						// call Suffix_Verb_Step2b, line 539
						if !r_Suffix_Verb_Step2b(env, context) {
							break lab12
						}
						break lab5
					}
					env.Cursor = env.Limit - v_5
					// call Suffix_Verb_Step2a, line 540
					if !r_Suffix_Verb_Step2a(env, context) {
						break lab4
					}
					break lab5
				}
				break lab3
			}
			env.Cursor = env.Limit - v_4
		lab13:
			for {
				// (, line 544
				// Boolean test is_noun, line 545
				if !context.b_is_noun {
					break lab13
				}
				// (, line 546
				// try, line 548
				var v_9 = env.Limit - env.Cursor
			lab14:
				for {
					// (, line 548
					// or, line 550
				lab15:
					for {
						var v_10 = env.Limit - env.Cursor
					lab16:
						for {
							// call Suffix_Noun_Step2c2, line 549
							if !r_Suffix_Noun_Step2c2(env, context) {
								break lab16
							}
							break lab15
						}
						env.Cursor = env.Limit - v_10
					lab17:
						for {
							// (, line 550
							// not, line 550
						lab18:
							for {
								// Boolean test is_defined, line 550
								if !context.b_is_defined {
									break lab18
								}
								break lab17
							}
							// call Suffix_Noun_Step1a, line 550
							if !r_Suffix_Noun_Step1a(env, context) {
								break lab17
							}
							// (, line 550
							// or, line 552
						lab19:
							for {
								var v_12 = env.Limit - env.Cursor
							lab20:
								for {
									// call Suffix_Noun_Step2a, line 551
									if !r_Suffix_Noun_Step2a(env, context) {
										break lab20
									}
									break lab19
								}
								env.Cursor = env.Limit - v_12
							lab21:
								for {
									// call Suffix_Noun_Step2b, line 552
									if !r_Suffix_Noun_Step2b(env, context) {
										break lab21
									}
									break lab19
								}
								env.Cursor = env.Limit - v_12
							lab22:
								for {
									// call Suffix_Noun_Step2c1, line 553
									if !r_Suffix_Noun_Step2c1(env, context) {
										break lab22
									}
									break lab19
								}
								env.Cursor = env.Limit - v_12
								// next, line 554
								if env.Cursor <= env.LimitBackward {
									break lab17
								}
								env.PrevChar()
								break lab19
							}
							break lab15
						}
						env.Cursor = env.Limit - v_10
					lab23:
						for {
							// (, line 555
							// call Suffix_Noun_Step1b, line 555
							if !r_Suffix_Noun_Step1b(env, context) {
								break lab23
							}
							// (, line 555
							// or, line 557
						lab24:
							for {
								var v_13 = env.Limit - env.Cursor
							lab25:
								for {
									// call Suffix_Noun_Step2a, line 556
									if !r_Suffix_Noun_Step2a(env, context) {
										break lab25
									}
									break lab24
								}
								env.Cursor = env.Limit - v_13
							lab26:
								for {
									// call Suffix_Noun_Step2b, line 557
									if !r_Suffix_Noun_Step2b(env, context) {
										break lab26
									}
									break lab24
								}
								env.Cursor = env.Limit - v_13
								// call Suffix_Noun_Step2c1, line 558
								if !r_Suffix_Noun_Step2c1(env, context) {
									break lab23
								}
								break lab24
							}
							break lab15
						}
						env.Cursor = env.Limit - v_10
					lab27:
						for {
							// (, line 559
							// not, line 559
						lab28:
							for {
								// Boolean test is_defined, line 559
								if !context.b_is_defined {
									break lab28
								}
								break lab27
							}
							// call Suffix_Noun_Step2a, line 559
							if !r_Suffix_Noun_Step2a(env, context) {
								break lab27
							}
							break lab15
						}
						env.Cursor = env.Limit - v_10
						// (, line 560
						// call Suffix_Noun_Step2b, line 560
						if !r_Suffix_Noun_Step2b(env, context) {
							env.Cursor = env.Limit - v_9
							break lab14
						}
						break lab15
					}
					break lab14
				}
				// call Suffix_Noun_Step3, line 562
				if !r_Suffix_Noun_Step3(env, context) {
					break lab13
				}
				break lab3
			}
			env.Cursor = env.Limit - v_4
			// call Suffix_All_alef_maqsura, line 568
			if !r_Suffix_All_alef_maqsura(env, context) {
				break lab2
			}
			break lab3
		}
		break lab2
	}
	env.Cursor = env.Limit - v_3
	env.Cursor = env.LimitBackward
	// do, line 573
	var v_15 = env.Cursor
lab29:
	for {
		// (, line 573
		// try, line 574
		var v_16 = env.Cursor
	lab30:
		for {
			// call Prefix_Step1, line 574
			if !r_Prefix_Step1(env, context) {
				env.Cursor = v_16
				break lab30
			}
			break lab30
		}
		// try, line 575
		var v_17 = env.Cursor
	lab31:
		for {
			// call Prefix_Step2, line 575
			if !r_Prefix_Step2(env, context) {
				env.Cursor = v_17
				break lab31
			}
			break lab31
		}
		// (, line 576
		// or, line 577
	lab32:
		for {
			var v_18 = env.Cursor
		lab33:
			for {
				// call Prefix_Step3a_Noun, line 576
				if !r_Prefix_Step3a_Noun(env, context) {
					break lab33
				}
				break lab32
			}
			env.Cursor = v_18
		lab34:
			for {
				// (, line 577
				// Boolean test is_noun, line 577
				if !context.b_is_noun {
					break lab34
				}
				// call Prefix_Step3b_Noun, line 577
				if !r_Prefix_Step3b_Noun(env, context) {
					break lab34
				}
				break lab32
			}
			env.Cursor = v_18
			// (, line 578
			// Boolean test is_verb, line 578
			if !context.b_is_verb {
				break lab29
			}
			// try, line 578
			var v_19 = env.Cursor
		lab35:
			for {
				// call Prefix_Step3_Verb, line 578
				if !r_Prefix_Step3_Verb(env, context) {
					env.Cursor = v_19
					break lab35
				}
				break lab35
			}
			// call Prefix_Step4_Verb, line 578
			if !r_Prefix_Step4_Verb(env, context) {
				break lab29
			}
			break lab32
		}
		break lab29
	}
	env.Cursor = v_15
	// do, line 583
	var v_20 = env.Cursor
lab36:
	for {
		// call Normalize_post, line 583
		if !r_Normalize_post(env, context) {
			break lab36
		}
		break lab36
	}
	env.Cursor = v_20
	return true
}