1//! This file was generated automatically by the Snowball to Go compiler
2//! http://snowballstem.org/
3
4package english
5
6import (
7	snowballRuntime "github.com/blevesearch/snowballstem"
8)
9
10var A_0 = []*snowballRuntime.Among{
11	{Str: "arsen", A: -1, B: -1, F: nil},
12	{Str: "commun", A: -1, B: -1, F: nil},
13	{Str: "gener", A: -1, B: -1, F: nil},
14}
15
16var A_1 = []*snowballRuntime.Among{
17	{Str: "'", A: -1, B: 1, F: nil},
18	{Str: "'s'", A: 0, B: 1, F: nil},
19	{Str: "'s", A: -1, B: 1, F: nil},
20}
21
22var A_2 = []*snowballRuntime.Among{
23	{Str: "ied", A: -1, B: 2, F: nil},
24	{Str: "s", A: -1, B: 3, F: nil},
25	{Str: "ies", A: 1, B: 2, F: nil},
26	{Str: "sses", A: 1, B: 1, F: nil},
27	{Str: "ss", A: 1, B: -1, F: nil},
28	{Str: "us", A: 1, B: -1, F: nil},
29}
30
31var A_3 = []*snowballRuntime.Among{
32	{Str: "", A: -1, B: 3, F: nil},
33	{Str: "bb", A: 0, B: 2, F: nil},
34	{Str: "dd", A: 0, B: 2, F: nil},
35	{Str: "ff", A: 0, B: 2, F: nil},
36	{Str: "gg", A: 0, B: 2, F: nil},
37	{Str: "bl", A: 0, B: 1, F: nil},
38	{Str: "mm", A: 0, B: 2, F: nil},
39	{Str: "nn", A: 0, B: 2, F: nil},
40	{Str: "pp", A: 0, B: 2, F: nil},
41	{Str: "rr", A: 0, B: 2, F: nil},
42	{Str: "at", A: 0, B: 1, F: nil},
43	{Str: "tt", A: 0, B: 2, F: nil},
44	{Str: "iz", A: 0, B: 1, F: nil},
45}
46
47var A_4 = []*snowballRuntime.Among{
48	{Str: "ed", A: -1, B: 2, F: nil},
49	{Str: "eed", A: 0, B: 1, F: nil},
50	{Str: "ing", A: -1, B: 2, F: nil},
51	{Str: "edly", A: -1, B: 2, F: nil},
52	{Str: "eedly", A: 3, B: 1, F: nil},
53	{Str: "ingly", A: -1, B: 2, F: nil},
54}
55
56var A_5 = []*snowballRuntime.Among{
57	{Str: "anci", A: -1, B: 3, F: nil},
58	{Str: "enci", A: -1, B: 2, F: nil},
59	{Str: "ogi", A: -1, B: 13, F: nil},
60	{Str: "li", A: -1, B: 16, F: nil},
61	{Str: "bli", A: 3, B: 12, F: nil},
62	{Str: "abli", A: 4, B: 4, F: nil},
63	{Str: "alli", A: 3, B: 8, F: nil},
64	{Str: "fulli", A: 3, B: 14, F: nil},
65	{Str: "lessli", A: 3, B: 15, F: nil},
66	{Str: "ousli", A: 3, B: 10, F: nil},
67	{Str: "entli", A: 3, B: 5, F: nil},
68	{Str: "aliti", A: -1, B: 8, F: nil},
69	{Str: "biliti", A: -1, B: 12, F: nil},
70	{Str: "iviti", A: -1, B: 11, F: nil},
71	{Str: "tional", A: -1, B: 1, F: nil},
72	{Str: "ational", A: 14, B: 7, F: nil},
73	{Str: "alism", A: -1, B: 8, F: nil},
74	{Str: "ation", A: -1, B: 7, F: nil},
75	{Str: "ization", A: 17, B: 6, F: nil},
76	{Str: "izer", A: -1, B: 6, F: nil},
77	{Str: "ator", A: -1, B: 7, F: nil},
78	{Str: "iveness", A: -1, B: 11, F: nil},
79	{Str: "fulness", A: -1, B: 9, F: nil},
80	{Str: "ousness", A: -1, B: 10, F: nil},
81}
82
83var A_6 = []*snowballRuntime.Among{
84	{Str: "icate", A: -1, B: 4, F: nil},
85	{Str: "ative", A: -1, B: 6, F: nil},
86	{Str: "alize", A: -1, B: 3, F: nil},
87	{Str: "iciti", A: -1, B: 4, F: nil},
88	{Str: "ical", A: -1, B: 4, F: nil},
89	{Str: "tional", A: -1, B: 1, F: nil},
90	{Str: "ational", A: 5, B: 2, F: nil},
91	{Str: "ful", A: -1, B: 5, F: nil},
92	{Str: "ness", A: -1, B: 5, F: nil},
93}
94
95var A_7 = []*snowballRuntime.Among{
96	{Str: "ic", A: -1, B: 1, F: nil},
97	{Str: "ance", A: -1, B: 1, F: nil},
98	{Str: "ence", A: -1, B: 1, F: nil},
99	{Str: "able", A: -1, B: 1, F: nil},
100	{Str: "ible", A: -1, B: 1, F: nil},
101	{Str: "ate", A: -1, B: 1, F: nil},
102	{Str: "ive", A: -1, B: 1, F: nil},
103	{Str: "ize", A: -1, B: 1, F: nil},
104	{Str: "iti", A: -1, B: 1, F: nil},
105	{Str: "al", A: -1, B: 1, F: nil},
106	{Str: "ism", A: -1, B: 1, F: nil},
107	{Str: "ion", A: -1, B: 2, F: nil},
108	{Str: "er", A: -1, B: 1, F: nil},
109	{Str: "ous", A: -1, B: 1, F: nil},
110	{Str: "ant", A: -1, B: 1, F: nil},
111	{Str: "ent", A: -1, B: 1, F: nil},
112	{Str: "ment", A: 15, B: 1, F: nil},
113	{Str: "ement", A: 16, B: 1, F: nil},
114}
115
116var A_8 = []*snowballRuntime.Among{
117	{Str: "e", A: -1, B: 1, F: nil},
118	{Str: "l", A: -1, B: 2, F: nil},
119}
120
121var A_9 = []*snowballRuntime.Among{
122	{Str: "succeed", A: -1, B: -1, F: nil},
123	{Str: "proceed", A: -1, B: -1, F: nil},
124	{Str: "exceed", A: -1, B: -1, F: nil},
125	{Str: "canning", A: -1, B: -1, F: nil},
126	{Str: "inning", A: -1, B: -1, F: nil},
127	{Str: "earring", A: -1, B: -1, F: nil},
128	{Str: "herring", A: -1, B: -1, F: nil},
129	{Str: "outing", A: -1, B: -1, F: nil},
130}
131
132var A_10 = []*snowballRuntime.Among{
133	{Str: "andes", A: -1, B: -1, F: nil},
134	{Str: "atlas", A: -1, B: -1, F: nil},
135	{Str: "bias", A: -1, B: -1, F: nil},
136	{Str: "cosmos", A: -1, B: -1, F: nil},
137	{Str: "dying", A: -1, B: 3, F: nil},
138	{Str: "early", A: -1, B: 9, F: nil},
139	{Str: "gently", A: -1, B: 7, F: nil},
140	{Str: "howe", A: -1, B: -1, F: nil},
141	{Str: "idly", A: -1, B: 6, F: nil},
142	{Str: "lying", A: -1, B: 4, F: nil},
143	{Str: "news", A: -1, B: -1, F: nil},
144	{Str: "only", A: -1, B: 10, F: nil},
145	{Str: "singly", A: -1, B: 11, F: nil},
146	{Str: "skies", A: -1, B: 2, F: nil},
147	{Str: "skis", A: -1, B: 1, F: nil},
148	{Str: "sky", A: -1, B: -1, F: nil},
149	{Str: "tying", A: -1, B: 5, F: nil},
150	{Str: "ugly", A: -1, B: 8, F: nil},
151}
152
153var G_v = []byte{17, 65, 16, 1}
154
155var G_v_WXY = []byte{1, 17, 65, 208, 1}
156
157var G_valid_LI = []byte{55, 141, 2}
158
159type Context struct {
160	b_Y_found bool
161	i_p2      int
162	i_p1      int
163}
164
165func r_prelude(env *snowballRuntime.Env, ctx interface{}) bool {
166	context := ctx.(*Context)
167	_ = context
168	// (, line 25
169	// unset Y_found, line 26
170	context.b_Y_found = false
171	// do, line 27
172	var v_1 = env.Cursor
173lab0:
174	for {
175		// (, line 27
176		// [, line 27
177		env.Bra = env.Cursor
178		// literal, line 27
179		if !env.EqS("'") {
180			break lab0
181		}
182		// ], line 27
183		env.Ket = env.Cursor
184		// delete, line 27
185		if !env.SliceDel() {
186			return false
187		}
188		break lab0
189	}
190	env.Cursor = v_1
191	// do, line 28
192	var v_2 = env.Cursor
193lab1:
194	for {
195		// (, line 28
196		// [, line 28
197		env.Bra = env.Cursor
198		// literal, line 28
199		if !env.EqS("y") {
200			break lab1
201		}
202		// ], line 28
203		env.Ket = env.Cursor
204		// <-, line 28
205		if !env.SliceFrom("Y") {
206			return false
207		}
208		// set Y_found, line 28
209		context.b_Y_found = true
210		break lab1
211	}
212	env.Cursor = v_2
213	// do, line 29
214	var v_3 = env.Cursor
215lab2:
216	for {
217		// repeat, line 29
218	replab3:
219		for {
220			var v_4 = env.Cursor
221		lab4:
222			for range [2]struct{}{} {
223				// (, line 29
224				// goto, line 29
225			golab5:
226				for {
227					var v_5 = env.Cursor
228				lab6:
229					for {
230						// (, line 29
231						if !env.InGrouping(G_v, 97, 121) {
232							break lab6
233						}
234						// [, line 29
235						env.Bra = env.Cursor
236						// literal, line 29
237						if !env.EqS("y") {
238							break lab6
239						}
240						// ], line 29
241						env.Ket = env.Cursor
242						env.Cursor = v_5
243						break golab5
244					}
245					env.Cursor = v_5
246					if env.Cursor >= env.Limit {
247						break lab4
248					}
249					env.NextChar()
250				}
251				// <-, line 29
252				if !env.SliceFrom("Y") {
253					return false
254				}
255				// set Y_found, line 29
256				context.b_Y_found = true
257				continue replab3
258			}
259			env.Cursor = v_4
260			break replab3
261		}
262		break lab2
263	}
264	env.Cursor = v_3
265	return true
266}
267
268func r_mark_regions(env *snowballRuntime.Env, ctx interface{}) bool {
269	context := ctx.(*Context)
270	_ = context
271	// (, line 32
272	context.i_p1 = env.Limit
273	context.i_p2 = env.Limit
274	// do, line 35
275	var v_1 = env.Cursor
276lab0:
277	for {
278		// (, line 35
279		// or, line 41
280	lab1:
281		for {
282			var v_2 = env.Cursor
283		lab2:
284			for {
285				// among, line 36
286				if env.FindAmong(A_0, context) == 0 {
287					break lab2
288				}
289				break lab1
290			}
291			env.Cursor = v_2
292			// (, line 41
293			// gopast, line 41
294		golab3:
295			for {
296			lab4:
297				for {
298					if !env.InGrouping(G_v, 97, 121) {
299						break lab4
300					}
301					break golab3
302				}
303				if env.Cursor >= env.Limit {
304					break lab0
305				}
306				env.NextChar()
307			}
308			// gopast, line 41
309		golab5:
310			for {
311			lab6:
312				for {
313					if !env.OutGrouping(G_v, 97, 121) {
314						break lab6
315					}
316					break golab5
317				}
318				if env.Cursor >= env.Limit {
319					break lab0
320				}
321				env.NextChar()
322			}
323			break lab1
324		}
325		// setmark p1, line 42
326		context.i_p1 = env.Cursor
327		// gopast, line 43
328	golab7:
329		for {
330		lab8:
331			for {
332				if !env.InGrouping(G_v, 97, 121) {
333					break lab8
334				}
335				break golab7
336			}
337			if env.Cursor >= env.Limit {
338				break lab0
339			}
340			env.NextChar()
341		}
342		// gopast, line 43
343	golab9:
344		for {
345		lab10:
346			for {
347				if !env.OutGrouping(G_v, 97, 121) {
348					break lab10
349				}
350				break golab9
351			}
352			if env.Cursor >= env.Limit {
353				break lab0
354			}
355			env.NextChar()
356		}
357		// setmark p2, line 43
358		context.i_p2 = env.Cursor
359		break lab0
360	}
361	env.Cursor = v_1
362	return true
363}
364
365func r_shortv(env *snowballRuntime.Env, ctx interface{}) bool {
366	context := ctx.(*Context)
367	_ = context
368	// (, line 49
369	// or, line 51
370lab0:
371	for {
372		var v_1 = env.Limit - env.Cursor
373	lab1:
374		for {
375			// (, line 50
376			if !env.OutGroupingB(G_v_WXY, 89, 121) {
377				break lab1
378			}
379			if !env.InGroupingB(G_v, 97, 121) {
380				break lab1
381			}
382			if !env.OutGroupingB(G_v, 97, 121) {
383				break lab1
384			}
385			break lab0
386		}
387		env.Cursor = env.Limit - v_1
388		// (, line 52
389		if !env.OutGroupingB(G_v, 97, 121) {
390			return false
391		}
392		if !env.InGroupingB(G_v, 97, 121) {
393			return false
394		}
395		// atlimit, line 52
396		if env.Cursor > env.LimitBackward {
397			return false
398		}
399		break lab0
400	}
401	return true
402}
403
404func r_R1(env *snowballRuntime.Env, ctx interface{}) bool {
405	context := ctx.(*Context)
406	_ = context
407	if !(context.i_p1 <= env.Cursor) {
408		return false
409	}
410	return true
411}
412
413func r_R2(env *snowballRuntime.Env, ctx interface{}) bool {
414	context := ctx.(*Context)
415	_ = context
416	if !(context.i_p2 <= env.Cursor) {
417		return false
418	}
419	return true
420}
421
422func r_Step_1a(env *snowballRuntime.Env, ctx interface{}) bool {
423	context := ctx.(*Context)
424	_ = context
425	var among_var int32
426	// (, line 58
427	// try, line 59
428	var v_1 = env.Limit - env.Cursor
429lab0:
430	for {
431		// (, line 59
432		// [, line 60
433		env.Ket = env.Cursor
434		// substring, line 60
435		among_var = env.FindAmongB(A_1, context)
436		if among_var == 0 {
437			env.Cursor = env.Limit - v_1
438			break lab0
439		}
440		// ], line 60
441		env.Bra = env.Cursor
442		if among_var == 0 {
443			env.Cursor = env.Limit - v_1
444			break lab0
445		} else if among_var == 1 {
446			// (, line 62
447			// delete, line 62
448			if !env.SliceDel() {
449				return false
450			}
451		}
452		break lab0
453	}
454	// [, line 65
455	env.Ket = env.Cursor
456	// substring, line 65
457	among_var = env.FindAmongB(A_2, context)
458	if among_var == 0 {
459		return false
460	}
461	// ], line 65
462	env.Bra = env.Cursor
463	if among_var == 0 {
464		return false
465	} else if among_var == 1 {
466		// (, line 66
467		// <-, line 66
468		if !env.SliceFrom("ss") {
469			return false
470		}
471	} else if among_var == 2 {
472		// (, line 68
473		// or, line 68
474	lab1:
475		for {
476			var v_2 = env.Limit - env.Cursor
477		lab2:
478			for {
479				// (, line 68
480				{
481					// hop, line 68
482					var c = env.ByteIndexForHop(-(2))
483					if int32(env.LimitBackward) > c || c > int32(env.Limit) {
484						break lab2
485					}
486					env.Cursor = int(c)
487				}
488				// <-, line 68
489				if !env.SliceFrom("i") {
490					return false
491				}
492				break lab1
493			}
494			env.Cursor = env.Limit - v_2
495			// <-, line 68
496			if !env.SliceFrom("ie") {
497				return false
498			}
499			break lab1
500		}
501	} else if among_var == 3 {
502		// (, line 69
503		// next, line 69
504		if env.Cursor <= env.LimitBackward {
505			return false
506		}
507		env.PrevChar()
508		// gopast, line 69
509	golab3:
510		for {
511		lab4:
512			for {
513				if !env.InGroupingB(G_v, 97, 121) {
514					break lab4
515				}
516				break golab3
517			}
518			if env.Cursor <= env.LimitBackward {
519				return false
520			}
521			env.PrevChar()
522		}
523		// delete, line 69
524		if !env.SliceDel() {
525			return false
526		}
527	}
528	return true
529}
530
531func r_Step_1b(env *snowballRuntime.Env, ctx interface{}) bool {
532	context := ctx.(*Context)
533	_ = context
534	var among_var int32
535	// (, line 74
536	// [, line 75
537	env.Ket = env.Cursor
538	// substring, line 75
539	among_var = env.FindAmongB(A_4, context)
540	if among_var == 0 {
541		return false
542	}
543	// ], line 75
544	env.Bra = env.Cursor
545	if among_var == 0 {
546		return false
547	} else if among_var == 1 {
548		// (, line 77
549		// call R1, line 77
550		if !r_R1(env, context) {
551			return false
552		}
553		// <-, line 77
554		if !env.SliceFrom("ee") {
555			return false
556		}
557	} else if among_var == 2 {
558		// (, line 79
559		// test, line 80
560		var v_1 = env.Limit - env.Cursor
561		// gopast, line 80
562	golab0:
563		for {
564		lab1:
565			for {
566				if !env.InGroupingB(G_v, 97, 121) {
567					break lab1
568				}
569				break golab0
570			}
571			if env.Cursor <= env.LimitBackward {
572				return false
573			}
574			env.PrevChar()
575		}
576		env.Cursor = env.Limit - v_1
577		// delete, line 80
578		if !env.SliceDel() {
579			return false
580		}
581		// test, line 81
582		var v_3 = env.Limit - env.Cursor
583		// substring, line 81
584		among_var = env.FindAmongB(A_3, context)
585		if among_var == 0 {
586			return false
587		}
588		env.Cursor = env.Limit - v_3
589		if among_var == 0 {
590			return false
591		} else if among_var == 1 {
592			// (, line 83
593			{
594				// <+, line 83
595				var c = env.Cursor
596				bra, ket := env.Cursor, env.Cursor
597				env.Insert(bra, ket, "e")
598				env.Cursor = c
599			}
600		} else if among_var == 2 {
601			// (, line 86
602			// [, line 86
603			env.Ket = env.Cursor
604			// next, line 86
605			if env.Cursor <= env.LimitBackward {
606				return false
607			}
608			env.PrevChar()
609			// ], line 86
610			env.Bra = env.Cursor
611			// delete, line 86
612			if !env.SliceDel() {
613				return false
614			}
615		} else if among_var == 3 {
616			// (, line 87
617			// atmark, line 87
618			if env.Cursor != context.i_p1 {
619				return false
620			}
621			// test, line 87
622			var v_4 = env.Limit - env.Cursor
623			// call shortv, line 87
624			if !r_shortv(env, context) {
625				return false
626			}
627			env.Cursor = env.Limit - v_4
628			{
629				// <+, line 87
630				var c = env.Cursor
631				bra, ket := env.Cursor, env.Cursor
632				env.Insert(bra, ket, "e")
633				env.Cursor = c
634			}
635		}
636	}
637	return true
638}
639
640func r_Step_1c(env *snowballRuntime.Env, ctx interface{}) bool {
641	context := ctx.(*Context)
642	_ = context
643	// (, line 93
644	// [, line 94
645	env.Ket = env.Cursor
646	// or, line 94
647lab0:
648	for {
649		var v_1 = env.Limit - env.Cursor
650	lab1:
651		for {
652			// literal, line 94
653			if !env.EqSB("y") {
654				break lab1
655			}
656			break lab0
657		}
658		env.Cursor = env.Limit - v_1
659		// literal, line 94
660		if !env.EqSB("Y") {
661			return false
662		}
663		break lab0
664	}
665	// ], line 94
666	env.Bra = env.Cursor
667	if !env.OutGroupingB(G_v, 97, 121) {
668		return false
669	}
670	// not, line 95
671	var v_2 = env.Limit - env.Cursor
672lab2:
673	for {
674		// atlimit, line 95
675		if env.Cursor > env.LimitBackward {
676			break lab2
677		}
678		return false
679	}
680	env.Cursor = env.Limit - v_2
681	// <-, line 96
682	if !env.SliceFrom("i") {
683		return false
684	}
685	return true
686}
687
688func r_Step_2(env *snowballRuntime.Env, ctx interface{}) bool {
689	context := ctx.(*Context)
690	_ = context
691	var among_var int32
692	// (, line 99
693	// [, line 100
694	env.Ket = env.Cursor
695	// substring, line 100
696	among_var = env.FindAmongB(A_5, context)
697	if among_var == 0 {
698		return false
699	}
700	// ], line 100
701	env.Bra = env.Cursor
702	// call R1, line 100
703	if !r_R1(env, context) {
704		return false
705	}
706	if among_var == 0 {
707		return false
708	} else if among_var == 1 {
709		// (, line 101
710		// <-, line 101
711		if !env.SliceFrom("tion") {
712			return false
713		}
714	} else if among_var == 2 {
715		// (, line 102
716		// <-, line 102
717		if !env.SliceFrom("ence") {
718			return false
719		}
720	} else if among_var == 3 {
721		// (, line 103
722		// <-, line 103
723		if !env.SliceFrom("ance") {
724			return false
725		}
726	} else if among_var == 4 {
727		// (, line 104
728		// <-, line 104
729		if !env.SliceFrom("able") {
730			return false
731		}
732	} else if among_var == 5 {
733		// (, line 105
734		// <-, line 105
735		if !env.SliceFrom("ent") {
736			return false
737		}
738	} else if among_var == 6 {
739		// (, line 107
740		// <-, line 107
741		if !env.SliceFrom("ize") {
742			return false
743		}
744	} else if among_var == 7 {
745		// (, line 109
746		// <-, line 109
747		if !env.SliceFrom("ate") {
748			return false
749		}
750	} else if among_var == 8 {
751		// (, line 111
752		// <-, line 111
753		if !env.SliceFrom("al") {
754			return false
755		}
756	} else if among_var == 9 {
757		// (, line 112
758		// <-, line 112
759		if !env.SliceFrom("ful") {
760			return false
761		}
762	} else if among_var == 10 {
763		// (, line 114
764		// <-, line 114
765		if !env.SliceFrom("ous") {
766			return false
767		}
768	} else if among_var == 11 {
769		// (, line 116
770		// <-, line 116
771		if !env.SliceFrom("ive") {
772			return false
773		}
774	} else if among_var == 12 {
775		// (, line 118
776		// <-, line 118
777		if !env.SliceFrom("ble") {
778			return false
779		}
780	} else if among_var == 13 {
781		// (, line 119
782		// literal, line 119
783		if !env.EqSB("l") {
784			return false
785		}
786		// <-, line 119
787		if !env.SliceFrom("og") {
788			return false
789		}
790	} else if among_var == 14 {
791		// (, line 120
792		// <-, line 120
793		if !env.SliceFrom("ful") {
794			return false
795		}
796	} else if among_var == 15 {
797		// (, line 121
798		// <-, line 121
799		if !env.SliceFrom("less") {
800			return false
801		}
802	} else if among_var == 16 {
803		// (, line 122
804		if !env.InGroupingB(G_valid_LI, 99, 116) {
805			return false
806		}
807		// delete, line 122
808		if !env.SliceDel() {
809			return false
810		}
811	}
812	return true
813}
814
815func r_Step_3(env *snowballRuntime.Env, ctx interface{}) bool {
816	context := ctx.(*Context)
817	_ = context
818	var among_var int32
819	// (, line 126
820	// [, line 127
821	env.Ket = env.Cursor
822	// substring, line 127
823	among_var = env.FindAmongB(A_6, context)
824	if among_var == 0 {
825		return false
826	}
827	// ], line 127
828	env.Bra = env.Cursor
829	// call R1, line 127
830	if !r_R1(env, context) {
831		return false
832	}
833	if among_var == 0 {
834		return false
835	} else if among_var == 1 {
836		// (, line 128
837		// <-, line 128
838		if !env.SliceFrom("tion") {
839			return false
840		}
841	} else if among_var == 2 {
842		// (, line 129
843		// <-, line 129
844		if !env.SliceFrom("ate") {
845			return false
846		}
847	} else if among_var == 3 {
848		// (, line 130
849		// <-, line 130
850		if !env.SliceFrom("al") {
851			return false
852		}
853	} else if among_var == 4 {
854		// (, line 132
855		// <-, line 132
856		if !env.SliceFrom("ic") {
857			return false
858		}
859	} else if among_var == 5 {
860		// (, line 134
861		// delete, line 134
862		if !env.SliceDel() {
863			return false
864		}
865	} else if among_var == 6 {
866		// (, line 136
867		// call R2, line 136
868		if !r_R2(env, context) {
869			return false
870		}
871		// delete, line 136
872		if !env.SliceDel() {
873			return false
874		}
875	}
876	return true
877}
878
879func r_Step_4(env *snowballRuntime.Env, ctx interface{}) bool {
880	context := ctx.(*Context)
881	_ = context
882	var among_var int32
883	// (, line 140
884	// [, line 141
885	env.Ket = env.Cursor
886	// substring, line 141
887	among_var = env.FindAmongB(A_7, context)
888	if among_var == 0 {
889		return false
890	}
891	// ], line 141
892	env.Bra = env.Cursor
893	// call R2, line 141
894	if !r_R2(env, context) {
895		return false
896	}
897	if among_var == 0 {
898		return false
899	} else if among_var == 1 {
900		// (, line 144
901		// delete, line 144
902		if !env.SliceDel() {
903			return false
904		}
905	} else if among_var == 2 {
906		// (, line 145
907		// or, line 145
908	lab0:
909		for {
910			var v_1 = env.Limit - env.Cursor
911		lab1:
912			for {
913				// literal, line 145
914				if !env.EqSB("s") {
915					break lab1
916				}
917				break lab0
918			}
919			env.Cursor = env.Limit - v_1
920			// literal, line 145
921			if !env.EqSB("t") {
922				return false
923			}
924			break lab0
925		}
926		// delete, line 145
927		if !env.SliceDel() {
928			return false
929		}
930	}
931	return true
932}
933
934func r_Step_5(env *snowballRuntime.Env, ctx interface{}) bool {
935	context := ctx.(*Context)
936	_ = context
937	var among_var int32
938	// (, line 149
939	// [, line 150
940	env.Ket = env.Cursor
941	// substring, line 150
942	among_var = env.FindAmongB(A_8, context)
943	if among_var == 0 {
944		return false
945	}
946	// ], line 150
947	env.Bra = env.Cursor
948	if among_var == 0 {
949		return false
950	} else if among_var == 1 {
951		// (, line 151
952		// or, line 151
953	lab0:
954		for {
955			var v_1 = env.Limit - env.Cursor
956		lab1:
957			for {
958				// call R2, line 151
959				if !r_R2(env, context) {
960					break lab1
961				}
962				break lab0
963			}
964			env.Cursor = env.Limit - v_1
965			// (, line 151
966			// call R1, line 151
967			if !r_R1(env, context) {
968				return false
969			}
970			// not, line 151
971			var v_2 = env.Limit - env.Cursor
972		lab2:
973			for {
974				// call shortv, line 151
975				if !r_shortv(env, context) {
976					break lab2
977				}
978				return false
979			}
980			env.Cursor = env.Limit - v_2
981			break lab0
982		}
983		// delete, line 151
984		if !env.SliceDel() {
985			return false
986		}
987	} else if among_var == 2 {
988		// (, line 152
989		// call R2, line 152
990		if !r_R2(env, context) {
991			return false
992		}
993		// literal, line 152
994		if !env.EqSB("l") {
995			return false
996		}
997		// delete, line 152
998		if !env.SliceDel() {
999			return false
1000		}
1001	}
1002	return true
1003}
1004
1005func r_exception2(env *snowballRuntime.Env, ctx interface{}) bool {
1006	context := ctx.(*Context)
1007	_ = context
1008	// (, line 156
1009	// [, line 158
1010	env.Ket = env.Cursor
1011	// substring, line 158
1012	if env.FindAmongB(A_9, context) == 0 {
1013		return false
1014	}
1015	// ], line 158
1016	env.Bra = env.Cursor
1017	// atlimit, line 158
1018	if env.Cursor > env.LimitBackward {
1019		return false
1020	}
1021	return true
1022}
1023
1024func r_exception1(env *snowballRuntime.Env, ctx interface{}) bool {
1025	context := ctx.(*Context)
1026	_ = context
1027	var among_var int32
1028	// (, line 168
1029	// [, line 170
1030	env.Bra = env.Cursor
1031	// substring, line 170
1032	among_var = env.FindAmong(A_10, context)
1033	if among_var == 0 {
1034		return false
1035	}
1036	// ], line 170
1037	env.Ket = env.Cursor
1038	// atlimit, line 170
1039	if env.Cursor < env.Limit {
1040		return false
1041	}
1042	if among_var == 0 {
1043		return false
1044	} else if among_var == 1 {
1045		// (, line 174
1046		// <-, line 174
1047		if !env.SliceFrom("ski") {
1048			return false
1049		}
1050	} else if among_var == 2 {
1051		// (, line 175
1052		// <-, line 175
1053		if !env.SliceFrom("sky") {
1054			return false
1055		}
1056	} else if among_var == 3 {
1057		// (, line 176
1058		// <-, line 176
1059		if !env.SliceFrom("die") {
1060			return false
1061		}
1062	} else if among_var == 4 {
1063		// (, line 177
1064		// <-, line 177
1065		if !env.SliceFrom("lie") {
1066			return false
1067		}
1068	} else if among_var == 5 {
1069		// (, line 178
1070		// <-, line 178
1071		if !env.SliceFrom("tie") {
1072			return false
1073		}
1074	} else if among_var == 6 {
1075		// (, line 182
1076		// <-, line 182
1077		if !env.SliceFrom("idl") {
1078			return false
1079		}
1080	} else if among_var == 7 {
1081		// (, line 183
1082		// <-, line 183
1083		if !env.SliceFrom("gentl") {
1084			return false
1085		}
1086	} else if among_var == 8 {
1087		// (, line 184
1088		// <-, line 184
1089		if !env.SliceFrom("ugli") {
1090			return false
1091		}
1092	} else if among_var == 9 {
1093		// (, line 185
1094		// <-, line 185
1095		if !env.SliceFrom("earli") {
1096			return false
1097		}
1098	} else if among_var == 10 {
1099		// (, line 186
1100		// <-, line 186
1101		if !env.SliceFrom("onli") {
1102			return false
1103		}
1104	} else if among_var == 11 {
1105		// (, line 187
1106		// <-, line 187
1107		if !env.SliceFrom("singl") {
1108			return false
1109		}
1110	}
1111	return true
1112}
1113
1114func r_postlude(env *snowballRuntime.Env, ctx interface{}) bool {
1115	context := ctx.(*Context)
1116	_ = context
1117	// (, line 203
1118	// Boolean test Y_found, line 203
1119	if !context.b_Y_found {
1120		return false
1121	}
1122	// repeat, line 203
1123replab0:
1124	for {
1125		var v_1 = env.Cursor
1126	lab1:
1127		for range [2]struct{}{} {
1128			// (, line 203
1129			// goto, line 203
1130		golab2:
1131			for {
1132				var v_2 = env.Cursor
1133			lab3:
1134				for {
1135					// (, line 203
1136					// [, line 203
1137					env.Bra = env.Cursor
1138					// literal, line 203
1139					if !env.EqS("Y") {
1140						break lab3
1141					}
1142					// ], line 203
1143					env.Ket = env.Cursor
1144					env.Cursor = v_2
1145					break golab2
1146				}
1147				env.Cursor = v_2
1148				if env.Cursor >= env.Limit {
1149					break lab1
1150				}
1151				env.NextChar()
1152			}
1153			// <-, line 203
1154			if !env.SliceFrom("y") {
1155				return false
1156			}
1157			continue replab0
1158		}
1159		env.Cursor = v_1
1160		break replab0
1161	}
1162	return true
1163}
1164
1165func Stem(env *snowballRuntime.Env) bool {
1166	var context = &Context{
1167		b_Y_found: false,
1168		i_p2:      0,
1169		i_p1:      0,
1170	}
1171	_ = context
1172	// (, line 205
1173	// or, line 207
1174lab0:
1175	for {
1176		var v_1 = env.Cursor
1177	lab1:
1178		for {
1179			// call exception1, line 207
1180			if !r_exception1(env, context) {
1181				break lab1
1182			}
1183			break lab0
1184		}
1185		env.Cursor = v_1
1186	lab2:
1187		for {
1188			// not, line 208
1189			var v_2 = env.Cursor
1190		lab3:
1191			for {
1192				{
1193					// hop, line 208
1194					var c = env.ByteIndexForHop((3))
1195					if int32(0) > c || c > int32(env.Limit) {
1196						break lab3
1197					}
1198					env.Cursor = int(c)
1199				}
1200				break lab2
1201			}
1202			env.Cursor = v_2
1203			break lab0
1204		}
1205		env.Cursor = v_1
1206		// (, line 208
1207		// do, line 209
1208		var v_3 = env.Cursor
1209	lab4:
1210		for {
1211			// call prelude, line 209
1212			if !r_prelude(env, context) {
1213				break lab4
1214			}
1215			break lab4
1216		}
1217		env.Cursor = v_3
1218		// do, line 210
1219		var v_4 = env.Cursor
1220	lab5:
1221		for {
1222			// call mark_regions, line 210
1223			if !r_mark_regions(env, context) {
1224				break lab5
1225			}
1226			break lab5
1227		}
1228		env.Cursor = v_4
1229		// backwards, line 211
1230		env.LimitBackward = env.Cursor
1231		env.Cursor = env.Limit
1232		// (, line 211
1233		// do, line 213
1234		var v_5 = env.Limit - env.Cursor
1235	lab6:
1236		for {
1237			// call Step_1a, line 213
1238			if !r_Step_1a(env, context) {
1239				break lab6
1240			}
1241			break lab6
1242		}
1243		env.Cursor = env.Limit - v_5
1244		// or, line 215
1245	lab7:
1246		for {
1247			var v_6 = env.Limit - env.Cursor
1248		lab8:
1249			for {
1250				// call exception2, line 215
1251				if !r_exception2(env, context) {
1252					break lab8
1253				}
1254				break lab7
1255			}
1256			env.Cursor = env.Limit - v_6
1257			// (, line 215
1258			// do, line 217
1259			var v_7 = env.Limit - env.Cursor
1260		lab9:
1261			for {
1262				// call Step_1b, line 217
1263				if !r_Step_1b(env, context) {
1264					break lab9
1265				}
1266				break lab9
1267			}
1268			env.Cursor = env.Limit - v_7
1269			// do, line 218
1270			var v_8 = env.Limit - env.Cursor
1271		lab10:
1272			for {
1273				// call Step_1c, line 218
1274				if !r_Step_1c(env, context) {
1275					break lab10
1276				}
1277				break lab10
1278			}
1279			env.Cursor = env.Limit - v_8
1280			// do, line 220
1281			var v_9 = env.Limit - env.Cursor
1282		lab11:
1283			for {
1284				// call Step_2, line 220
1285				if !r_Step_2(env, context) {
1286					break lab11
1287				}
1288				break lab11
1289			}
1290			env.Cursor = env.Limit - v_9
1291			// do, line 221
1292			var v_10 = env.Limit - env.Cursor
1293		lab12:
1294			for {
1295				// call Step_3, line 221
1296				if !r_Step_3(env, context) {
1297					break lab12
1298				}
1299				break lab12
1300			}
1301			env.Cursor = env.Limit - v_10
1302			// do, line 222
1303			var v_11 = env.Limit - env.Cursor
1304		lab13:
1305			for {
1306				// call Step_4, line 222
1307				if !r_Step_4(env, context) {
1308					break lab13
1309				}
1310				break lab13
1311			}
1312			env.Cursor = env.Limit - v_11
1313			// do, line 224
1314			var v_12 = env.Limit - env.Cursor
1315		lab14:
1316			for {
1317				// call Step_5, line 224
1318				if !r_Step_5(env, context) {
1319					break lab14
1320				}
1321				break lab14
1322			}
1323			env.Cursor = env.Limit - v_12
1324			break lab7
1325		}
1326		env.Cursor = env.LimitBackward
1327		// do, line 227
1328		var v_13 = env.Cursor
1329	lab15:
1330		for {
1331			// call postlude, line 227
1332			if !r_postlude(env, context) {
1333				break lab15
1334			}
1335			break lab15
1336		}
1337		env.Cursor = v_13
1338		break lab0
1339	}
1340	return true
1341}
1342