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

package russian

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

var A_0 = []*snowballRuntime.Among{
	{Str: "\u0432\u0448\u0438\u0441\u044C", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0432\u0448\u0438\u0441\u044C", A: 0, B: 2, F: nil},
	{Str: "\u0438\u0432\u0448\u0438\u0441\u044C", A: 0, B: 2, F: nil},
	{Str: "\u0432", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0432", A: 3, B: 2, F: nil},
	{Str: "\u0438\u0432", A: 3, B: 2, F: nil},
	{Str: "\u0432\u0448\u0438", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0432\u0448\u0438", A: 6, B: 2, F: nil},
	{Str: "\u0438\u0432\u0448\u0438", A: 6, B: 2, F: nil},
}

var A_1 = []*snowballRuntime.Among{
	{Str: "\u0435\u043C\u0443", A: -1, B: 1, F: nil},
	{Str: "\u043E\u043C\u0443", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0445", A: -1, B: 1, F: nil},
	{Str: "\u0438\u0445", A: -1, B: 1, F: nil},
	{Str: "\u0443\u044E", A: -1, B: 1, F: nil},
	{Str: "\u044E\u044E", A: -1, B: 1, F: nil},
	{Str: "\u0435\u044E", A: -1, B: 1, F: nil},
	{Str: "\u043E\u044E", A: -1, B: 1, F: nil},
	{Str: "\u044F\u044F", A: -1, B: 1, F: nil},
	{Str: "\u0430\u044F", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0435", A: -1, B: 1, F: nil},
	{Str: "\u0435\u0435", A: -1, B: 1, F: nil},
	{Str: "\u0438\u0435", A: -1, B: 1, F: nil},
	{Str: "\u043E\u0435", A: -1, B: 1, F: nil},
	{Str: "\u044B\u043C\u0438", A: -1, B: 1, F: nil},
	{Str: "\u0438\u043C\u0438", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0439", A: -1, B: 1, F: nil},
	{Str: "\u0435\u0439", A: -1, B: 1, F: nil},
	{Str: "\u0438\u0439", A: -1, B: 1, F: nil},
	{Str: "\u043E\u0439", A: -1, B: 1, F: nil},
	{Str: "\u044B\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0435\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0438\u043C", A: -1, B: 1, F: nil},
	{Str: "\u043E\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0435\u0433\u043E", A: -1, B: 1, F: nil},
	{Str: "\u043E\u0433\u043E", A: -1, B: 1, F: nil},
}

var A_2 = []*snowballRuntime.Among{
	{Str: "\u0432\u0448", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0432\u0448", A: 0, B: 2, F: nil},
	{Str: "\u0438\u0432\u0448", A: 0, B: 2, F: nil},
	{Str: "\u0449", A: -1, B: 1, F: nil},
	{Str: "\u044E\u0449", A: 3, B: 1, F: nil},
	{Str: "\u0443\u044E\u0449", A: 4, B: 2, F: nil},
	{Str: "\u0435\u043C", A: -1, B: 1, F: nil},
	{Str: "\u043D\u043D", A: -1, B: 1, F: nil},
}

var A_3 = []*snowballRuntime.Among{
	{Str: "\u0441\u044C", A: -1, B: 1, F: nil},
	{Str: "\u0441\u044F", A: -1, B: 1, F: nil},
}

var A_4 = []*snowballRuntime.Among{
	{Str: "\u044B\u0442", A: -1, B: 2, F: nil},
	{Str: "\u044E\u0442", A: -1, B: 1, F: nil},
	{Str: "\u0443\u044E\u0442", A: 1, B: 2, F: nil},
	{Str: "\u044F\u0442", A: -1, B: 2, F: nil},
	{Str: "\u0435\u0442", A: -1, B: 1, F: nil},
	{Str: "\u0443\u0435\u0442", A: 4, B: 2, F: nil},
	{Str: "\u0438\u0442", A: -1, B: 2, F: nil},
	{Str: "\u043D\u044B", A: -1, B: 1, F: nil},
	{Str: "\u0435\u043D\u044B", A: 7, B: 2, F: nil},
	{Str: "\u0442\u044C", A: -1, B: 1, F: nil},
	{Str: "\u044B\u0442\u044C", A: 9, B: 2, F: nil},
	{Str: "\u0438\u0442\u044C", A: 9, B: 2, F: nil},
	{Str: "\u0435\u0448\u044C", A: -1, B: 1, F: nil},
	{Str: "\u0438\u0448\u044C", A: -1, B: 2, F: nil},
	{Str: "\u044E", A: -1, B: 2, F: nil},
	{Str: "\u0443\u044E", A: 14, B: 2, F: nil},
	{Str: "\u043B\u0430", A: -1, B: 1, F: nil},
	{Str: "\u044B\u043B\u0430", A: 16, B: 2, F: nil},
	{Str: "\u0438\u043B\u0430", A: 16, B: 2, F: nil},
	{Str: "\u043D\u0430", A: -1, B: 1, F: nil},
	{Str: "\u0435\u043D\u0430", A: 19, B: 2, F: nil},
	{Str: "\u0435\u0442\u0435", A: -1, B: 1, F: nil},
	{Str: "\u0438\u0442\u0435", A: -1, B: 2, F: nil},
	{Str: "\u0439\u0442\u0435", A: -1, B: 1, F: nil},
	{Str: "\u0443\u0439\u0442\u0435", A: 23, B: 2, F: nil},
	{Str: "\u0435\u0439\u0442\u0435", A: 23, B: 2, F: nil},
	{Str: "\u043B\u0438", A: -1, B: 1, F: nil},
	{Str: "\u044B\u043B\u0438", A: 26, B: 2, F: nil},
	{Str: "\u0438\u043B\u0438", A: 26, B: 2, F: nil},
	{Str: "\u0439", A: -1, B: 1, F: nil},
	{Str: "\u0443\u0439", A: 29, B: 2, F: nil},
	{Str: "\u0435\u0439", A: 29, B: 2, F: nil},
	{Str: "\u043B", A: -1, B: 1, F: nil},
	{Str: "\u044B\u043B", A: 32, B: 2, F: nil},
	{Str: "\u0438\u043B", A: 32, B: 2, F: nil},
	{Str: "\u044B\u043C", A: -1, B: 2, F: nil},
	{Str: "\u0435\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0438\u043C", A: -1, B: 2, F: nil},
	{Str: "\u043D", A: -1, B: 1, F: nil},
	{Str: "\u0435\u043D", A: 38, B: 2, F: nil},
	{Str: "\u043B\u043E", A: -1, B: 1, F: nil},
	{Str: "\u044B\u043B\u043E", A: 40, B: 2, F: nil},
	{Str: "\u0438\u043B\u043E", A: 40, B: 2, F: nil},
	{Str: "\u043D\u043E", A: -1, B: 1, F: nil},
	{Str: "\u0435\u043D\u043E", A: 43, B: 2, F: nil},
	{Str: "\u043D\u043D\u043E", A: 43, B: 1, F: nil},
}

var A_5 = []*snowballRuntime.Among{
	{Str: "\u0443", A: -1, B: 1, F: nil},
	{Str: "\u044F\u0445", A: -1, B: 1, F: nil},
	{Str: "\u0438\u044F\u0445", A: 1, B: 1, F: nil},
	{Str: "\u0430\u0445", A: -1, B: 1, F: nil},
	{Str: "\u044B", A: -1, B: 1, F: nil},
	{Str: "\u044C", A: -1, B: 1, F: nil},
	{Str: "\u044E", A: -1, B: 1, F: nil},
	{Str: "\u044C\u044E", A: 6, B: 1, F: nil},
	{Str: "\u0438\u044E", A: 6, B: 1, F: nil},
	{Str: "\u044F", A: -1, B: 1, F: nil},
	{Str: "\u044C\u044F", A: 9, B: 1, F: nil},
	{Str: "\u0438\u044F", A: 9, B: 1, F: nil},
	{Str: "\u0430", A: -1, B: 1, F: nil},
	{Str: "\u0435\u0432", A: -1, B: 1, F: nil},
	{Str: "\u043E\u0432", A: -1, B: 1, F: nil},
	{Str: "\u0435", A: -1, B: 1, F: nil},
	{Str: "\u044C\u0435", A: 15, B: 1, F: nil},
	{Str: "\u0438\u0435", A: 15, B: 1, F: nil},
	{Str: "\u0438", A: -1, B: 1, F: nil},
	{Str: "\u0435\u0438", A: 18, B: 1, F: nil},
	{Str: "\u0438\u0438", A: 18, B: 1, F: nil},
	{Str: "\u044F\u043C\u0438", A: 18, B: 1, F: nil},
	{Str: "\u0438\u044F\u043C\u0438", A: 21, B: 1, F: nil},
	{Str: "\u0430\u043C\u0438", A: 18, B: 1, F: nil},
	{Str: "\u0439", A: -1, B: 1, F: nil},
	{Str: "\u0435\u0439", A: 24, B: 1, F: nil},
	{Str: "\u0438\u0435\u0439", A: 25, B: 1, F: nil},
	{Str: "\u0438\u0439", A: 24, B: 1, F: nil},
	{Str: "\u043E\u0439", A: 24, B: 1, F: nil},
	{Str: "\u044F\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0438\u044F\u043C", A: 29, B: 1, F: nil},
	{Str: "\u0430\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0435\u043C", A: -1, B: 1, F: nil},
	{Str: "\u0438\u0435\u043C", A: 32, B: 1, F: nil},
	{Str: "\u043E\u043C", A: -1, B: 1, F: nil},
	{Str: "\u043E", A: -1, B: 1, F: nil},
}

var A_6 = []*snowballRuntime.Among{
	{Str: "\u043E\u0441\u0442", A: -1, B: 1, F: nil},
	{Str: "\u043E\u0441\u0442\u044C", A: -1, B: 1, F: nil},
}

var A_7 = []*snowballRuntime.Among{
	{Str: "\u0435\u0439\u0448", A: -1, B: 1, F: nil},
	{Str: "\u044C", A: -1, B: 3, F: nil},
	{Str: "\u0435\u0439\u0448\u0435", A: -1, B: 1, F: nil},
	{Str: "\u043D", A: -1, B: 2, F: nil},
}

var G_v = []byte{33, 65, 8, 232}

type Context struct {
	i_p2 int
	i_pV int
}

func r_mark_regions(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	// (, line 57
	context.i_pV = env.Limit
	context.i_p2 = env.Limit
	// do, line 61
	var v_1 = env.Cursor
lab0:
	for {
		// (, line 61
		// gopast, line 62
	golab1:
		for {
		lab2:
			for {
				if !env.InGrouping(G_v, 1072, 1103) {
					break lab2
				}
				break golab1
			}
			if env.Cursor >= env.Limit {
				break lab0
			}
			env.NextChar()
		}
		// setmark pV, line 62
		context.i_pV = env.Cursor
		// gopast, line 62
	golab3:
		for {
		lab4:
			for {
				if !env.OutGrouping(G_v, 1072, 1103) {
					break lab4
				}
				break golab3
			}
			if env.Cursor >= env.Limit {
				break lab0
			}
			env.NextChar()
		}
		// gopast, line 63
	golab5:
		for {
		lab6:
			for {
				if !env.InGrouping(G_v, 1072, 1103) {
					break lab6
				}
				break golab5
			}
			if env.Cursor >= env.Limit {
				break lab0
			}
			env.NextChar()
		}
		// gopast, line 63
	golab7:
		for {
		lab8:
			for {
				if !env.OutGrouping(G_v, 1072, 1103) {
					break lab8
				}
				break golab7
			}
			if env.Cursor >= env.Limit {
				break lab0
			}
			env.NextChar()
		}
		// setmark p2, line 63
		context.i_p2 = env.Cursor
		break lab0
	}
	env.Cursor = v_1
	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_perfective_gerund(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 71
	// [, line 72
	env.Ket = env.Cursor
	// substring, line 72
	among_var = env.FindAmongB(A_0, context)
	if among_var == 0 {
		return false
	}
	// ], line 72
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 76
		// or, line 76
	lab0:
		for {
			var v_1 = env.Limit - env.Cursor
		lab1:
			for {
				// literal, line 76
				if !env.EqSB("\u0430") {
					break lab1
				}
				break lab0
			}
			env.Cursor = env.Limit - v_1
			// literal, line 76
			if !env.EqSB("\u044F") {
				return false
			}
			break lab0
		}
		// delete, line 76
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 83
		// delete, line 83
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_adjective(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 87
	// [, line 88
	env.Ket = env.Cursor
	// substring, line 88
	among_var = env.FindAmongB(A_1, context)
	if among_var == 0 {
		return false
	}
	// ], line 88
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 97
		// delete, line 97
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_adjectival(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 101
	// call adjective, line 102
	if !r_adjective(env, context) {
		return false
	}
	// try, line 109
	var v_1 = env.Limit - env.Cursor
lab0:
	for {
		// (, line 109
		// [, line 110
		env.Ket = env.Cursor
		// substring, line 110
		among_var = env.FindAmongB(A_2, context)
		if among_var == 0 {
			env.Cursor = env.Limit - v_1
			break lab0
		}
		// ], line 110
		env.Bra = env.Cursor
		if among_var == 0 {
			env.Cursor = env.Limit - v_1
			break lab0
		} else if among_var == 1 {
			// (, line 115
			// or, line 115
		lab1:
			for {
				var v_2 = env.Limit - env.Cursor
			lab2:
				for {
					// literal, line 115
					if !env.EqSB("\u0430") {
						break lab2
					}
					break lab1
				}
				env.Cursor = env.Limit - v_2
				// literal, line 115
				if !env.EqSB("\u044F") {
					env.Cursor = env.Limit - v_1
					break lab0
				}
				break lab1
			}
			// delete, line 115
			if !env.SliceDel() {
				return false
			}
		} else if among_var == 2 {
			// (, line 122
			// delete, line 122
			if !env.SliceDel() {
				return false
			}
		}
		break lab0
	}
	return true
}

func r_reflexive(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 128
	// [, line 129
	env.Ket = env.Cursor
	// substring, line 129
	among_var = env.FindAmongB(A_3, context)
	if among_var == 0 {
		return false
	}
	// ], line 129
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 132
		// delete, line 132
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_verb(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 136
	// [, line 137
	env.Ket = env.Cursor
	// substring, line 137
	among_var = env.FindAmongB(A_4, context)
	if among_var == 0 {
		return false
	}
	// ], line 137
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 143
		// or, line 143
	lab0:
		for {
			var v_1 = env.Limit - env.Cursor
		lab1:
			for {
				// literal, line 143
				if !env.EqSB("\u0430") {
					break lab1
				}
				break lab0
			}
			env.Cursor = env.Limit - v_1
			// literal, line 143
			if !env.EqSB("\u044F") {
				return false
			}
			break lab0
		}
		// delete, line 143
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 151
		// delete, line 151
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_noun(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 159
	// [, line 160
	env.Ket = env.Cursor
	// substring, line 160
	among_var = env.FindAmongB(A_5, context)
	if among_var == 0 {
		return false
	}
	// ], line 160
	env.Bra = env.Cursor
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 167
		// delete, line 167
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_derivational(env *snowballRuntime.Env, ctx interface{}) bool {
	context := ctx.(*Context)
	_ = context
	var among_var int32
	// (, line 175
	// [, line 176
	env.Ket = env.Cursor
	// substring, line 176
	among_var = env.FindAmongB(A_6, context)
	if among_var == 0 {
		return false
	}
	// ], line 176
	env.Bra = env.Cursor
	// call R2, line 176
	if !r_R2(env, context) {
		return false
	}
	if among_var == 0 {
		return false
	} else if among_var == 1 {
		// (, line 179
		// delete, line 179
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func r_tidy_up(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 188
		// delete, line 188
		if !env.SliceDel() {
			return false
		}
		// [, line 189
		env.Ket = env.Cursor
		// literal, line 189
		if !env.EqSB("\u043D") {
			return false
		}
		// ], line 189
		env.Bra = env.Cursor
		// literal, line 189
		if !env.EqSB("\u043D") {
			return false
		}
		// delete, line 189
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 2 {
		// (, line 192
		// literal, line 192
		if !env.EqSB("\u043D") {
			return false
		}
		// delete, line 192
		if !env.SliceDel() {
			return false
		}
	} else if among_var == 3 {
		// (, line 194
		// delete, line 194
		if !env.SliceDel() {
			return false
		}
	}
	return true
}

func Stem(env *snowballRuntime.Env) bool {
	var context = &Context{
		i_p2: 0,
		i_pV: 0,
	}
	_ = context
	// (, line 199
	// do, line 201
	var v_1 = env.Cursor
lab0:
	for {
		// call mark_regions, line 201
		if !r_mark_regions(env, context) {
			break lab0
		}
		break lab0
	}
	env.Cursor = v_1
	// backwards, line 202
	env.LimitBackward = env.Cursor
	env.Cursor = env.Limit
	// setlimit, line 202
	var v_2 = env.Limit - env.Cursor
	// tomark, line 202
	if env.Cursor < context.i_pV {
		return false
	}
	env.Cursor = context.i_pV
	var v_3 = env.LimitBackward
	env.LimitBackward = env.Cursor
	env.Cursor = env.Limit - v_2
	// (, line 202
	// do, line 203
	var v_4 = env.Limit - env.Cursor
lab1:
	for {
		// (, line 203
		// or, line 204
	lab2:
		for {
			var v_5 = env.Limit - env.Cursor
		lab3:
			for {
				// call perfective_gerund, line 204
				if !r_perfective_gerund(env, context) {
					break lab3
				}
				break lab2
			}
			env.Cursor = env.Limit - v_5
			// (, line 205
			// try, line 205
			var v_6 = env.Limit - env.Cursor
		lab4:
			for {
				// call reflexive, line 205
				if !r_reflexive(env, context) {
					env.Cursor = env.Limit - v_6
					break lab4
				}
				break lab4
			}
			// or, line 206
		lab5:
			for {
				var v_7 = env.Limit - env.Cursor
			lab6:
				for {
					// call adjectival, line 206
					if !r_adjectival(env, context) {
						break lab6
					}
					break lab5
				}
				env.Cursor = env.Limit - v_7
			lab7:
				for {
					// call verb, line 206
					if !r_verb(env, context) {
						break lab7
					}
					break lab5
				}
				env.Cursor = env.Limit - v_7
				// call noun, line 206
				if !r_noun(env, context) {
					break lab1
				}
				break lab5
			}
			break lab2
		}
		break lab1
	}
	env.Cursor = env.Limit - v_4
	// try, line 209
	var v_8 = env.Limit - env.Cursor
lab8:
	for {
		// (, line 209
		// [, line 209
		env.Ket = env.Cursor
		// literal, line 209
		if !env.EqSB("\u0438") {
			env.Cursor = env.Limit - v_8
			break lab8
		}
		// ], line 209
		env.Bra = env.Cursor
		// delete, line 209
		if !env.SliceDel() {
			return false
		}
		break lab8
	}
	// do, line 212
	var v_9 = env.Limit - env.Cursor
lab9:
	for {
		// call derivational, line 212
		if !r_derivational(env, context) {
			break lab9
		}
		break lab9
	}
	env.Cursor = env.Limit - v_9
	// do, line 213
	var v_10 = env.Limit - env.Cursor
lab10:
	for {
		// call tidy_up, line 213
		if !r_tidy_up(env, context) {
			break lab10
		}
		break lab10
	}
	env.Cursor = env.Limit - v_10
	env.LimitBackward = v_3
	env.Cursor = env.LimitBackward
	return true
}
