1//! This file was generated automatically by the Snowball to Go compiler
2//! http://snowballstem.org/
3
4package irish
5
6import (
7	snowballRuntime "github.com/blevesearch/snowballstem"
8)
9
10var A_0 = []*snowballRuntime.Among{
11	{Str: "b'", A: -1, B: 4, F: nil},
12	{Str: "bh", A: -1, B: 14, F: nil},
13	{Str: "bhf", A: 1, B: 9, F: nil},
14	{Str: "bp", A: -1, B: 11, F: nil},
15	{Str: "ch", A: -1, B: 15, F: nil},
16	{Str: "d'", A: -1, B: 2, F: nil},
17	{Str: "d'fh", A: 5, B: 3, F: nil},
18	{Str: "dh", A: -1, B: 16, F: nil},
19	{Str: "dt", A: -1, B: 13, F: nil},
20	{Str: "fh", A: -1, B: 17, F: nil},
21	{Str: "gc", A: -1, B: 7, F: nil},
22	{Str: "gh", A: -1, B: 18, F: nil},
23	{Str: "h-", A: -1, B: 1, F: nil},
24	{Str: "m'", A: -1, B: 4, F: nil},
25	{Str: "mb", A: -1, B: 6, F: nil},
26	{Str: "mh", A: -1, B: 19, F: nil},
27	{Str: "n-", A: -1, B: 1, F: nil},
28	{Str: "nd", A: -1, B: 8, F: nil},
29	{Str: "ng", A: -1, B: 10, F: nil},
30	{Str: "ph", A: -1, B: 20, F: nil},
31	{Str: "sh", A: -1, B: 5, F: nil},
32	{Str: "t-", A: -1, B: 1, F: nil},
33	{Str: "th", A: -1, B: 21, F: nil},
34	{Str: "ts", A: -1, B: 12, F: nil},
35}
36
37var A_1 = []*snowballRuntime.Among{
38	{Str: "\u00EDochta", A: -1, B: 1, F: nil},
39	{Str: "a\u00EDochta", A: 0, B: 1, F: nil},
40	{Str: "ire", A: -1, B: 2, F: nil},
41	{Str: "aire", A: 2, B: 2, F: nil},
42	{Str: "abh", A: -1, B: 1, F: nil},
43	{Str: "eabh", A: 4, B: 1, F: nil},
44	{Str: "ibh", A: -1, B: 1, F: nil},
45	{Str: "aibh", A: 6, B: 1, F: nil},
46	{Str: "amh", A: -1, B: 1, F: nil},
47	{Str: "eamh", A: 8, B: 1, F: nil},
48	{Str: "imh", A: -1, B: 1, F: nil},
49	{Str: "aimh", A: 10, B: 1, F: nil},
50	{Str: "\u00EDocht", A: -1, B: 1, F: nil},
51	{Str: "a\u00EDocht", A: 12, B: 1, F: nil},
52	{Str: "ir\u00ED", A: -1, B: 2, F: nil},
53	{Str: "air\u00ED", A: 14, B: 2, F: nil},
54}
55
56var A_2 = []*snowballRuntime.Among{
57	{Str: "\u00F3ideacha", A: -1, B: 6, F: nil},
58	{Str: "patacha", A: -1, B: 5, F: nil},
59	{Str: "achta", A: -1, B: 1, F: nil},
60	{Str: "arcachta", A: 2, B: 2, F: nil},
61	{Str: "eachta", A: 2, B: 1, F: nil},
62	{Str: "grafa\u00EDochta", A: -1, B: 4, F: nil},
63	{Str: "paite", A: -1, B: 5, F: nil},
64	{Str: "ach", A: -1, B: 1, F: nil},
65	{Str: "each", A: 7, B: 1, F: nil},
66	{Str: "\u00F3ideach", A: 8, B: 6, F: nil},
67	{Str: "gineach", A: 8, B: 3, F: nil},
68	{Str: "patach", A: 7, B: 5, F: nil},
69	{Str: "grafa\u00EDoch", A: -1, B: 4, F: nil},
70	{Str: "pataigh", A: -1, B: 5, F: nil},
71	{Str: "\u00F3idigh", A: -1, B: 6, F: nil},
72	{Str: "acht\u00FAil", A: -1, B: 1, F: nil},
73	{Str: "eacht\u00FAil", A: 15, B: 1, F: nil},
74	{Str: "gineas", A: -1, B: 3, F: nil},
75	{Str: "ginis", A: -1, B: 3, F: nil},
76	{Str: "acht", A: -1, B: 1, F: nil},
77	{Str: "arcacht", A: 19, B: 2, F: nil},
78	{Str: "eacht", A: 19, B: 1, F: nil},
79	{Str: "grafa\u00EDocht", A: -1, B: 4, F: nil},
80	{Str: "arcachta\u00ED", A: -1, B: 2, F: nil},
81	{Str: "grafa\u00EDochta\u00ED", A: -1, B: 4, F: nil},
82}
83
84var A_3 = []*snowballRuntime.Among{
85	{Str: "imid", A: -1, B: 1, F: nil},
86	{Str: "aimid", A: 0, B: 1, F: nil},
87	{Str: "\u00EDmid", A: -1, B: 1, F: nil},
88	{Str: "a\u00EDmid", A: 2, B: 1, F: nil},
89	{Str: "adh", A: -1, B: 2, F: nil},
90	{Str: "eadh", A: 4, B: 2, F: nil},
91	{Str: "faidh", A: -1, B: 1, F: nil},
92	{Str: "fidh", A: -1, B: 1, F: nil},
93	{Str: "\u00E1il", A: -1, B: 2, F: nil},
94	{Str: "ain", A: -1, B: 2, F: nil},
95	{Str: "tear", A: -1, B: 2, F: nil},
96	{Str: "tar", A: -1, B: 2, F: nil},
97}
98
99var G_v = []byte{17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 4, 2}
100
101type Context struct {
102	i_p2 int
103	i_p1 int
104	i_pV int
105}
106
107func r_mark_regions(env *snowballRuntime.Env, ctx interface{}) bool {
108	context := ctx.(*Context)
109	_ = context
110	// (, line 28
111	context.i_pV = env.Limit
112	context.i_p1 = env.Limit
113	context.i_p2 = env.Limit
114	// do, line 34
115	var v_1 = env.Cursor
116lab0:
117	for {
118		// (, line 34
119		// gopast, line 35
120	golab1:
121		for {
122		lab2:
123			for {
124				if !env.InGrouping(G_v, 97, 250) {
125					break lab2
126				}
127				break golab1
128			}
129			if env.Cursor >= env.Limit {
130				break lab0
131			}
132			env.NextChar()
133		}
134		// setmark pV, line 35
135		context.i_pV = env.Cursor
136		break lab0
137	}
138	env.Cursor = v_1
139	// do, line 37
140	var v_3 = env.Cursor
141lab3:
142	for {
143		// (, line 37
144		// gopast, line 38
145	golab4:
146		for {
147		lab5:
148			for {
149				if !env.InGrouping(G_v, 97, 250) {
150					break lab5
151				}
152				break golab4
153			}
154			if env.Cursor >= env.Limit {
155				break lab3
156			}
157			env.NextChar()
158		}
159		// gopast, line 38
160	golab6:
161		for {
162		lab7:
163			for {
164				if !env.OutGrouping(G_v, 97, 250) {
165					break lab7
166				}
167				break golab6
168			}
169			if env.Cursor >= env.Limit {
170				break lab3
171			}
172			env.NextChar()
173		}
174		// setmark p1, line 38
175		context.i_p1 = env.Cursor
176		// gopast, line 39
177	golab8:
178		for {
179		lab9:
180			for {
181				if !env.InGrouping(G_v, 97, 250) {
182					break lab9
183				}
184				break golab8
185			}
186			if env.Cursor >= env.Limit {
187				break lab3
188			}
189			env.NextChar()
190		}
191		// gopast, line 39
192	golab10:
193		for {
194		lab11:
195			for {
196				if !env.OutGrouping(G_v, 97, 250) {
197					break lab11
198				}
199				break golab10
200			}
201			if env.Cursor >= env.Limit {
202				break lab3
203			}
204			env.NextChar()
205		}
206		// setmark p2, line 39
207		context.i_p2 = env.Cursor
208		break lab3
209	}
210	env.Cursor = v_3
211	return true
212}
213
214func r_initial_morph(env *snowballRuntime.Env, ctx interface{}) bool {
215	context := ctx.(*Context)
216	_ = context
217	var among_var int32
218	// (, line 43
219	// [, line 44
220	env.Bra = env.Cursor
221	// substring, line 44
222	among_var = env.FindAmong(A_0, context)
223	if among_var == 0 {
224		return false
225	}
226	// ], line 44
227	env.Ket = env.Cursor
228	if among_var == 0 {
229		return false
230	} else if among_var == 1 {
231		// (, line 46
232		// delete, line 46
233		if !env.SliceDel() {
234			return false
235		}
236	} else if among_var == 2 {
237		// (, line 50
238		// delete, line 50
239		if !env.SliceDel() {
240			return false
241		}
242	} else if among_var == 3 {
243		// (, line 52
244		// <-, line 52
245		if !env.SliceFrom("f") {
246			return false
247		}
248	} else if among_var == 4 {
249		// (, line 55
250		// delete, line 55
251		if !env.SliceDel() {
252			return false
253		}
254	} else if among_var == 5 {
255		// (, line 58
256		// <-, line 58
257		if !env.SliceFrom("s") {
258			return false
259		}
260	} else if among_var == 6 {
261		// (, line 61
262		// <-, line 61
263		if !env.SliceFrom("b") {
264			return false
265		}
266	} else if among_var == 7 {
267		// (, line 63
268		// <-, line 63
269		if !env.SliceFrom("c") {
270			return false
271		}
272	} else if among_var == 8 {
273		// (, line 65
274		// <-, line 65
275		if !env.SliceFrom("d") {
276			return false
277		}
278	} else if among_var == 9 {
279		// (, line 67
280		// <-, line 67
281		if !env.SliceFrom("f") {
282			return false
283		}
284	} else if among_var == 10 {
285		// (, line 69
286		// <-, line 69
287		if !env.SliceFrom("g") {
288			return false
289		}
290	} else if among_var == 11 {
291		// (, line 71
292		// <-, line 71
293		if !env.SliceFrom("p") {
294			return false
295		}
296	} else if among_var == 12 {
297		// (, line 73
298		// <-, line 73
299		if !env.SliceFrom("s") {
300			return false
301		}
302	} else if among_var == 13 {
303		// (, line 75
304		// <-, line 75
305		if !env.SliceFrom("t") {
306			return false
307		}
308	} else if among_var == 14 {
309		// (, line 79
310		// <-, line 79
311		if !env.SliceFrom("b") {
312			return false
313		}
314	} else if among_var == 15 {
315		// (, line 81
316		// <-, line 81
317		if !env.SliceFrom("c") {
318			return false
319		}
320	} else if among_var == 16 {
321		// (, line 83
322		// <-, line 83
323		if !env.SliceFrom("d") {
324			return false
325		}
326	} else if among_var == 17 {
327		// (, line 85
328		// <-, line 85
329		if !env.SliceFrom("f") {
330			return false
331		}
332	} else if among_var == 18 {
333		// (, line 87
334		// <-, line 87
335		if !env.SliceFrom("g") {
336			return false
337		}
338	} else if among_var == 19 {
339		// (, line 89
340		// <-, line 89
341		if !env.SliceFrom("m") {
342			return false
343		}
344	} else if among_var == 20 {
345		// (, line 91
346		// <-, line 91
347		if !env.SliceFrom("p") {
348			return false
349		}
350	} else if among_var == 21 {
351		// (, line 93
352		// <-, line 93
353		if !env.SliceFrom("t") {
354			return false
355		}
356	}
357	return true
358}
359
360func r_RV(env *snowballRuntime.Env, ctx interface{}) bool {
361	context := ctx.(*Context)
362	_ = context
363	if !(context.i_pV <= env.Cursor) {
364		return false
365	}
366	return true
367}
368
369func r_R1(env *snowballRuntime.Env, ctx interface{}) bool {
370	context := ctx.(*Context)
371	_ = context
372	if !(context.i_p1 <= env.Cursor) {
373		return false
374	}
375	return true
376}
377
378func r_R2(env *snowballRuntime.Env, ctx interface{}) bool {
379	context := ctx.(*Context)
380	_ = context
381	if !(context.i_p2 <= env.Cursor) {
382		return false
383	}
384	return true
385}
386
387func r_noun_sfx(env *snowballRuntime.Env, ctx interface{}) bool {
388	context := ctx.(*Context)
389	_ = context
390	var among_var int32
391	// (, line 103
392	// [, line 104
393	env.Ket = env.Cursor
394	// substring, line 104
395	among_var = env.FindAmongB(A_1, context)
396	if among_var == 0 {
397		return false
398	}
399	// ], line 104
400	env.Bra = env.Cursor
401	if among_var == 0 {
402		return false
403	} else if among_var == 1 {
404		// (, line 108
405		// call R1, line 108
406		if !r_R1(env, context) {
407			return false
408		}
409		// delete, line 108
410		if !env.SliceDel() {
411			return false
412		}
413	} else if among_var == 2 {
414		// (, line 110
415		// call R2, line 110
416		if !r_R2(env, context) {
417			return false
418		}
419		// delete, line 110
420		if !env.SliceDel() {
421			return false
422		}
423	}
424	return true
425}
426
427func r_deriv(env *snowballRuntime.Env, ctx interface{}) bool {
428	context := ctx.(*Context)
429	_ = context
430	var among_var int32
431	// (, line 113
432	// [, line 114
433	env.Ket = env.Cursor
434	// substring, line 114
435	among_var = env.FindAmongB(A_2, context)
436	if among_var == 0 {
437		return false
438	}
439	// ], line 114
440	env.Bra = env.Cursor
441	if among_var == 0 {
442		return false
443	} else if among_var == 1 {
444		// (, line 116
445		// call R2, line 116
446		if !r_R2(env, context) {
447			return false
448		}
449		// delete, line 116
450		if !env.SliceDel() {
451			return false
452		}
453	} else if among_var == 2 {
454		// (, line 118
455		// <-, line 118
456		if !env.SliceFrom("arc") {
457			return false
458		}
459	} else if among_var == 3 {
460		// (, line 120
461		// <-, line 120
462		if !env.SliceFrom("gin") {
463			return false
464		}
465	} else if among_var == 4 {
466		// (, line 122
467		// <-, line 122
468		if !env.SliceFrom("graf") {
469			return false
470		}
471	} else if among_var == 5 {
472		// (, line 124
473		// <-, line 124
474		if !env.SliceFrom("paite") {
475			return false
476		}
477	} else if among_var == 6 {
478		// (, line 126
479		// <-, line 126
480		if !env.SliceFrom("\u00F3id") {
481			return false
482		}
483	}
484	return true
485}
486
487func r_verb_sfx(env *snowballRuntime.Env, ctx interface{}) bool {
488	context := ctx.(*Context)
489	_ = context
490	var among_var int32
491	// (, line 129
492	// [, line 130
493	env.Ket = env.Cursor
494	// substring, line 130
495	among_var = env.FindAmongB(A_3, context)
496	if among_var == 0 {
497		return false
498	}
499	// ], line 130
500	env.Bra = env.Cursor
501	if among_var == 0 {
502		return false
503	} else if among_var == 1 {
504		// (, line 133
505		// call RV, line 133
506		if !r_RV(env, context) {
507			return false
508		}
509		// delete, line 133
510		if !env.SliceDel() {
511			return false
512		}
513	} else if among_var == 2 {
514		// (, line 138
515		// call R1, line 138
516		if !r_R1(env, context) {
517			return false
518		}
519		// delete, line 138
520		if !env.SliceDel() {
521			return false
522		}
523	}
524	return true
525}
526
527func Stem(env *snowballRuntime.Env) bool {
528	var context = &Context{
529		i_p2: 0,
530		i_p1: 0,
531		i_pV: 0,
532	}
533	_ = context
534	// (, line 143
535	// do, line 144
536	var v_1 = env.Cursor
537lab0:
538	for {
539		// call initial_morph, line 144
540		if !r_initial_morph(env, context) {
541			break lab0
542		}
543		break lab0
544	}
545	env.Cursor = v_1
546	// do, line 145
547	var v_2 = env.Cursor
548lab1:
549	for {
550		// call mark_regions, line 145
551		if !r_mark_regions(env, context) {
552			break lab1
553		}
554		break lab1
555	}
556	env.Cursor = v_2
557	// backwards, line 146
558	env.LimitBackward = env.Cursor
559	env.Cursor = env.Limit
560	// (, line 146
561	// do, line 147
562	var v_3 = env.Limit - env.Cursor
563lab2:
564	for {
565		// call noun_sfx, line 147
566		if !r_noun_sfx(env, context) {
567			break lab2
568		}
569		break lab2
570	}
571	env.Cursor = env.Limit - v_3
572	// do, line 148
573	var v_4 = env.Limit - env.Cursor
574lab3:
575	for {
576		// call deriv, line 148
577		if !r_deriv(env, context) {
578			break lab3
579		}
580		break lab3
581	}
582	env.Cursor = env.Limit - v_4
583	// do, line 149
584	var v_5 = env.Limit - env.Cursor
585lab4:
586	for {
587		// call verb_sfx, line 149
588		if !r_verb_sfx(env, context) {
589			break lab4
590		}
591		break lab4
592	}
593	env.Cursor = env.Limit - v_5
594	env.Cursor = env.LimitBackward
595	return true
596}
597