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>; 3] = &[
12     Among("", -1, 3, None),
13     Among("I", 0, 1, None),
14     Among("U", 0, 2, None),
15 ];
16 
17 static A_1: &'static [Among<Context>; 16] = &[
18     Among("ea", -1, 3, None),
19     Among("a\u{0163}ia", -1, 7, None),
20     Among("aua", -1, 2, None),
21     Among("iua", -1, 4, None),
22     Among("a\u{0163}ie", -1, 7, None),
23     Among("ele", -1, 3, None),
24     Among("ile", -1, 5, None),
25     Among("iile", 6, 4, None),
26     Among("iei", -1, 4, None),
27     Among("atei", -1, 6, None),
28     Among("ii", -1, 4, None),
29     Among("ului", -1, 1, None),
30     Among("ul", -1, 1, None),
31     Among("elor", -1, 3, None),
32     Among("ilor", -1, 4, None),
33     Among("iilor", 14, 4, None),
34 ];
35 
36 static A_2: &'static [Among<Context>; 46] = &[
37     Among("icala", -1, 4, None),
38     Among("iciva", -1, 4, None),
39     Among("ativa", -1, 5, None),
40     Among("itiva", -1, 6, None),
41     Among("icale", -1, 4, None),
42     Among("a\u{0163}iune", -1, 5, None),
43     Among("i\u{0163}iune", -1, 6, None),
44     Among("atoare", -1, 5, None),
45     Among("itoare", -1, 6, None),
46     Among("\u{0103}toare", -1, 5, None),
47     Among("icitate", -1, 4, None),
48     Among("abilitate", -1, 1, None),
49     Among("ibilitate", -1, 2, None),
50     Among("ivitate", -1, 3, None),
51     Among("icive", -1, 4, None),
52     Among("ative", -1, 5, None),
53     Among("itive", -1, 6, None),
54     Among("icali", -1, 4, None),
55     Among("atori", -1, 5, None),
56     Among("icatori", 18, 4, None),
57     Among("itori", -1, 6, None),
58     Among("\u{0103}tori", -1, 5, None),
59     Among("icitati", -1, 4, None),
60     Among("abilitati", -1, 1, None),
61     Among("ivitati", -1, 3, None),
62     Among("icivi", -1, 4, None),
63     Among("ativi", -1, 5, None),
64     Among("itivi", -1, 6, None),
65     Among("icit\u{0103}i", -1, 4, None),
66     Among("abilit\u{0103}i", -1, 1, None),
67     Among("ivit\u{0103}i", -1, 3, None),
68     Among("icit\u{0103}\u{0163}i", -1, 4, None),
69     Among("abilit\u{0103}\u{0163}i", -1, 1, None),
70     Among("ivit\u{0103}\u{0163}i", -1, 3, None),
71     Among("ical", -1, 4, None),
72     Among("ator", -1, 5, None),
73     Among("icator", 35, 4, None),
74     Among("itor", -1, 6, None),
75     Among("\u{0103}tor", -1, 5, None),
76     Among("iciv", -1, 4, None),
77     Among("ativ", -1, 5, None),
78     Among("itiv", -1, 6, None),
79     Among("ical\u{0103}", -1, 4, None),
80     Among("iciv\u{0103}", -1, 4, None),
81     Among("ativ\u{0103}", -1, 5, None),
82     Among("itiv\u{0103}", -1, 6, None),
83 ];
84 
85 static A_3: &'static [Among<Context>; 62] = &[
86     Among("ica", -1, 1, None),
87     Among("abila", -1, 1, None),
88     Among("ibila", -1, 1, None),
89     Among("oasa", -1, 1, None),
90     Among("ata", -1, 1, None),
91     Among("ita", -1, 1, None),
92     Among("anta", -1, 1, None),
93     Among("ista", -1, 3, None),
94     Among("uta", -1, 1, None),
95     Among("iva", -1, 1, None),
96     Among("ic", -1, 1, None),
97     Among("ice", -1, 1, None),
98     Among("abile", -1, 1, None),
99     Among("ibile", -1, 1, None),
100     Among("isme", -1, 3, None),
101     Among("iune", -1, 2, None),
102     Among("oase", -1, 1, None),
103     Among("ate", -1, 1, None),
104     Among("itate", 17, 1, None),
105     Among("ite", -1, 1, None),
106     Among("ante", -1, 1, None),
107     Among("iste", -1, 3, None),
108     Among("ute", -1, 1, None),
109     Among("ive", -1, 1, None),
110     Among("ici", -1, 1, None),
111     Among("abili", -1, 1, None),
112     Among("ibili", -1, 1, None),
113     Among("iuni", -1, 2, None),
114     Among("atori", -1, 1, None),
115     Among("osi", -1, 1, None),
116     Among("ati", -1, 1, None),
117     Among("itati", 30, 1, None),
118     Among("iti", -1, 1, None),
119     Among("anti", -1, 1, None),
120     Among("isti", -1, 3, None),
121     Among("uti", -1, 1, None),
122     Among("i\u{015F}ti", -1, 3, None),
123     Among("ivi", -1, 1, None),
124     Among("it\u{0103}i", -1, 1, None),
125     Among("o\u{015F}i", -1, 1, None),
126     Among("it\u{0103}\u{0163}i", -1, 1, None),
127     Among("abil", -1, 1, None),
128     Among("ibil", -1, 1, None),
129     Among("ism", -1, 3, None),
130     Among("ator", -1, 1, None),
131     Among("os", -1, 1, None),
132     Among("at", -1, 1, None),
133     Among("it", -1, 1, None),
134     Among("ant", -1, 1, None),
135     Among("ist", -1, 3, None),
136     Among("ut", -1, 1, None),
137     Among("iv", -1, 1, None),
138     Among("ic\u{0103}", -1, 1, None),
139     Among("abil\u{0103}", -1, 1, None),
140     Among("ibil\u{0103}", -1, 1, None),
141     Among("oas\u{0103}", -1, 1, None),
142     Among("at\u{0103}", -1, 1, None),
143     Among("it\u{0103}", -1, 1, None),
144     Among("ant\u{0103}", -1, 1, None),
145     Among("ist\u{0103}", -1, 3, None),
146     Among("ut\u{0103}", -1, 1, None),
147     Among("iv\u{0103}", -1, 1, None),
148 ];
149 
150 static A_4: &'static [Among<Context>; 94] = &[
151     Among("ea", -1, 1, None),
152     Among("ia", -1, 1, None),
153     Among("esc", -1, 1, None),
154     Among("\u{0103}sc", -1, 1, None),
155     Among("ind", -1, 1, None),
156     Among("\u{00E2}nd", -1, 1, None),
157     Among("are", -1, 1, None),
158     Among("ere", -1, 1, None),
159     Among("ire", -1, 1, None),
160     Among("\u{00E2}re", -1, 1, None),
161     Among("se", -1, 2, None),
162     Among("ase", 10, 1, None),
163     Among("sese", 10, 2, None),
164     Among("ise", 10, 1, None),
165     Among("use", 10, 1, None),
166     Among("\u{00E2}se", 10, 1, None),
167     Among("e\u{015F}te", -1, 1, None),
168     Among("\u{0103}\u{015F}te", -1, 1, None),
169     Among("eze", -1, 1, None),
170     Among("ai", -1, 1, None),
171     Among("eai", 19, 1, None),
172     Among("iai", 19, 1, None),
173     Among("sei", -1, 2, None),
174     Among("e\u{015F}ti", -1, 1, None),
175     Among("\u{0103}\u{015F}ti", -1, 1, None),
176     Among("ui", -1, 1, None),
177     Among("ezi", -1, 1, None),
178     Among("a\u{015F}i", -1, 1, None),
179     Among("se\u{015F}i", -1, 2, None),
180     Among("ase\u{015F}i", 28, 1, None),
181     Among("sese\u{015F}i", 28, 2, None),
182     Among("ise\u{015F}i", 28, 1, None),
183     Among("use\u{015F}i", 28, 1, None),
184     Among("\u{00E2}se\u{015F}i", 28, 1, None),
185     Among("i\u{015F}i", -1, 1, None),
186     Among("u\u{015F}i", -1, 1, None),
187     Among("\u{00E2}\u{015F}i", -1, 1, None),
188     Among("\u{00E2}i", -1, 1, None),
189     Among("a\u{0163}i", -1, 2, None),
190     Among("ea\u{0163}i", 38, 1, None),
191     Among("ia\u{0163}i", 38, 1, None),
192     Among("e\u{0163}i", -1, 2, None),
193     Among("i\u{0163}i", -1, 2, None),
194     Among("ar\u{0103}\u{0163}i", -1, 1, None),
195     Among("ser\u{0103}\u{0163}i", -1, 2, None),
196     Among("aser\u{0103}\u{0163}i", 44, 1, None),
197     Among("seser\u{0103}\u{0163}i", 44, 2, None),
198     Among("iser\u{0103}\u{0163}i", 44, 1, None),
199     Among("user\u{0103}\u{0163}i", 44, 1, None),
200     Among("\u{00E2}ser\u{0103}\u{0163}i", 44, 1, None),
201     Among("ir\u{0103}\u{0163}i", -1, 1, None),
202     Among("ur\u{0103}\u{0163}i", -1, 1, None),
203     Among("\u{00E2}r\u{0103}\u{0163}i", -1, 1, None),
204     Among("\u{00E2}\u{0163}i", -1, 2, None),
205     Among("am", -1, 1, None),
206     Among("eam", 54, 1, None),
207     Among("iam", 54, 1, None),
208     Among("em", -1, 2, None),
209     Among("asem", 57, 1, None),
210     Among("sesem", 57, 2, None),
211     Among("isem", 57, 1, None),
212     Among("usem", 57, 1, None),
213     Among("\u{00E2}sem", 57, 1, None),
214     Among("im", -1, 2, None),
215     Among("\u{0103}m", -1, 2, None),
216     Among("ar\u{0103}m", 64, 1, None),
217     Among("ser\u{0103}m", 64, 2, None),
218     Among("aser\u{0103}m", 66, 1, None),
219     Among("seser\u{0103}m", 66, 2, None),
220     Among("iser\u{0103}m", 66, 1, None),
221     Among("user\u{0103}m", 66, 1, None),
222     Among("\u{00E2}ser\u{0103}m", 66, 1, None),
223     Among("ir\u{0103}m", 64, 1, None),
224     Among("ur\u{0103}m", 64, 1, None),
225     Among("\u{00E2}r\u{0103}m", 64, 1, None),
226     Among("\u{00E2}m", -1, 2, None),
227     Among("au", -1, 1, None),
228     Among("eau", 76, 1, None),
229     Among("iau", 76, 1, None),
230     Among("indu", -1, 1, None),
231     Among("\u{00E2}ndu", -1, 1, None),
232     Among("ez", -1, 1, None),
233     Among("easc\u{0103}", -1, 1, None),
234     Among("ar\u{0103}", -1, 1, None),
235     Among("ser\u{0103}", -1, 2, None),
236     Among("aser\u{0103}", 84, 1, None),
237     Among("seser\u{0103}", 84, 2, None),
238     Among("iser\u{0103}", 84, 1, None),
239     Among("user\u{0103}", 84, 1, None),
240     Among("\u{00E2}ser\u{0103}", 84, 1, None),
241     Among("ir\u{0103}", -1, 1, None),
242     Among("ur\u{0103}", -1, 1, None),
243     Among("\u{00E2}r\u{0103}", -1, 1, None),
244     Among("eaz\u{0103}", -1, 1, None),
245 ];
246 
247 static A_5: &'static [Among<Context>; 5] = &[
248     Among("a", -1, 1, None),
249     Among("e", -1, 1, None),
250     Among("ie", 1, 1, None),
251     Among("i", -1, 1, None),
252     Among("\u{0103}", -1, 1, None),
253 ];
254 
255 static G_v: &'static [u8; 21] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 32, 0, 0, 4];
256 
257 #[derive(Clone)]
258 struct Context {
259     b_standard_suffix_removed: bool,
260     i_p2: usize,
261     i_p1: usize,
262     i_pV: usize,
263 }
264 
r_prelude(env: &mut SnowballEnv, context: &mut Context) -> bool265 fn r_prelude(env: &mut SnowballEnv, context: &mut Context) -> bool {
266     // (, line 30
267     // repeat, line 31
268     'replab0: loop{
269         let v_1 = env.cursor;
270         'lab1: for _ in 0..1 {
271             // goto, line 31
272             'golab2: loop {
273                 let v_2 = env.cursor;
274                 'lab3: loop {
275                     // (, line 31
276                     if !env.in_grouping(G_v, 97, 259) {
277                         break 'lab3;
278                     }
279                     // [, line 32
280                     env.bra = env.cursor;
281                     // or, line 32
282                     'lab4: loop {
283                         let v_3 = env.cursor;
284                         'lab5: loop {
285                             // (, line 32
286                             // literal, line 32
287                             if !env.eq_s(&"u") {
288                                 break 'lab5;
289                             }
290                             // ], line 32
291                             env.ket = env.cursor;
292                             if !env.in_grouping(G_v, 97, 259) {
293                                 break 'lab5;
294                             }
295                             // <-, line 32
296                             if !env.slice_from("U") {
297                                 return false;
298                             }
299                             break 'lab4;
300                         }
301                         env.cursor = v_3;
302                         // (, line 33
303                         // literal, line 33
304                         if !env.eq_s(&"i") {
305                             break 'lab3;
306                         }
307                         // ], line 33
308                         env.ket = env.cursor;
309                         if !env.in_grouping(G_v, 97, 259) {
310                             break 'lab3;
311                         }
312                         // <-, line 33
313                         if !env.slice_from("I") {
314                             return false;
315                         }
316                         break 'lab4;
317                     }
318                     env.cursor = v_2;
319                     break 'golab2;
320                 }
321                 env.cursor = v_2;
322                 if env.cursor >= env.limit {
323                     break 'lab1;
324                 }
325                 env.next_char();
326             }
327             continue 'replab0;
328         }
329         env.cursor = v_1;
330         break 'replab0;
331     }
332     return true;
333 }
334 
r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool335 fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool {
336     // (, line 37
337     context.i_pV = env.limit;
338     context.i_p1 = env.limit;
339     context.i_p2 = env.limit;
340     // do, line 43
341     let v_1 = env.cursor;
342     'lab0: loop {
343         // (, line 43
344         // or, line 45
345         'lab1: loop {
346             let v_2 = env.cursor;
347             'lab2: loop {
348                 // (, line 44
349                 if !env.in_grouping(G_v, 97, 259) {
350                     break 'lab2;
351                 }
352                 // or, line 44
353                 'lab3: loop {
354                     let v_3 = env.cursor;
355                     'lab4: loop {
356                         // (, line 44
357                         if !env.out_grouping(G_v, 97, 259) {
358                             break 'lab4;
359                         }
360                         // gopast, line 44
361                         'golab5: loop {
362                             'lab6: loop {
363                                 if !env.in_grouping(G_v, 97, 259) {
364                                     break 'lab6;
365                                 }
366                                 break 'golab5;
367                             }
368                             if env.cursor >= env.limit {
369                                 break 'lab4;
370                             }
371                             env.next_char();
372                         }
373                         break 'lab3;
374                     }
375                     env.cursor = v_3;
376                     // (, line 44
377                     if !env.in_grouping(G_v, 97, 259) {
378                         break 'lab2;
379                     }
380                     // gopast, line 44
381                     'golab7: loop {
382                         'lab8: loop {
383                             if !env.out_grouping(G_v, 97, 259) {
384                                 break 'lab8;
385                             }
386                             break 'golab7;
387                         }
388                         if env.cursor >= env.limit {
389                             break 'lab2;
390                         }
391                         env.next_char();
392                     }
393                     break 'lab3;
394                 }
395                 break 'lab1;
396             }
397             env.cursor = v_2;
398             // (, line 46
399             if !env.out_grouping(G_v, 97, 259) {
400                 break 'lab0;
401             }
402             // or, line 46
403             'lab9: loop {
404                 let v_6 = env.cursor;
405                 'lab10: loop {
406                     // (, line 46
407                     if !env.out_grouping(G_v, 97, 259) {
408                         break 'lab10;
409                     }
410                     // gopast, line 46
411                     'golab11: loop {
412                         'lab12: loop {
413                             if !env.in_grouping(G_v, 97, 259) {
414                                 break 'lab12;
415                             }
416                             break 'golab11;
417                         }
418                         if env.cursor >= env.limit {
419                             break 'lab10;
420                         }
421                         env.next_char();
422                     }
423                     break 'lab9;
424                 }
425                 env.cursor = v_6;
426                 // (, line 46
427                 if !env.in_grouping(G_v, 97, 259) {
428                     break 'lab0;
429                 }
430                 // next, line 46
431                 if env.cursor >= env.limit {
432                     break 'lab0;
433                 }
434                 env.next_char();
435                 break 'lab9;
436             }
437             break 'lab1;
438         }
439         // setmark pV, line 47
440         context.i_pV = env.cursor;
441         break 'lab0;
442     }
443     env.cursor = v_1;
444     // do, line 49
445     let v_8 = env.cursor;
446     'lab13: loop {
447         // (, line 49
448         // gopast, line 50
449         'golab14: loop {
450             'lab15: loop {
451                 if !env.in_grouping(G_v, 97, 259) {
452                     break 'lab15;
453                 }
454                 break 'golab14;
455             }
456             if env.cursor >= env.limit {
457                 break 'lab13;
458             }
459             env.next_char();
460         }
461         // gopast, line 50
462         'golab16: loop {
463             'lab17: loop {
464                 if !env.out_grouping(G_v, 97, 259) {
465                     break 'lab17;
466                 }
467                 break 'golab16;
468             }
469             if env.cursor >= env.limit {
470                 break 'lab13;
471             }
472             env.next_char();
473         }
474         // setmark p1, line 50
475         context.i_p1 = env.cursor;
476         // gopast, line 51
477         'golab18: loop {
478             'lab19: loop {
479                 if !env.in_grouping(G_v, 97, 259) {
480                     break 'lab19;
481                 }
482                 break 'golab18;
483             }
484             if env.cursor >= env.limit {
485                 break 'lab13;
486             }
487             env.next_char();
488         }
489         // gopast, line 51
490         'golab20: loop {
491             'lab21: loop {
492                 if !env.out_grouping(G_v, 97, 259) {
493                     break 'lab21;
494                 }
495                 break 'golab20;
496             }
497             if env.cursor >= env.limit {
498                 break 'lab13;
499             }
500             env.next_char();
501         }
502         // setmark p2, line 51
503         context.i_p2 = env.cursor;
504         break 'lab13;
505     }
506     env.cursor = v_8;
507     return true;
508 }
509 
r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool510 fn r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool {
511     let mut among_var;
512     // repeat, line 55
513     'replab0: loop{
514         let v_1 = env.cursor;
515         'lab1: for _ in 0..1 {
516             // (, line 55
517             // [, line 57
518             env.bra = env.cursor;
519             // substring, line 57
520             among_var = env.find_among(A_0, context);
521             if among_var == 0 {
522                 break 'lab1;
523             }
524             // ], line 57
525             env.ket = env.cursor;
526             if among_var == 0 {
527                 break 'lab1;
528             } else if among_var == 1 {
529                 // (, line 58
530                 // <-, line 58
531                 if !env.slice_from("i") {
532                     return false;
533                 }
534             } else if among_var == 2 {
535                 // (, line 59
536                 // <-, line 59
537                 if !env.slice_from("u") {
538                     return false;
539                 }
540             } else if among_var == 3 {
541                 // (, line 60
542                 // next, line 60
543                 if env.cursor >= env.limit {
544                     break 'lab1;
545                 }
546                 env.next_char();
547             }
548             continue 'replab0;
549         }
550         env.cursor = v_1;
551         break 'replab0;
552     }
553     return true;
554 }
555 
r_RV(env: &mut SnowballEnv, context: &mut Context) -> bool556 fn r_RV(env: &mut SnowballEnv, context: &mut Context) -> bool {
557     if !(context.i_pV <= env.cursor){
558         return false;
559     }
560     return true;
561 }
562 
r_R1(env: &mut SnowballEnv, context: &mut Context) -> bool563 fn r_R1(env: &mut SnowballEnv, context: &mut Context) -> bool {
564     if !(context.i_p1 <= env.cursor){
565         return false;
566     }
567     return true;
568 }
569 
r_R2(env: &mut SnowballEnv, context: &mut Context) -> bool570 fn r_R2(env: &mut SnowballEnv, context: &mut Context) -> bool {
571     if !(context.i_p2 <= env.cursor){
572         return false;
573     }
574     return true;
575 }
576 
r_step_0(env: &mut SnowballEnv, context: &mut Context) -> bool577 fn r_step_0(env: &mut SnowballEnv, context: &mut Context) -> bool {
578     let mut among_var;
579     // (, line 71
580     // [, line 72
581     env.ket = env.cursor;
582     // substring, line 72
583     among_var = env.find_among_b(A_1, context);
584     if among_var == 0 {
585         return false;
586     }
587     // ], line 72
588     env.bra = env.cursor;
589     // call R1, line 72
590     if !r_R1(env, context) {
591         return false;
592     }
593     if among_var == 0 {
594         return false;
595     } else if among_var == 1 {
596         // (, line 74
597         // delete, line 74
598         if !env.slice_del() {
599             return false;
600         }
601     } else if among_var == 2 {
602         // (, line 76
603         // <-, line 76
604         if !env.slice_from("a") {
605             return false;
606         }
607     } else if among_var == 3 {
608         // (, line 78
609         // <-, line 78
610         if !env.slice_from("e") {
611             return false;
612         }
613     } else if among_var == 4 {
614         // (, line 80
615         // <-, line 80
616         if !env.slice_from("i") {
617             return false;
618         }
619     } else if among_var == 5 {
620         // (, line 82
621         // not, line 82
622         let v_1 = env.limit - env.cursor;
623         'lab0: loop {
624             // literal, line 82
625             if !env.eq_s_b(&"ab") {
626                 break 'lab0;
627             }
628             return false;
629         }
630         env.cursor = env.limit - v_1;
631         // <-, line 82
632         if !env.slice_from("i") {
633             return false;
634         }
635     } else if among_var == 6 {
636         // (, line 84
637         // <-, line 84
638         if !env.slice_from("at") {
639             return false;
640         }
641     } else if among_var == 7 {
642         // (, line 86
643         // <-, line 86
644         if !env.slice_from("a\u{0163}i") {
645             return false;
646         }
647     }
648     return true;
649 }
650 
r_combo_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool651 fn r_combo_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
652     let mut among_var;
653     // test, line 90
654     let v_1 = env.limit - env.cursor;
655     // (, line 90
656     // [, line 91
657     env.ket = env.cursor;
658     // substring, line 91
659     among_var = env.find_among_b(A_2, context);
660     if among_var == 0 {
661         return false;
662     }
663     // ], line 91
664     env.bra = env.cursor;
665     // call R1, line 91
666     if !r_R1(env, context) {
667         return false;
668     }
669     // (, line 91
670     if among_var == 0 {
671         return false;
672     } else if among_var == 1 {
673         // (, line 99
674         // <-, line 100
675         if !env.slice_from("abil") {
676             return false;
677         }
678     } else if among_var == 2 {
679         // (, line 102
680         // <-, line 103
681         if !env.slice_from("ibil") {
682             return false;
683         }
684     } else if among_var == 3 {
685         // (, line 105
686         // <-, line 106
687         if !env.slice_from("iv") {
688             return false;
689         }
690     } else if among_var == 4 {
691         // (, line 111
692         // <-, line 112
693         if !env.slice_from("ic") {
694             return false;
695         }
696     } else if among_var == 5 {
697         // (, line 116
698         // <-, line 117
699         if !env.slice_from("at") {
700             return false;
701         }
702     } else if among_var == 6 {
703         // (, line 120
704         // <-, line 121
705         if !env.slice_from("it") {
706             return false;
707         }
708     }
709     // set standard_suffix_removed, line 124
710     context.b_standard_suffix_removed = true;
711     env.cursor = env.limit - v_1;
712     return true;
713 }
714 
r_standard_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool715 fn r_standard_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
716     let mut among_var;
717     // (, line 128
718     // unset standard_suffix_removed, line 129
719     context.b_standard_suffix_removed = false;
720     // repeat, line 130
721     'replab0: loop{
722         let v_1 = env.limit - env.cursor;
723         'lab1: for _ in 0..1 {
724             // call combo_suffix, line 130
725             if !r_combo_suffix(env, context) {
726                 break 'lab1;
727             }
728             continue 'replab0;
729         }
730         env.cursor = env.limit - v_1;
731         break 'replab0;
732     }
733     // [, line 131
734     env.ket = env.cursor;
735     // substring, line 131
736     among_var = env.find_among_b(A_3, context);
737     if among_var == 0 {
738         return false;
739     }
740     // ], line 131
741     env.bra = env.cursor;
742     // call R2, line 131
743     if !r_R2(env, context) {
744         return false;
745     }
746     // (, line 131
747     if among_var == 0 {
748         return false;
749     } else if among_var == 1 {
750         // (, line 147
751         // delete, line 148
752         if !env.slice_del() {
753             return false;
754         }
755     } else if among_var == 2 {
756         // (, line 150
757         // literal, line 151
758         if !env.eq_s_b(&"\u{0163}") {
759             return false;
760         }
761         // ], line 151
762         env.bra = env.cursor;
763         // <-, line 151
764         if !env.slice_from("t") {
765             return false;
766         }
767     } else if among_var == 3 {
768         // (, line 154
769         // <-, line 155
770         if !env.slice_from("ist") {
771             return false;
772         }
773     }
774     // set standard_suffix_removed, line 159
775     context.b_standard_suffix_removed = true;
776     return true;
777 }
778 
r_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool779 fn r_verb_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
780     let mut among_var;
781     // setlimit, line 163
782     let v_1 = env.limit - env.cursor;
783     // tomark, line 163
784     if env.cursor < context.i_pV {
785         return false;
786     }
787     env.cursor = context.i_pV;
788     let v_2 = env.limit_backward;
789     env.limit_backward = env.cursor;
790     env.cursor = env.limit - v_1;
791     // (, line 163
792     // [, line 164
793     env.ket = env.cursor;
794     // substring, line 164
795     among_var = env.find_among_b(A_4, context);
796     if among_var == 0 {
797         env.limit_backward = v_2;
798         return false;
799     }
800     // ], line 164
801     env.bra = env.cursor;
802     if among_var == 0 {
803         env.limit_backward = v_2;
804         return false;
805     } else if among_var == 1 {
806         // (, line 199
807         // or, line 199
808         'lab0: loop {
809             let v_3 = env.limit - env.cursor;
810             'lab1: loop {
811                 if !env.out_grouping_b(G_v, 97, 259) {
812                     break 'lab1;
813                 }
814                 break 'lab0;
815             }
816             env.cursor = env.limit - v_3;
817             // literal, line 199
818             if !env.eq_s_b(&"u") {
819                 env.limit_backward = v_2;
820                 return false;
821             }
822             break 'lab0;
823         }
824         // delete, line 199
825         if !env.slice_del() {
826             return false;
827         }
828     } else if among_var == 2 {
829         // (, line 213
830         // delete, line 213
831         if !env.slice_del() {
832             return false;
833         }
834     }
835     env.limit_backward = v_2;
836     return true;
837 }
838 
r_vowel_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool839 fn r_vowel_suffix(env: &mut SnowballEnv, context: &mut Context) -> bool {
840     let mut among_var;
841     // (, line 217
842     // [, line 218
843     env.ket = env.cursor;
844     // substring, line 218
845     among_var = env.find_among_b(A_5, context);
846     if among_var == 0 {
847         return false;
848     }
849     // ], line 218
850     env.bra = env.cursor;
851     // call RV, line 218
852     if !r_RV(env, context) {
853         return false;
854     }
855     if among_var == 0 {
856         return false;
857     } else if among_var == 1 {
858         // (, line 219
859         // delete, line 219
860         if !env.slice_del() {
861             return false;
862         }
863     }
864     return true;
865 }
866 
stem(env: &mut SnowballEnv) -> bool867 pub fn stem(env: &mut SnowballEnv) -> bool {
868     let mut context = &mut Context {
869         b_standard_suffix_removed: false,
870         i_p2: 0,
871         i_p1: 0,
872         i_pV: 0,
873     };
874     // (, line 224
875     // do, line 225
876     let v_1 = env.cursor;
877     'lab0: loop {
878         // call prelude, line 225
879         if !r_prelude(env, context) {
880             break 'lab0;
881         }
882         break 'lab0;
883     }
884     env.cursor = v_1;
885     // do, line 226
886     let v_2 = env.cursor;
887     'lab1: loop {
888         // call mark_regions, line 226
889         if !r_mark_regions(env, context) {
890             break 'lab1;
891         }
892         break 'lab1;
893     }
894     env.cursor = v_2;
895     // backwards, line 227
896     env.limit_backward = env.cursor;
897     env.cursor = env.limit;
898     // (, line 227
899     // do, line 228
900     let v_3 = env.limit - env.cursor;
901     'lab2: loop {
902         // call step_0, line 228
903         if !r_step_0(env, context) {
904             break 'lab2;
905         }
906         break 'lab2;
907     }
908     env.cursor = env.limit - v_3;
909     // do, line 229
910     let v_4 = env.limit - env.cursor;
911     'lab3: loop {
912         // call standard_suffix, line 229
913         if !r_standard_suffix(env, context) {
914             break 'lab3;
915         }
916         break 'lab3;
917     }
918     env.cursor = env.limit - v_4;
919     // do, line 230
920     let v_5 = env.limit - env.cursor;
921     'lab4: loop {
922         // (, line 230
923         // or, line 230
924         'lab5: loop {
925             let v_6 = env.limit - env.cursor;
926             'lab6: loop {
927                 // Boolean test standard_suffix_removed, line 230
928                 if !context.b_standard_suffix_removed {
929                     break 'lab6;
930                 }
931                 break 'lab5;
932             }
933             env.cursor = env.limit - v_6;
934             // call verb_suffix, line 230
935             if !r_verb_suffix(env, context) {
936                 break 'lab4;
937             }
938             break 'lab5;
939         }
940         break 'lab4;
941     }
942     env.cursor = env.limit - v_5;
943     // do, line 231
944     let v_7 = env.limit - env.cursor;
945     'lab7: loop {
946         // call vowel_suffix, line 231
947         if !r_vowel_suffix(env, context) {
948             break 'lab7;
949         }
950         break 'lab7;
951     }
952     env.cursor = env.limit - v_7;
953     env.cursor = env.limit_backward;
954     // do, line 233
955     let v_8 = env.cursor;
956     'lab8: loop {
957         // call postlude, line 233
958         if !r_postlude(env, context) {
959             break 'lab8;
960         }
961         break 'lab8;
962     }
963     env.cursor = v_8;
964     return true;
965 }
966