1 //! This file was generated automatically by the Snowball to Rust compiler
2 //! http://snowballstem.org/
3 
4 #![allow(non_upper_case_globals)]
5 #![allow(non_snake_case)]
6 #![allow(unused_variables)]
7 #![allow(unused_mut)]
8 use snowball::SnowballEnv;
9 use snowball::Among;
10 
11 static A_0: &'static [Among<Context>; 8] = &[
12     Among("cs", -1, -1, None),
13     Among("dzs", -1, -1, None),
14     Among("gy", -1, -1, None),
15     Among("ly", -1, -1, None),
16     Among("ny", -1, -1, None),
17     Among("sz", -1, -1, None),
18     Among("ty", -1, -1, None),
19     Among("zs", -1, -1, None),
20 ];
21 
22 static A_1: &'static [Among<Context>; 2] = &[
23     Among("\u{00E1}", -1, 1, None),
24     Among("\u{00E9}", -1, 2, None),
25 ];
26 
27 static A_2: &'static [Among<Context>; 23] = &[
28     Among("bb", -1, -1, None),
29     Among("cc", -1, -1, None),
30     Among("dd", -1, -1, None),
31     Among("ff", -1, -1, None),
32     Among("gg", -1, -1, None),
33     Among("jj", -1, -1, None),
34     Among("kk", -1, -1, None),
35     Among("ll", -1, -1, None),
36     Among("mm", -1, -1, None),
37     Among("nn", -1, -1, None),
38     Among("pp", -1, -1, None),
39     Among("rr", -1, -1, None),
40     Among("ccs", -1, -1, None),
41     Among("ss", -1, -1, None),
42     Among("zzs", -1, -1, None),
43     Among("tt", -1, -1, None),
44     Among("vv", -1, -1, None),
45     Among("ggy", -1, -1, None),
46     Among("lly", -1, -1, None),
47     Among("nny", -1, -1, None),
48     Among("tty", -1, -1, None),
49     Among("ssz", -1, -1, None),
50     Among("zz", -1, -1, None),
51 ];
52 
53 static A_3: &'static [Among<Context>; 2] = &[
54     Among("al", -1, 1, None),
55     Among("el", -1, 2, None),
56 ];
57 
58 static A_4: &'static [Among<Context>; 44] = &[
59     Among("ba", -1, -1, None),
60     Among("ra", -1, -1, None),
61     Among("be", -1, -1, None),
62     Among("re", -1, -1, None),
63     Among("ig", -1, -1, None),
64     Among("nak", -1, -1, None),
65     Among("nek", -1, -1, None),
66     Among("val", -1, -1, None),
67     Among("vel", -1, -1, None),
68     Among("ul", -1, -1, None),
69     Among("b\u{0151}l", -1, -1, None),
70     Among("r\u{0151}l", -1, -1, None),
71     Among("t\u{0151}l", -1, -1, None),
72     Among("n\u{00E1}l", -1, -1, None),
73     Among("n\u{00E9}l", -1, -1, None),
74     Among("b\u{00F3}l", -1, -1, None),
75     Among("r\u{00F3}l", -1, -1, None),
76     Among("t\u{00F3}l", -1, -1, None),
77     Among("\u{00FC}l", -1, -1, None),
78     Among("n", -1, -1, None),
79     Among("an", 19, -1, None),
80     Among("ban", 20, -1, None),
81     Among("en", 19, -1, None),
82     Among("ben", 22, -1, None),
83     Among("k\u{00E9}ppen", 22, -1, None),
84     Among("on", 19, -1, None),
85     Among("\u{00F6}n", 19, -1, None),
86     Among("k\u{00E9}pp", -1, -1, None),
87     Among("kor", -1, -1, None),
88     Among("t", -1, -1, None),
89     Among("at", 29, -1, None),
90     Among("et", 29, -1, None),
91     Among("k\u{00E9}nt", 29, -1, None),
92     Among("ank\u{00E9}nt", 32, -1, None),
93     Among("enk\u{00E9}nt", 32, -1, None),
94     Among("onk\u{00E9}nt", 32, -1, None),
95     Among("ot", 29, -1, None),
96     Among("\u{00E9}rt", 29, -1, None),
97     Among("\u{00F6}t", 29, -1, None),
98     Among("hez", -1, -1, None),
99     Among("hoz", -1, -1, None),
100     Among("h\u{00F6}z", -1, -1, None),
101     Among("v\u{00E1}", -1, -1, None),
102     Among("v\u{00E9}", -1, -1, None),
103 ];
104 
105 static A_5: &'static [Among<Context>; 3] = &[
106     Among("\u{00E1}n", -1, 2, None),
107     Among("\u{00E9}n", -1, 1, None),
108     Among("\u{00E1}nk\u{00E9}nt", -1, 3, None),
109 ];
110 
111 static A_6: &'static [Among<Context>; 6] = &[
112     Among("stul", -1, 2, None),
113     Among("astul", 0, 1, None),
114     Among("\u{00E1}stul", 0, 3, None),
115     Among("st\u{00FC}l", -1, 2, None),
116     Among("est\u{00FC}l", 3, 1, None),
117     Among("\u{00E9}st\u{00FC}l", 3, 4, None),
118 ];
119 
120 static A_7: &'static [Among<Context>; 2] = &[
121     Among("\u{00E1}", -1, 1, None),
122     Among("\u{00E9}", -1, 2, None),
123 ];
124 
125 static A_8: &'static [Among<Context>; 7] = &[
126     Among("k", -1, 7, None),
127     Among("ak", 0, 4, None),
128     Among("ek", 0, 6, None),
129     Among("ok", 0, 5, None),
130     Among("\u{00E1}k", 0, 1, None),
131     Among("\u{00E9}k", 0, 2, None),
132     Among("\u{00F6}k", 0, 3, None),
133 ];
134 
135 static A_9: &'static [Among<Context>; 12] = &[
136     Among("\u{00E9}i", -1, 7, None),
137     Among("\u{00E1}\u{00E9}i", 0, 6, None),
138     Among("\u{00E9}\u{00E9}i", 0, 5, None),
139     Among("\u{00E9}", -1, 9, None),
140     Among("k\u{00E9}", 3, 4, None),
141     Among("ak\u{00E9}", 4, 1, None),
142     Among("ek\u{00E9}", 4, 1, None),
143     Among("ok\u{00E9}", 4, 1, None),
144     Among("\u{00E1}k\u{00E9}", 4, 3, None),
145     Among("\u{00E9}k\u{00E9}", 4, 2, None),
146     Among("\u{00F6}k\u{00E9}", 4, 1, None),
147     Among("\u{00E9}\u{00E9}", 3, 8, None),
148 ];
149 
150 static A_10: &'static [Among<Context>; 31] = &[
151     Among("a", -1, 18, None),
152     Among("ja", 0, 17, None),
153     Among("d", -1, 16, None),
154     Among("ad", 2, 13, None),
155     Among("ed", 2, 13, None),
156     Among("od", 2, 13, None),
157     Among("\u{00E1}d", 2, 14, None),
158     Among("\u{00E9}d", 2, 15, None),
159     Among("\u{00F6}d", 2, 13, None),
160     Among("e", -1, 18, None),
161     Among("je", 9, 17, None),
162     Among("nk", -1, 4, None),
163     Among("unk", 11, 1, None),
164     Among("\u{00E1}nk", 11, 2, None),
165     Among("\u{00E9}nk", 11, 3, None),
166     Among("\u{00FC}nk", 11, 1, None),
167     Among("uk", -1, 8, None),
168     Among("juk", 16, 7, None),
169     Among("\u{00E1}juk", 17, 5, None),
170     Among("\u{00FC}k", -1, 8, None),
171     Among("j\u{00FC}k", 19, 7, None),
172     Among("\u{00E9}j\u{00FC}k", 20, 6, None),
173     Among("m", -1, 12, None),
174     Among("am", 22, 9, None),
175     Among("em", 22, 9, None),
176     Among("om", 22, 9, None),
177     Among("\u{00E1}m", 22, 10, None),
178     Among("\u{00E9}m", 22, 11, None),
179     Among("o", -1, 18, None),
180     Among("\u{00E1}", -1, 19, None),
181     Among("\u{00E9}", -1, 20, None),
182 ];
183 
184 static A_11: &'static [Among<Context>; 42] = &[
185     Among("id", -1, 10, None),
186     Among("aid", 0, 9, None),
187     Among("jaid", 1, 6, None),
188     Among("eid", 0, 9, None),
189     Among("jeid", 3, 6, None),
190     Among("\u{00E1}id", 0, 7, None),
191     Among("\u{00E9}id", 0, 8, None),
192     Among("i", -1, 15, None),
193     Among("ai", 7, 14, None),
194     Among("jai", 8, 11, None),
195     Among("ei", 7, 14, None),
196     Among("jei", 10, 11, None),
197     Among("\u{00E1}i", 7, 12, None),
198     Among("\u{00E9}i", 7, 13, None),
199     Among("itek", -1, 24, None),
200     Among("eitek", 14, 21, None),
201     Among("jeitek", 15, 20, None),
202     Among("\u{00E9}itek", 14, 23, None),
203     Among("ik", -1, 29, None),
204     Among("aik", 18, 26, None),
205     Among("jaik", 19, 25, None),
206     Among("eik", 18, 26, None),
207     Among("jeik", 21, 25, None),
208     Among("\u{00E1}ik", 18, 27, None),
209     Among("\u{00E9}ik", 18, 28, None),
210     Among("ink", -1, 20, None),
211     Among("aink", 25, 17, None),
212     Among("jaink", 26, 16, None),
213     Among("eink", 25, 17, None),
214     Among("jeink", 28, 16, None),
215     Among("\u{00E1}ink", 25, 18, None),
216     Among("\u{00E9}ink", 25, 19, None),
217     Among("aitok", -1, 21, None),
218     Among("jaitok", 32, 20, None),
219     Among("\u{00E1}itok", -1, 22, None),
220     Among("im", -1, 5, None),
221     Among("aim", 35, 4, None),
222     Among("jaim", 36, 1, None),
223     Among("eim", 35, 4, None),
224     Among("jeim", 38, 1, None),
225     Among("\u{00E1}im", 35, 2, None),
226     Among("\u{00E9}im", 35, 3, None),
227 ];
228 
229 static G_v: &'static [u8; 35] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 36, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1];
230 
231 #[derive(Clone)]
232 struct Context {
233     i_p1: usize,
234 }
235 
236 fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
237     // (, line 44
238     context.i_p1 = env.limit;
239     // or, line 51
240     'lab0: loop {
241         let v_1 = env.cursor;
242         'lab1: loop {
243             // (, line 48
244             if !env.in_grouping(G_v, 97, 369) {
245                 break 'lab1;
246             }
247             // goto, line 48
248             'golab2: loop {
249                 let v_2 = env.cursor;
250                 'lab3: loop {
251                     if !env.out_grouping(G_v, 97, 369) {
252                         break 'lab3;
253                     }
254                     env.cursor = v_2;
255                     break 'golab2;
256                 }
257                 env.cursor = v_2;
258                 if env.cursor >= env.limit {
259                     break 'lab1;
260                 }
261                 env.next_char();
262             }
263             // or, line 49
264             'lab4: loop {
265                 let v_3 = env.cursor;
266                 'lab5: loop {
267                     // among, line 49
268                     if env.find_among(A_0, context) == 0 {
269                         break 'lab5;
270                     }
271                     break 'lab4;
272                 }
273                 env.cursor = v_3;
274                 // next, line 49
275                 if env.cursor >= env.limit {
276                     break 'lab1;
277                 }
278                 env.next_char();
279                 break 'lab4;
280             }
281             // setmark p1, line 50
282             context.i_p1 = env.cursor;
283             break 'lab0;
284         }
285         env.cursor = v_1;
286         // (, line 53
287         if !env.out_grouping(G_v, 97, 369) {
288             return false;
289         }
290         // gopast, line 53
291         'golab6: loop {
292             'lab7: loop {
293                 if !env.in_grouping(G_v, 97, 369) {
294                     break 'lab7;
295                 }
296                 break 'golab6;
297             }
298             if env.cursor >= env.limit {
299                 return false;
300             }
301             env.next_char();
302         }
303         // setmark p1, line 53
304         context.i_p1 = env.cursor;
305         break 'lab0;
306     }
307     return true;
308 }
309 
310 fn r_R1(env: &mut SnowballEnv, context: &mut Context) -> bool {
311     if !(context.i_p1 <= env.cursor){
312         return false;
313     }
314     return true;
315 }
316 
317 fn r_v_ending(env: &mut SnowballEnv, context: &mut Context) -> bool {
318     let mut among_var;
319     // (, line 60
320     // [, line 61
321     env.ket = env.cursor;
322     // substring, line 61
323     among_var = env.find_among_b(A_1, context);
324     if among_var == 0 {
325         return false;
326     }
327     // ], line 61
328     env.bra = env.cursor;
329     // call R1, line 61
330     if !r_R1(env, context) {
331         return false;
332     }
333     if among_var == 0 {
334         return false;
335     } else if among_var == 1 {
336         // (, line 62
337         // <-, line 62
338         if !env.slice_from("a") {
339             return false;
340         }
341     } else if among_var == 2 {
342         // (, line 63
343         // <-, line 63
344         if !env.slice_from("e") {
345             return false;
346         }
347     }
348     return true;
349 }
350 
351 fn r_double(env: &mut SnowballEnv, context: &mut Context) -> bool {
352     // (, line 67
353     // test, line 68
354     let v_1 = env.limit - env.cursor;
355     // among, line 68
356     if env.find_among_b(A_2, context) == 0 {
357         return false;
358     }
359     env.cursor = env.limit - v_1;
360     return true;
361 }
362 
363 fn r_undouble(env: &mut SnowballEnv, context: &mut Context) -> bool {
364     // (, line 72
365     // next, line 73
366     if env.cursor <= env.limit_backward {
367         return false;
368     }
369     env.previous_char();
370     // [, line 73
371     env.ket = env.cursor;
372     // hop, line 73
373     let c = env.byte_index_for_hop(-1);
374     if env.limit_backward as i32 > c || c > env.limit as i32 {
375         return false;
376     }
377     env.cursor = c as usize;
378     // ], line 73
379     env.bra = env.cursor;
380     // delete, line 73
381     if !env.slice_del() {
382         return false;
383     }
384     return true;
385 }
386 
387 fn r_instrum(env: &mut SnowballEnv, context: &mut Context) -> bool {
388     let mut among_var;
389     // (, line 76
390     // [, line 77
391     env.ket = env.cursor;
392     // substring, line 77
393     among_var = env.find_among_b(A_3, context);
394     if among_var == 0 {
395         return false;
396     }
397     // ], line 77
398     env.bra = env.cursor;
399     // call R1, line 77
400     if !r_R1(env, context) {
401         return false;
402     }
403     if among_var == 0 {
404         return false;
405     } else if among_var == 1 {
406         // (, line 78
407         // call double, line 78
408         if !r_double(env, context) {
409             return false;
410         }
411     } else if among_var == 2 {
412         // (, line 79
413         // call double, line 79
414         if !r_double(env, context) {
415             return false;
416         }
417     }
418     // delete, line 81
419     if !env.slice_del() {
420         return false;
421     }
422     // call undouble, line 82
423     if !r_undouble(env, context) {
424         return false;
425     }
426     return true;
427 }
428 
429 fn r_case(env: &mut SnowballEnv, context: &mut Context) -> bool {
430     // (, line 86
431     // [, line 87
432     env.ket = env.cursor;
433     // substring, line 87
434     if env.find_among_b(A_4, context) == 0 {
435         return false;
436     }
437     // ], line 87
438     env.bra = env.cursor;
439     // call R1, line 87
440     if !r_R1(env, context) {
441         return false;
442     }
443     // delete, line 111
444     if !env.slice_del() {
445         return false;
446     }
447     // call v_ending, line 112
448     if !r_v_ending(env, context) {
449         return false;
450     }
451     return true;
452 }
453 
454 fn r_case_special(env: &mut SnowballEnv, context: &mut Context) -> bool {
455     let mut among_var;
456     // (, line 115
457     // [, line 116
458     env.ket = env.cursor;
459     // substring, line 116
460     among_var = env.find_among_b(A_5, context);
461     if among_var == 0 {
462         return false;
463     }
464     // ], line 116
465     env.bra = env.cursor;
466     // call R1, line 116
467     if !r_R1(env, context) {
468         return false;
469     }
470     if among_var == 0 {
471         return false;
472     } else if among_var == 1 {
473         // (, line 117
474         // <-, line 117
475         if !env.slice_from("e") {
476             return false;
477         }
478     } else if among_var == 2 {
479         // (, line 118
480         // <-, line 118
481         if !env.slice_from("a") {
482             return false;
483         }
484     } else if among_var == 3 {
485         // (, line 119
486         // <-, line 119
487         if !env.slice_from("a") {
488             return false;
489         }
490     }
491     return true;
492 }
493 
494 fn r_case_other(env: &mut SnowballEnv, context: &mut Context) -> bool {
495     let mut among_var;
496     // (, line 123
497     // [, line 124
498     env.ket = env.cursor;
499     // substring, line 124
500     among_var = env.find_among_b(A_6, context);
501     if among_var == 0 {
502         return false;
503     }
504     // ], line 124
505     env.bra = env.cursor;
506     // call R1, line 124
507     if !r_R1(env, context) {
508         return false;
509     }
510     if among_var == 0 {
511         return false;
512     } else if among_var == 1 {
513         // (, line 125
514         // delete, line 125
515         if !env.slice_del() {
516             return false;
517         }
518     } else if among_var == 2 {
519         // (, line 126
520         // delete, line 126
521         if !env.slice_del() {
522             return false;
523         }
524     } else if among_var == 3 {
525         // (, line 127
526         // <-, line 127
527         if !env.slice_from("a") {
528             return false;
529         }
530     } else if among_var == 4 {
531         // (, line 128
532         // <-, line 128
533         if !env.slice_from("e") {
534             return false;
535         }
536     }
537     return true;
538 }
539 
540 fn r_factive(env: &mut SnowballEnv, context: &mut Context) -> bool {
541     let mut among_var;
542     // (, line 132
543     // [, line 133
544     env.ket = env.cursor;
545     // substring, line 133
546     among_var = env.find_among_b(A_7, context);
547     if among_var == 0 {
548         return false;
549     }
550     // ], line 133
551     env.bra = env.cursor;
552     // call R1, line 133
553     if !r_R1(env, context) {
554         return false;
555     }
556     if among_var == 0 {
557         return false;
558     } else if among_var == 1 {
559         // (, line 134
560         // call double, line 134
561         if !r_double(env, context) {
562             return false;
563         }
564     } else if among_var == 2 {
565         // (, line 135
566         // call double, line 135
567         if !r_double(env, context) {
568             return false;
569         }
570     }
571     // delete, line 137
572     if !env.slice_del() {
573         return false;
574     }
575     // call undouble, line 138
576     if !r_undouble(env, context) {
577         return false;
578     }
579     return true;
580 }
581 
582 fn r_plural(env: &mut SnowballEnv, context: &mut Context) -> bool {
583     let mut among_var;
584     // (, line 141
585     // [, line 142
586     env.ket = env.cursor;
587     // substring, line 142
588     among_var = env.find_among_b(A_8, context);
589     if among_var == 0 {
590         return false;
591     }
592     // ], line 142
593     env.bra = env.cursor;
594     // call R1, line 142
595     if !r_R1(env, context) {
596         return false;
597     }
598     if among_var == 0 {
599         return false;
600     } else if among_var == 1 {
601         // (, line 143
602         // <-, line 143
603         if !env.slice_from("a") {
604             return false;
605         }
606     } else if among_var == 2 {
607         // (, line 144
608         // <-, line 144
609         if !env.slice_from("e") {
610             return false;
611         }
612     } else if among_var == 3 {
613         // (, line 145
614         // delete, line 145
615         if !env.slice_del() {
616             return false;
617         }
618     } else if among_var == 4 {
619         // (, line 146
620         // delete, line 146
621         if !env.slice_del() {
622             return false;
623         }
624     } else if among_var == 5 {
625         // (, line 147
626         // delete, line 147
627         if !env.slice_del() {
628             return false;
629         }
630     } else if among_var == 6 {
631         // (, line 148
632         // delete, line 148
633         if !env.slice_del() {
634             return false;
635         }
636     } else if among_var == 7 {
637         // (, line 149
638         // delete, line 149
639         if !env.slice_del() {
640             return false;
641         }
642     }
643     return true;
644 }
645 
646 fn r_owned(env: &mut SnowballEnv, context: &mut Context) -> bool {
647     let mut among_var;
648     // (, line 153
649     // [, line 154
650     env.ket = env.cursor;
651     // substring, line 154
652     among_var = env.find_among_b(A_9, context);
653     if among_var == 0 {
654         return false;
655     }
656     // ], line 154
657     env.bra = env.cursor;
658     // call R1, line 154
659     if !r_R1(env, context) {
660         return false;
661     }
662     if among_var == 0 {
663         return false;
664     } else if among_var == 1 {
665         // (, line 155
666         // delete, line 155
667         if !env.slice_del() {
668             return false;
669         }
670     } else if among_var == 2 {
671         // (, line 156
672         // <-, line 156
673         if !env.slice_from("e") {
674             return false;
675         }
676     } else if among_var == 3 {
677         // (, line 157
678         // <-, line 157
679         if !env.slice_from("a") {
680             return false;
681         }
682     } else if among_var == 4 {
683         // (, line 158
684         // delete, line 158
685         if !env.slice_del() {
686             return false;
687         }
688     } else if among_var == 5 {
689         // (, line 159
690         // <-, line 159
691         if !env.slice_from("e") {
692             return false;
693         }
694     } else if among_var == 6 {
695         // (, line 160
696         // <-, line 160
697         if !env.slice_from("a") {
698             return false;
699         }
700     } else if among_var == 7 {
701         // (, line 161
702         // delete, line 161
703         if !env.slice_del() {
704             return false;
705         }
706     } else if among_var == 8 {
707         // (, line 162
708         // <-, line 162
709         if !env.slice_from("e") {
710             return false;
711         }
712     } else if among_var == 9 {
713         // (, line 163
714         // delete, line 163
715         if !env.slice_del() {
716             return false;
717         }
718     }
719     return true;
720 }
721 
722 fn r_sing_owner(env: &mut SnowballEnv, context: &mut Context) -> bool {
723     let mut among_var;
724     // (, line 167
725     // [, line 168
726     env.ket = env.cursor;
727     // substring, line 168
728     among_var = env.find_among_b(A_10, context);
729     if among_var == 0 {
730         return false;
731     }
732     // ], line 168
733     env.bra = env.cursor;
734     // call R1, line 168
735     if !r_R1(env, context) {
736         return false;
737     }
738     if among_var == 0 {
739         return false;
740     } else if among_var == 1 {
741         // (, line 169
742         // delete, line 169
743         if !env.slice_del() {
744             return false;
745         }
746     } else if among_var == 2 {
747         // (, line 170
748         // <-, line 170
749         if !env.slice_from("a") {
750             return false;
751         }
752     } else if among_var == 3 {
753         // (, line 171
754         // <-, line 171
755         if !env.slice_from("e") {
756             return false;
757         }
758     } else if among_var == 4 {
759         // (, line 172
760         // delete, line 172
761         if !env.slice_del() {
762             return false;
763         }
764     } else if among_var == 5 {
765         // (, line 173
766         // <-, line 173
767         if !env.slice_from("a") {
768             return false;
769         }
770     } else if among_var == 6 {
771         // (, line 174
772         // <-, line 174
773         if !env.slice_from("e") {
774             return false;
775         }
776     } else if among_var == 7 {
777         // (, line 175
778         // delete, line 175
779         if !env.slice_del() {
780             return false;
781         }
782     } else if among_var == 8 {
783         // (, line 176
784         // delete, line 176
785         if !env.slice_del() {
786             return false;
787         }
788     } else if among_var == 9 {
789         // (, line 177
790         // delete, line 177
791         if !env.slice_del() {
792             return false;
793         }
794     } else if among_var == 10 {
795         // (, line 178
796         // <-, line 178
797         if !env.slice_from("a") {
798             return false;
799         }
800     } else if among_var == 11 {
801         // (, line 179
802         // <-, line 179
803         if !env.slice_from("e") {
804             return false;
805         }
806     } else if among_var == 12 {
807         // (, line 180
808         // delete, line 180
809         if !env.slice_del() {
810             return false;
811         }
812     } else if among_var == 13 {
813         // (, line 181
814         // delete, line 181
815         if !env.slice_del() {
816             return false;
817         }
818     } else if among_var == 14 {
819         // (, line 182
820         // <-, line 182
821         if !env.slice_from("a") {
822             return false;
823         }
824     } else if among_var == 15 {
825         // (, line 183
826         // <-, line 183
827         if !env.slice_from("e") {
828             return false;
829         }
830     } else if among_var == 16 {
831         // (, line 184
832         // delete, line 184
833         if !env.slice_del() {
834             return false;
835         }
836     } else if among_var == 17 {
837         // (, line 185
838         // delete, line 185
839         if !env.slice_del() {
840             return false;
841         }
842     } else if among_var == 18 {
843         // (, line 186
844         // delete, line 186
845         if !env.slice_del() {
846             return false;
847         }
848     } else if among_var == 19 {
849         // (, line 187
850         // <-, line 187
851         if !env.slice_from("a") {
852             return false;
853         }
854     } else if among_var == 20 {
855         // (, line 188
856         // <-, line 188
857         if !env.slice_from("e") {
858             return false;
859         }
860     }
861     return true;
862 }
863 
864 fn r_plur_owner(env: &mut SnowballEnv, context: &mut Context) -> bool {
865     let mut among_var;
866     // (, line 192
867     // [, line 193
868     env.ket = env.cursor;
869     // substring, line 193
870     among_var = env.find_among_b(A_11, context);
871     if among_var == 0 {
872         return false;
873     }
874     // ], line 193
875     env.bra = env.cursor;
876     // call R1, line 193
877     if !r_R1(env, context) {
878         return false;
879     }
880     if among_var == 0 {
881         return false;
882     } else if among_var == 1 {
883         // (, line 194
884         // delete, line 194
885         if !env.slice_del() {
886             return false;
887         }
888     } else if among_var == 2 {
889         // (, line 195
890         // <-, line 195
891         if !env.slice_from("a") {
892             return false;
893         }
894     } else if among_var == 3 {
895         // (, line 196
896         // <-, line 196
897         if !env.slice_from("e") {
898             return false;
899         }
900     } else if among_var == 4 {
901         // (, line 197
902         // delete, line 197
903         if !env.slice_del() {
904             return false;
905         }
906     } else if among_var == 5 {
907         // (, line 198
908         // delete, line 198
909         if !env.slice_del() {
910             return false;
911         }
912     } else if among_var == 6 {
913         // (, line 199
914         // delete, line 199
915         if !env.slice_del() {
916             return false;
917         }
918     } else if among_var == 7 {
919         // (, line 200
920         // <-, line 200
921         if !env.slice_from("a") {
922             return false;
923         }
924     } else if among_var == 8 {
925         // (, line 201
926         // <-, line 201
927         if !env.slice_from("e") {
928             return false;
929         }
930     } else if among_var == 9 {
931         // (, line 202
932         // delete, line 202
933         if !env.slice_del() {
934             return false;
935         }
936     } else if among_var == 10 {
937         // (, line 203
938         // delete, line 203
939         if !env.slice_del() {
940             return false;
941         }
942     } else if among_var == 11 {
943         // (, line 204
944         // delete, line 204
945         if !env.slice_del() {
946             return false;
947         }
948     } else if among_var == 12 {
949         // (, line 205
950         // <-, line 205
951         if !env.slice_from("a") {
952             return false;
953         }
954     } else if among_var == 13 {
955         // (, line 206
956         // <-, line 206
957         if !env.slice_from("e") {
958             return false;
959         }
960     } else if among_var == 14 {
961         // (, line 207
962         // delete, line 207
963         if !env.slice_del() {
964             return false;
965         }
966     } else if among_var == 15 {
967         // (, line 208
968         // delete, line 208
969         if !env.slice_del() {
970             return false;
971         }
972     } else if among_var == 16 {
973         // (, line 209
974         // delete, line 209
975         if !env.slice_del() {
976             return false;
977         }
978     } else if among_var == 17 {
979         // (, line 210
980         // delete, line 210
981         if !env.slice_del() {
982             return false;
983         }
984     } else if among_var == 18 {
985         // (, line 211
986         // <-, line 211
987         if !env.slice_from("a") {
988             return false;
989         }
990     } else if among_var == 19 {
991         // (, line 212
992         // <-, line 212
993         if !env.slice_from("e") {
994             return false;
995         }
996     } else if among_var == 20 {
997         // (, line 214
998         // delete, line 214
999         if !env.slice_del() {
1000             return false;
1001         }
1002     } else if among_var == 21 {
1003         // (, line 215
1004         // delete, line 215
1005         if !env.slice_del() {
1006             return false;
1007         }
1008     } else if among_var == 22 {
1009         // (, line 216
1010         // <-, line 216
1011         if !env.slice_from("a") {
1012             return false;
1013         }
1014     } else if among_var == 23 {
1015         // (, line 217
1016         // <-, line 217
1017         if !env.slice_from("e") {
1018             return false;
1019         }
1020     } else if among_var == 24 {
1021         // (, line 218
1022         // delete, line 218
1023         if !env.slice_del() {
1024             return false;
1025         }
1026     } else if among_var == 25 {
1027         // (, line 219
1028         // delete, line 219
1029         if !env.slice_del() {
1030             return false;
1031         }
1032     } else if among_var == 26 {
1033         // (, line 220
1034         // delete, line 220
1035         if !env.slice_del() {
1036             return false;
1037         }
1038     } else if among_var == 27 {
1039         // (, line 221
1040         // <-, line 221
1041         if !env.slice_from("a") {
1042             return false;
1043         }
1044     } else if among_var == 28 {
1045         // (, line 222
1046         // <-, line 222
1047         if !env.slice_from("e") {
1048             return false;
1049         }
1050     } else if among_var == 29 {
1051         // (, line 223
1052         // delete, line 223
1053         if !env.slice_del() {
1054             return false;
1055         }
1056     }
1057     return true;
1058 }
1059 
1060 pub fn stem(env: &mut SnowballEnv) -> bool {
1061     let mut context = &mut Context {
1062         i_p1: 0,
1063     };
1064     // (, line 228
1065     // do, line 229
1066     let v_1 = env.cursor;
1067     'lab0: loop {
1068         // call mark_regions, line 229
1069         if !r_mark_regions(env, context) {
1070             break 'lab0;
1071         }
1072         break 'lab0;
1073     }
1074     env.cursor = v_1;
1075     // backwards, line 230
1076     env.limit_backward = env.cursor;
1077     env.cursor = env.limit;
1078     // (, line 230
1079     // do, line 231
1080     let v_2 = env.limit - env.cursor;
1081     'lab1: loop {
1082         // call instrum, line 231
1083         if !r_instrum(env, context) {
1084             break 'lab1;
1085         }
1086         break 'lab1;
1087     }
1088     env.cursor = env.limit - v_2;
1089     // do, line 232
1090     let v_3 = env.limit - env.cursor;
1091     'lab2: loop {
1092         // call case, line 232
1093         if !r_case(env, context) {
1094             break 'lab2;
1095         }
1096         break 'lab2;
1097     }
1098     env.cursor = env.limit - v_3;
1099     // do, line 233
1100     let v_4 = env.limit - env.cursor;
1101     'lab3: loop {
1102         // call case_special, line 233
1103         if !r_case_special(env, context) {
1104             break 'lab3;
1105         }
1106         break 'lab3;
1107     }
1108     env.cursor = env.limit - v_4;
1109     // do, line 234
1110     let v_5 = env.limit - env.cursor;
1111     'lab4: loop {
1112         // call case_other, line 234
1113         if !r_case_other(env, context) {
1114             break 'lab4;
1115         }
1116         break 'lab4;
1117     }
1118     env.cursor = env.limit - v_5;
1119     // do, line 235
1120     let v_6 = env.limit - env.cursor;
1121     'lab5: loop {
1122         // call factive, line 235
1123         if !r_factive(env, context) {
1124             break 'lab5;
1125         }
1126         break 'lab5;
1127     }
1128     env.cursor = env.limit - v_6;
1129     // do, line 236
1130     let v_7 = env.limit - env.cursor;
1131     'lab6: loop {
1132         // call owned, line 236
1133         if !r_owned(env, context) {
1134             break 'lab6;
1135         }
1136         break 'lab6;
1137     }
1138     env.cursor = env.limit - v_7;
1139     // do, line 237
1140     let v_8 = env.limit - env.cursor;
1141     'lab7: loop {
1142         // call sing_owner, line 237
1143         if !r_sing_owner(env, context) {
1144             break 'lab7;
1145         }
1146         break 'lab7;
1147     }
1148     env.cursor = env.limit - v_8;
1149     // do, line 238
1150     let v_9 = env.limit - env.cursor;
1151     'lab8: loop {
1152         // call plur_owner, line 238
r_has_min_length(env: &mut SnowballEnv, context: &mut Context) -> bool1153         if !r_plur_owner(env, context) {
1154             break 'lab8;
1155         }
1156         break 'lab8;
1157     }
1158     env.cursor = env.limit - v_9;
1159     // do, line 239
1160     let v_10 = env.limit - env.cursor;
r_tolower(env: &mut SnowballEnv, context: &mut Context) -> bool1161     'lab9: loop {
1162         // call plural, line 239
1163         if !r_plural(env, context) {
1164             break 'lab9;
1165         }
1166         break 'lab9;
1167     }
1168     env.cursor = env.limit - v_10;
1169     env.cursor = env.limit_backward;
1170     return true;
1171 }
1172