1//! This file was generated automatically by the Snowball to Go compiler
2//! http://snowballstem.org/
3
4package porter
5
6import (
7	snowballRuntime "github.com/blevesearch/snowballstem"
8)
9
10var A_0 = []*snowballRuntime.Among{
11	{Str: "s", A: -1, B: 3, F: nil},
12	{Str: "ies", A: 0, B: 2, F: nil},
13	{Str: "sses", A: 0, B: 1, F: nil},
14	{Str: "ss", A: 0, B: -1, F: nil},
15}
16
17var A_1 = []*snowballRuntime.Among{
18	{Str: "", A: -1, B: 3, F: nil},
19	{Str: "bb", A: 0, B: 2, F: nil},
20	{Str: "dd", A: 0, B: 2, F: nil},
21	{Str: "ff", A: 0, B: 2, F: nil},
22	{Str: "gg", A: 0, B: 2, F: nil},
23	{Str: "bl", A: 0, B: 1, F: nil},
24	{Str: "mm", A: 0, B: 2, F: nil},
25	{Str: "nn", A: 0, B: 2, F: nil},
26	{Str: "pp", A: 0, B: 2, F: nil},
27	{Str: "rr", A: 0, B: 2, F: nil},
28	{Str: "at", A: 0, B: 1, F: nil},
29	{Str: "tt", A: 0, B: 2, F: nil},
30	{Str: "iz", A: 0, B: 1, F: nil},
31}
32
33var A_2 = []*snowballRuntime.Among{
34	{Str: "ed", A: -1, B: 2, F: nil},
35	{Str: "eed", A: 0, B: 1, F: nil},
36	{Str: "ing", A: -1, B: 2, F: nil},
37}
38
39var A_3 = []*snowballRuntime.Among{
40	{Str: "anci", A: -1, B: 3, F: nil},
41	{Str: "enci", A: -1, B: 2, F: nil},
42	{Str: "abli", A: -1, B: 4, F: nil},
43	{Str: "eli", A: -1, B: 6, F: nil},
44	{Str: "alli", A: -1, B: 9, F: nil},
45	{Str: "ousli", A: -1, B: 12, F: nil},
46	{Str: "entli", A: -1, B: 5, F: nil},
47	{Str: "aliti", A: -1, B: 10, F: nil},
48	{Str: "biliti", A: -1, B: 14, F: nil},
49	{Str: "iviti", A: -1, B: 13, F: nil},
50	{Str: "tional", A: -1, B: 1, F: nil},
51	{Str: "ational", A: 10, B: 8, F: nil},
52	{Str: "alism", A: -1, B: 10, F: nil},
53	{Str: "ation", A: -1, B: 8, F: nil},
54	{Str: "ization", A: 13, B: 7, F: nil},
55	{Str: "izer", A: -1, B: 7, F: nil},
56	{Str: "ator", A: -1, B: 8, F: nil},
57	{Str: "iveness", A: -1, B: 13, F: nil},
58	{Str: "fulness", A: -1, B: 11, F: nil},
59	{Str: "ousness", A: -1, B: 12, F: nil},
60}
61
62var A_4 = []*snowballRuntime.Among{
63	{Str: "icate", A: -1, B: 2, F: nil},
64	{Str: "ative", A: -1, B: 3, F: nil},
65	{Str: "alize", A: -1, B: 1, F: nil},
66	{Str: "iciti", A: -1, B: 2, F: nil},
67	{Str: "ical", A: -1, B: 2, F: nil},
68	{Str: "ful", A: -1, B: 3, F: nil},
69	{Str: "ness", A: -1, B: 3, F: nil},
70}
71
72var A_5 = []*snowballRuntime.Among{
73	{Str: "ic", A: -1, B: 1, F: nil},
74	{Str: "ance", A: -1, B: 1, F: nil},
75	{Str: "ence", A: -1, B: 1, F: nil},
76	{Str: "able", A: -1, B: 1, F: nil},
77	{Str: "ible", A: -1, B: 1, F: nil},
78	{Str: "ate", A: -1, B: 1, F: nil},
79	{Str: "ive", A: -1, B: 1, F: nil},
80	{Str: "ize", A: -1, B: 1, F: nil},
81	{Str: "iti", A: -1, B: 1, F: nil},
82	{Str: "al", A: -1, B: 1, F: nil},
83	{Str: "ism", A: -1, B: 1, F: nil},
84	{Str: "ion", A: -1, B: 2, F: nil},
85	{Str: "er", A: -1, B: 1, F: nil},
86	{Str: "ous", A: -1, B: 1, F: nil},
87	{Str: "ant", A: -1, B: 1, F: nil},
88	{Str: "ent", A: -1, B: 1, F: nil},
89	{Str: "ment", A: 15, B: 1, F: nil},
90	{Str: "ement", A: 16, B: 1, F: nil},
91	{Str: "ou", A: -1, B: 1, F: nil},
92}
93
94var G_v = []byte{17, 65, 16, 1}
95
96var G_v_WXY = []byte{1, 17, 65, 208, 1}
97
98type Context struct {
99	b_Y_found bool
100	i_p2      int
101	i_p1      int
102}
103
104func r_shortv(env *snowballRuntime.Env, ctx interface{}) bool {
105	context := ctx.(*Context)
106	_ = context
107	// (, line 19
108	if !env.OutGroupingB(G_v_WXY, 89, 121) {
109		return false
110	}
111	if !env.InGroupingB(G_v, 97, 121) {
112		return false
113	}
114	if !env.OutGroupingB(G_v, 97, 121) {
115		return false
116	}
117	return true
118}
119
120func r_R1(env *snowballRuntime.Env, ctx interface{}) bool {
121	context := ctx.(*Context)
122	_ = context
123	if !(context.i_p1 <= env.Cursor) {
124		return false
125	}
126	return true
127}
128
129func r_R2(env *snowballRuntime.Env, ctx interface{}) bool {
130	context := ctx.(*Context)
131	_ = context
132	if !(context.i_p2 <= env.Cursor) {
133		return false
134	}
135	return true
136}
137
138func r_Step_1a(env *snowballRuntime.Env, ctx interface{}) bool {
139	context := ctx.(*Context)
140	_ = context
141	var among_var int32
142	// (, line 24
143	// [, line 25
144	env.Ket = env.Cursor
145	// substring, line 25
146	among_var = env.FindAmongB(A_0, context)
147	if among_var == 0 {
148		return false
149	}
150	// ], line 25
151	env.Bra = env.Cursor
152	if among_var == 0 {
153		return false
154	} else if among_var == 1 {
155		// (, line 26
156		// <-, line 26
157		if !env.SliceFrom("ss") {
158			return false
159		}
160	} else if among_var == 2 {
161		// (, line 27
162		// <-, line 27
163		if !env.SliceFrom("i") {
164			return false
165		}
166	} else if among_var == 3 {
167		// (, line 29
168		// delete, line 29
169		if !env.SliceDel() {
170			return false
171		}
172	}
173	return true
174}
175
176func r_Step_1b(env *snowballRuntime.Env, ctx interface{}) bool {
177	context := ctx.(*Context)
178	_ = context
179	var among_var int32
180	// (, line 33
181	// [, line 34
182	env.Ket = env.Cursor
183	// substring, line 34
184	among_var = env.FindAmongB(A_2, context)
185	if among_var == 0 {
186		return false
187	}
188	// ], line 34
189	env.Bra = env.Cursor
190	if among_var == 0 {
191		return false
192	} else if among_var == 1 {
193		// (, line 35
194		// call R1, line 35
195		if !r_R1(env, context) {
196			return false
197		}
198		// <-, line 35
199		if !env.SliceFrom("ee") {
200			return false
201		}
202	} else if among_var == 2 {
203		// (, line 37
204		// test, line 38
205		var v_1 = env.Limit - env.Cursor
206		// gopast, line 38
207	golab0:
208		for {
209		lab1:
210			for {
211				if !env.InGroupingB(G_v, 97, 121) {
212					break lab1
213				}
214				break golab0
215			}
216			if env.Cursor <= env.LimitBackward {
217				return false
218			}
219			env.PrevChar()
220		}
221		env.Cursor = env.Limit - v_1
222		// delete, line 38
223		if !env.SliceDel() {
224			return false
225		}
226		// test, line 39
227		var v_3 = env.Limit - env.Cursor
228		// substring, line 39
229		among_var = env.FindAmongB(A_1, context)
230		if among_var == 0 {
231			return false
232		}
233		env.Cursor = env.Limit - v_3
234		if among_var == 0 {
235			return false
236		} else if among_var == 1 {
237			// (, line 41
238			{
239				// <+, line 41
240				var c = env.Cursor
241				bra, ket := env.Cursor, env.Cursor
242				env.Insert(bra, ket, "e")
243				env.Cursor = c
244			}
245		} else if among_var == 2 {
246			// (, line 44
247			// [, line 44
248			env.Ket = env.Cursor
249			// next, line 44
250			if env.Cursor <= env.LimitBackward {
251				return false
252			}
253			env.PrevChar()
254			// ], line 44
255			env.Bra = env.Cursor
256			// delete, line 44
257			if !env.SliceDel() {
258				return false
259			}
260		} else if among_var == 3 {
261			// (, line 45
262			// atmark, line 45
263			if env.Cursor != context.i_p1 {
264				return false
265			}
266			// test, line 45
267			var v_4 = env.Limit - env.Cursor
268			// call shortv, line 45
269			if !r_shortv(env, context) {
270				return false
271			}
272			env.Cursor = env.Limit - v_4
273			{
274				// <+, line 45
275				var c = env.Cursor
276				bra, ket := env.Cursor, env.Cursor
277				env.Insert(bra, ket, "e")
278				env.Cursor = c
279			}
280		}
281	}
282	return true
283}
284
285func r_Step_1c(env *snowballRuntime.Env, ctx interface{}) bool {
286	context := ctx.(*Context)
287	_ = context
288	// (, line 51
289	// [, line 52
290	env.Ket = env.Cursor
291	// or, line 52
292lab0:
293	for {
294		var v_1 = env.Limit - env.Cursor
295	lab1:
296		for {
297			// literal, line 52
298			if !env.EqSB("y") {
299				break lab1
300			}
301			break lab0
302		}
303		env.Cursor = env.Limit - v_1
304		// literal, line 52
305		if !env.EqSB("Y") {
306			return false
307		}
308		break lab0
309	}
310	// ], line 52
311	env.Bra = env.Cursor
312	// gopast, line 53
313golab2:
314	for {
315	lab3:
316		for {
317			if !env.InGroupingB(G_v, 97, 121) {
318				break lab3
319			}
320			break golab2
321		}
322		if env.Cursor <= env.LimitBackward {
323			return false
324		}
325		env.PrevChar()
326	}
327	// <-, line 54
328	if !env.SliceFrom("i") {
329		return false
330	}
331	return true
332}
333
334func r_Step_2(env *snowballRuntime.Env, ctx interface{}) bool {
335	context := ctx.(*Context)
336	_ = context
337	var among_var int32
338	// (, line 57
339	// [, line 58
340	env.Ket = env.Cursor
341	// substring, line 58
342	among_var = env.FindAmongB(A_3, context)
343	if among_var == 0 {
344		return false
345	}
346	// ], line 58
347	env.Bra = env.Cursor
348	// call R1, line 58
349	if !r_R1(env, context) {
350		return false
351	}
352	if among_var == 0 {
353		return false
354	} else if among_var == 1 {
355		// (, line 59
356		// <-, line 59
357		if !env.SliceFrom("tion") {
358			return false
359		}
360	} else if among_var == 2 {
361		// (, line 60
362		// <-, line 60
363		if !env.SliceFrom("ence") {
364			return false
365		}
366	} else if among_var == 3 {
367		// (, line 61
368		// <-, line 61
369		if !env.SliceFrom("ance") {
370			return false
371		}
372	} else if among_var == 4 {
373		// (, line 62
374		// <-, line 62
375		if !env.SliceFrom("able") {
376			return false
377		}
378	} else if among_var == 5 {
379		// (, line 63
380		// <-, line 63
381		if !env.SliceFrom("ent") {
382			return false
383		}
384	} else if among_var == 6 {
385		// (, line 64
386		// <-, line 64
387		if !env.SliceFrom("e") {
388			return false
389		}
390	} else if among_var == 7 {
391		// (, line 66
392		// <-, line 66
393		if !env.SliceFrom("ize") {
394			return false
395		}
396	} else if among_var == 8 {
397		// (, line 68
398		// <-, line 68
399		if !env.SliceFrom("ate") {
400			return false
401		}
402	} else if among_var == 9 {
403		// (, line 69
404		// <-, line 69
405		if !env.SliceFrom("al") {
406			return false
407		}
408	} else if among_var == 10 {
409		// (, line 71
410		// <-, line 71
411		if !env.SliceFrom("al") {
412			return false
413		}
414	} else if among_var == 11 {
415		// (, line 72
416		// <-, line 72
417		if !env.SliceFrom("ful") {
418			return false
419		}
420	} else if among_var == 12 {
421		// (, line 74
422		// <-, line 74
423		if !env.SliceFrom("ous") {
424			return false
425		}
426	} else if among_var == 13 {
427		// (, line 76
428		// <-, line 76
429		if !env.SliceFrom("ive") {
430			return false
431		}
432	} else if among_var == 14 {
433		// (, line 77
434		// <-, line 77
435		if !env.SliceFrom("ble") {
436			return false
437		}
438	}
439	return true
440}
441
442func r_Step_3(env *snowballRuntime.Env, ctx interface{}) bool {
443	context := ctx.(*Context)
444	_ = context
445	var among_var int32
446	// (, line 81
447	// [, line 82
448	env.Ket = env.Cursor
449	// substring, line 82
450	among_var = env.FindAmongB(A_4, context)
451	if among_var == 0 {
452		return false
453	}
454	// ], line 82
455	env.Bra = env.Cursor
456	// call R1, line 82
457	if !r_R1(env, context) {
458		return false
459	}
460	if among_var == 0 {
461		return false
462	} else if among_var == 1 {
463		// (, line 83
464		// <-, line 83
465		if !env.SliceFrom("al") {
466			return false
467		}
468	} else if among_var == 2 {
469		// (, line 85
470		// <-, line 85
471		if !env.SliceFrom("ic") {
472			return false
473		}
474	} else if among_var == 3 {
475		// (, line 87
476		// delete, line 87
477		if !env.SliceDel() {
478			return false
479		}
480	}
481	return true
482}
483
484func r_Step_4(env *snowballRuntime.Env, ctx interface{}) bool {
485	context := ctx.(*Context)
486	_ = context
487	var among_var int32
488	// (, line 91
489	// [, line 92
490	env.Ket = env.Cursor
491	// substring, line 92
492	among_var = env.FindAmongB(A_5, context)
493	if among_var == 0 {
494		return false
495	}
496	// ], line 92
497	env.Bra = env.Cursor
498	// call R2, line 92
499	if !r_R2(env, context) {
500		return false
501	}
502	if among_var == 0 {
503		return false
504	} else if among_var == 1 {
505		// (, line 95
506		// delete, line 95
507		if !env.SliceDel() {
508			return false
509		}
510	} else if among_var == 2 {
511		// (, line 96
512		// or, line 96
513	lab0:
514		for {
515			var v_1 = env.Limit - env.Cursor
516		lab1:
517			for {
518				// literal, line 96
519				if !env.EqSB("s") {
520					break lab1
521				}
522				break lab0
523			}
524			env.Cursor = env.Limit - v_1
525			// literal, line 96
526			if !env.EqSB("t") {
527				return false
528			}
529			break lab0
530		}
531		// delete, line 96
532		if !env.SliceDel() {
533			return false
534		}
535	}
536	return true
537}
538
539func r_Step_5a(env *snowballRuntime.Env, ctx interface{}) bool {
540	context := ctx.(*Context)
541	_ = context
542	// (, line 100
543	// [, line 101
544	env.Ket = env.Cursor
545	// literal, line 101
546	if !env.EqSB("e") {
547		return false
548	}
549	// ], line 101
550	env.Bra = env.Cursor
551	// or, line 102
552lab0:
553	for {
554		var v_1 = env.Limit - env.Cursor
555	lab1:
556		for {
557			// call R2, line 102
558			if !r_R2(env, context) {
559				break lab1
560			}
561			break lab0
562		}
563		env.Cursor = env.Limit - v_1
564		// (, line 102
565		// call R1, line 102
566		if !r_R1(env, context) {
567			return false
568		}
569		// not, line 102
570		var v_2 = env.Limit - env.Cursor
571	lab2:
572		for {
573			// call shortv, line 102
574			if !r_shortv(env, context) {
575				break lab2
576			}
577			return false
578		}
579		env.Cursor = env.Limit - v_2
580		break lab0
581	}
582	// delete, line 103
583	if !env.SliceDel() {
584		return false
585	}
586	return true
587}
588
589func r_Step_5b(env *snowballRuntime.Env, ctx interface{}) bool {
590	context := ctx.(*Context)
591	_ = context
592	// (, line 106
593	// [, line 107
594	env.Ket = env.Cursor
595	// literal, line 107
596	if !env.EqSB("l") {
597		return false
598	}
599	// ], line 107
600	env.Bra = env.Cursor
601	// call R2, line 108
602	if !r_R2(env, context) {
603		return false
604	}
605	// literal, line 108
606	if !env.EqSB("l") {
607		return false
608	}
609	// delete, line 109
610	if !env.SliceDel() {
611		return false
612	}
613	return true
614}
615
616func Stem(env *snowballRuntime.Env) bool {
617	var context = &Context{
618		b_Y_found: false,
619		i_p2:      0,
620		i_p1:      0,
621	}
622	_ = context
623	// (, line 113
624	// unset Y_found, line 115
625	context.b_Y_found = false
626	// do, line 116
627	var v_1 = env.Cursor
628lab0:
629	for {
630		// (, line 116
631		// [, line 116
632		env.Bra = env.Cursor
633		// literal, line 116
634		if !env.EqS("y") {
635			break lab0
636		}
637		// ], line 116
638		env.Ket = env.Cursor
639		// <-, line 116
640		if !env.SliceFrom("Y") {
641			return false
642		}
643		// set Y_found, line 116
644		context.b_Y_found = true
645		break lab0
646	}
647	env.Cursor = v_1
648	// do, line 117
649	var v_2 = env.Cursor
650lab1:
651	for {
652		// repeat, line 117
653	replab2:
654		for {
655			var v_3 = env.Cursor
656		lab3:
657			for range [2]struct{}{} {
658				// (, line 117
659				// goto, line 117
660			golab4:
661				for {
662					var v_4 = env.Cursor
663				lab5:
664					for {
665						// (, line 117
666						if !env.InGrouping(G_v, 97, 121) {
667							break lab5
668						}
669						// [, line 117
670						env.Bra = env.Cursor
671						// literal, line 117
672						if !env.EqS("y") {
673							break lab5
674						}
675						// ], line 117
676						env.Ket = env.Cursor
677						env.Cursor = v_4
678						break golab4
679					}
680					env.Cursor = v_4
681					if env.Cursor >= env.Limit {
682						break lab3
683					}
684					env.NextChar()
685				}
686				// <-, line 117
687				if !env.SliceFrom("Y") {
688					return false
689				}
690				// set Y_found, line 117
691				context.b_Y_found = true
692				continue replab2
693			}
694			env.Cursor = v_3
695			break replab2
696		}
697		break lab1
698	}
699	env.Cursor = v_2
700	context.i_p1 = env.Limit
701	context.i_p2 = env.Limit
702	// do, line 121
703	var v_5 = env.Cursor
704lab6:
705	for {
706		// (, line 121
707		// gopast, line 122
708	golab7:
709		for {
710		lab8:
711			for {
712				if !env.InGrouping(G_v, 97, 121) {
713					break lab8
714				}
715				break golab7
716			}
717			if env.Cursor >= env.Limit {
718				break lab6
719			}
720			env.NextChar()
721		}
722		// gopast, line 122
723	golab9:
724		for {
725		lab10:
726			for {
727				if !env.OutGrouping(G_v, 97, 121) {
728					break lab10
729				}
730				break golab9
731			}
732			if env.Cursor >= env.Limit {
733				break lab6
734			}
735			env.NextChar()
736		}
737		// setmark p1, line 122
738		context.i_p1 = env.Cursor
739		// gopast, line 123
740	golab11:
741		for {
742		lab12:
743			for {
744				if !env.InGrouping(G_v, 97, 121) {
745					break lab12
746				}
747				break golab11
748			}
749			if env.Cursor >= env.Limit {
750				break lab6
751			}
752			env.NextChar()
753		}
754		// gopast, line 123
755	golab13:
756		for {
757		lab14:
758			for {
759				if !env.OutGrouping(G_v, 97, 121) {
760					break lab14
761				}
762				break golab13
763			}
764			if env.Cursor >= env.Limit {
765				break lab6
766			}
767			env.NextChar()
768		}
769		// setmark p2, line 123
770		context.i_p2 = env.Cursor
771		break lab6
772	}
773	env.Cursor = v_5
774	// backwards, line 126
775	env.LimitBackward = env.Cursor
776	env.Cursor = env.Limit
777	// (, line 126
778	// do, line 127
779	var v_10 = env.Limit - env.Cursor
780lab15:
781	for {
782		// call Step_1a, line 127
783		if !r_Step_1a(env, context) {
784			break lab15
785		}
786		break lab15
787	}
788	env.Cursor = env.Limit - v_10
789	// do, line 128
790	var v_11 = env.Limit - env.Cursor
791lab16:
792	for {
793		// call Step_1b, line 128
794		if !r_Step_1b(env, context) {
795			break lab16
796		}
797		break lab16
798	}
799	env.Cursor = env.Limit - v_11
800	// do, line 129
801	var v_12 = env.Limit - env.Cursor
802lab17:
803	for {
804		// call Step_1c, line 129
805		if !r_Step_1c(env, context) {
806			break lab17
807		}
808		break lab17
809	}
810	env.Cursor = env.Limit - v_12
811	// do, line 130
812	var v_13 = env.Limit - env.Cursor
813lab18:
814	for {
815		// call Step_2, line 130
816		if !r_Step_2(env, context) {
817			break lab18
818		}
819		break lab18
820	}
821	env.Cursor = env.Limit - v_13
822	// do, line 131
823	var v_14 = env.Limit - env.Cursor
824lab19:
825	for {
826		// call Step_3, line 131
827		if !r_Step_3(env, context) {
828			break lab19
829		}
830		break lab19
831	}
832	env.Cursor = env.Limit - v_14
833	// do, line 132
834	var v_15 = env.Limit - env.Cursor
835lab20:
836	for {
837		// call Step_4, line 132
838		if !r_Step_4(env, context) {
839			break lab20
840		}
841		break lab20
842	}
843	env.Cursor = env.Limit - v_15
844	// do, line 133
845	var v_16 = env.Limit - env.Cursor
846lab21:
847	for {
848		// call Step_5a, line 133
849		if !r_Step_5a(env, context) {
850			break lab21
851		}
852		break lab21
853	}
854	env.Cursor = env.Limit - v_16
855	// do, line 134
856	var v_17 = env.Limit - env.Cursor
857lab22:
858	for {
859		// call Step_5b, line 134
860		if !r_Step_5b(env, context) {
861			break lab22
862		}
863		break lab22
864	}
865	env.Cursor = env.Limit - v_17
866	env.Cursor = env.LimitBackward
867	// do, line 137
868	var v_18 = env.Cursor
869lab23:
870	for {
871		// (, line 137
872		// Boolean test Y_found, line 137
873		if !context.b_Y_found {
874			break lab23
875		}
876		// repeat, line 137
877	replab24:
878		for {
879			var v_19 = env.Cursor
880		lab25:
881			for range [2]struct{}{} {
882				// (, line 137
883				// goto, line 137
884			golab26:
885				for {
886					var v_20 = env.Cursor
887				lab27:
888					for {
889						// (, line 137
890						// [, line 137
891						env.Bra = env.Cursor
892						// literal, line 137
893						if !env.EqS("Y") {
894							break lab27
895						}
896						// ], line 137
897						env.Ket = env.Cursor
898						env.Cursor = v_20
899						break golab26
900					}
901					env.Cursor = v_20
902					if env.Cursor >= env.Limit {
903						break lab25
904					}
905					env.NextChar()
906				}
907				// <-, line 137
908				if !env.SliceFrom("y") {
909					return false
910				}
911				continue replab24
912			}
913			env.Cursor = v_19
914			break replab24
915		}
916		break lab23
917	}
918	env.Cursor = v_18
919	return true
920}
921