← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/analyzers/common/src/java/org/tartarus/snowball/ext/SpanishStemmer.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/analyzers/common/src/java/org/tartarus/snowball/ext/SpanishStemmer.java
1
 
// This file was generated automatically by the Snowball to Java compiler
2
 
 
3
 
package org.tartarus.snowball.ext;
4
 
import org.tartarus.snowball.SnowballProgram;
5
 
import org.tartarus.snowball.Among;
6
 
 
7
 
/**
8
 
 * Generated class implementing code defined by a snowball script.
9
 
 */
10
 
public class SpanishStemmer extends SnowballProgram {
11
 
 
12
 
        private Among a_0[] = {
13
 
            new Among ( "", -1, 6, "", this),
14
 
            new Among ( "\u00E1", 0, 1, "", this),
15
 
            new Among ( "\u00E9", 0, 2, "", this),
16
 
            new Among ( "\u00ED", 0, 3, "", this),
17
 
            new Among ( "\u00F3", 0, 4, "", this),
18
 
            new Among ( "\u00FA", 0, 5, "", this)
19
 
        };
20
 
 
21
 
        private Among a_1[] = {
22
 
            new Among ( "la", -1, -1, "", this),
23
 
            new Among ( "sela", 0, -1, "", this),
24
 
            new Among ( "le", -1, -1, "", this),
25
 
            new Among ( "me", -1, -1, "", this),
26
 
            new Among ( "se", -1, -1, "", this),
27
 
            new Among ( "lo", -1, -1, "", this),
28
 
            new Among ( "selo", 5, -1, "", this),
29
 
            new Among ( "las", -1, -1, "", this),
30
 
            new Among ( "selas", 7, -1, "", this),
31
 
            new Among ( "les", -1, -1, "", this),
32
 
            new Among ( "los", -1, -1, "", this),
33
 
            new Among ( "selos", 10, -1, "", this),
34
 
            new Among ( "nos", -1, -1, "", this)
35
 
        };
36
 
 
37
 
        private Among a_2[] = {
38
 
            new Among ( "ando", -1, 6, "", this),
39
 
            new Among ( "iendo", -1, 6, "", this),
40
 
            new Among ( "yendo", -1, 7, "", this),
41
 
            new Among ( "\u00E1ndo", -1, 2, "", this),
42
 
            new Among ( "i\u00E9ndo", -1, 1, "", this),
43
 
            new Among ( "ar", -1, 6, "", this),
44
 
            new Among ( "er", -1, 6, "", this),
45
 
            new Among ( "ir", -1, 6, "", this),
46
 
            new Among ( "\u00E1r", -1, 3, "", this),
47
 
            new Among ( "\u00E9r", -1, 4, "", this),
48
 
            new Among ( "\u00EDr", -1, 5, "", this)
49
 
        };
50
 
 
51
 
        private Among a_3[] = {
52
 
            new Among ( "ic", -1, -1, "", this),
53
 
            new Among ( "ad", -1, -1, "", this),
54
 
            new Among ( "os", -1, -1, "", this),
55
 
            new Among ( "iv", -1, 1, "", this)
56
 
        };
57
 
 
58
 
        private Among a_4[] = {
59
 
            new Among ( "able", -1, 1, "", this),
60
 
            new Among ( "ible", -1, 1, "", this),
61
 
            new Among ( "ante", -1, 1, "", this)
62
 
        };
63
 
 
64
 
        private Among a_5[] = {
65
 
            new Among ( "ic", -1, 1, "", this),
66
 
            new Among ( "abil", -1, 1, "", this),
67
 
            new Among ( "iv", -1, 1, "", this)
68
 
        };
69
 
 
70
 
        private Among a_6[] = {
71
 
            new Among ( "ica", -1, 1, "", this),
72
 
            new Among ( "ancia", -1, 2, "", this),
73
 
            new Among ( "encia", -1, 5, "", this),
74
 
            new Among ( "adora", -1, 2, "", this),
75
 
            new Among ( "osa", -1, 1, "", this),
76
 
            new Among ( "ista", -1, 1, "", this),
77
 
            new Among ( "iva", -1, 9, "", this),
78
 
            new Among ( "anza", -1, 1, "", this),
79
 
            new Among ( "log\u00EDa", -1, 3, "", this),
80
 
            new Among ( "idad", -1, 8, "", this),
81
 
            new Among ( "able", -1, 1, "", this),
82
 
            new Among ( "ible", -1, 1, "", this),
83
 
            new Among ( "ante", -1, 2, "", this),
84
 
            new Among ( "mente", -1, 7, "", this),
85
 
            new Among ( "amente", 13, 6, "", this),
86
 
            new Among ( "aci\u00F3n", -1, 2, "", this),
87
 
            new Among ( "uci\u00F3n", -1, 4, "", this),
88
 
            new Among ( "ico", -1, 1, "", this),
89
 
            new Among ( "ismo", -1, 1, "", this),
90
 
            new Among ( "oso", -1, 1, "", this),
91
 
            new Among ( "amiento", -1, 1, "", this),
92
 
            new Among ( "imiento", -1, 1, "", this),
93
 
            new Among ( "ivo", -1, 9, "", this),
94
 
            new Among ( "ador", -1, 2, "", this),
95
 
            new Among ( "icas", -1, 1, "", this),
96
 
            new Among ( "ancias", -1, 2, "", this),
97
 
            new Among ( "encias", -1, 5, "", this),
98
 
            new Among ( "adoras", -1, 2, "", this),
99
 
            new Among ( "osas", -1, 1, "", this),
100
 
            new Among ( "istas", -1, 1, "", this),
101
 
            new Among ( "ivas", -1, 9, "", this),
102
 
            new Among ( "anzas", -1, 1, "", this),
103
 
            new Among ( "log\u00EDas", -1, 3, "", this),
104
 
            new Among ( "idades", -1, 8, "", this),
105
 
            new Among ( "ables", -1, 1, "", this),
106
 
            new Among ( "ibles", -1, 1, "", this),
107
 
            new Among ( "aciones", -1, 2, "", this),
108
 
            new Among ( "uciones", -1, 4, "", this),
109
 
            new Among ( "adores", -1, 2, "", this),
110
 
            new Among ( "antes", -1, 2, "", this),
111
 
            new Among ( "icos", -1, 1, "", this),
112
 
            new Among ( "ismos", -1, 1, "", this),
113
 
            new Among ( "osos", -1, 1, "", this),
114
 
            new Among ( "amientos", -1, 1, "", this),
115
 
            new Among ( "imientos", -1, 1, "", this),
116
 
            new Among ( "ivos", -1, 9, "", this)
117
 
        };
118
 
 
119
 
        private Among a_7[] = {
120
 
            new Among ( "ya", -1, 1, "", this),
121
 
            new Among ( "ye", -1, 1, "", this),
122
 
            new Among ( "yan", -1, 1, "", this),
123
 
            new Among ( "yen", -1, 1, "", this),
124
 
            new Among ( "yeron", -1, 1, "", this),
125
 
            new Among ( "yendo", -1, 1, "", this),
126
 
            new Among ( "yo", -1, 1, "", this),
127
 
            new Among ( "yas", -1, 1, "", this),
128
 
            new Among ( "yes", -1, 1, "", this),
129
 
            new Among ( "yais", -1, 1, "", this),
130
 
            new Among ( "yamos", -1, 1, "", this),
131
 
            new Among ( "y\u00F3", -1, 1, "", this)
132
 
        };
133
 
 
134
 
        private Among a_8[] = {
135
 
            new Among ( "aba", -1, 2, "", this),
136
 
            new Among ( "ada", -1, 2, "", this),
137
 
            new Among ( "ida", -1, 2, "", this),
138
 
            new Among ( "ara", -1, 2, "", this),
139
 
            new Among ( "iera", -1, 2, "", this),
140
 
            new Among ( "\u00EDa", -1, 2, "", this),
141
 
            new Among ( "ar\u00EDa", 5, 2, "", this),
142
 
            new Among ( "er\u00EDa", 5, 2, "", this),
143
 
            new Among ( "ir\u00EDa", 5, 2, "", this),
144
 
            new Among ( "ad", -1, 2, "", this),
145
 
            new Among ( "ed", -1, 2, "", this),
146
 
            new Among ( "id", -1, 2, "", this),
147
 
            new Among ( "ase", -1, 2, "", this),
148
 
            new Among ( "iese", -1, 2, "", this),
149
 
            new Among ( "aste", -1, 2, "", this),
150
 
            new Among ( "iste", -1, 2, "", this),
151
 
            new Among ( "an", -1, 2, "", this),
152
 
            new Among ( "aban", 16, 2, "", this),
153
 
            new Among ( "aran", 16, 2, "", this),
154
 
            new Among ( "ieran", 16, 2, "", this),
155
 
            new Among ( "\u00EDan", 16, 2, "", this),
156
 
            new Among ( "ar\u00EDan", 20, 2, "", this),
157
 
            new Among ( "er\u00EDan", 20, 2, "", this),
158
 
            new Among ( "ir\u00EDan", 20, 2, "", this),
159
 
            new Among ( "en", -1, 1, "", this),
160
 
            new Among ( "asen", 24, 2, "", this),
161
 
            new Among ( "iesen", 24, 2, "", this),
162
 
            new Among ( "aron", -1, 2, "", this),
163
 
            new Among ( "ieron", -1, 2, "", this),
164
 
            new Among ( "ar\u00E1n", -1, 2, "", this),
165
 
            new Among ( "er\u00E1n", -1, 2, "", this),
166
 
            new Among ( "ir\u00E1n", -1, 2, "", this),
167
 
            new Among ( "ado", -1, 2, "", this),
168
 
            new Among ( "ido", -1, 2, "", this),
169
 
            new Among ( "ando", -1, 2, "", this),
170
 
            new Among ( "iendo", -1, 2, "", this),
171
 
            new Among ( "ar", -1, 2, "", this),
172
 
            new Among ( "er", -1, 2, "", this),
173
 
            new Among ( "ir", -1, 2, "", this),
174
 
            new Among ( "as", -1, 2, "", this),
175
 
            new Among ( "abas", 39, 2, "", this),
176
 
            new Among ( "adas", 39, 2, "", this),
177
 
            new Among ( "idas", 39, 2, "", this),
178
 
            new Among ( "aras", 39, 2, "", this),
179
 
            new Among ( "ieras", 39, 2, "", this),
180
 
            new Among ( "\u00EDas", 39, 2, "", this),
181
 
            new Among ( "ar\u00EDas", 45, 2, "", this),
182
 
            new Among ( "er\u00EDas", 45, 2, "", this),
183
 
            new Among ( "ir\u00EDas", 45, 2, "", this),
184
 
            new Among ( "es", -1, 1, "", this),
185
 
            new Among ( "ases", 49, 2, "", this),
186
 
            new Among ( "ieses", 49, 2, "", this),
187
 
            new Among ( "abais", -1, 2, "", this),
188
 
            new Among ( "arais", -1, 2, "", this),
189
 
            new Among ( "ierais", -1, 2, "", this),
190
 
            new Among ( "\u00EDais", -1, 2, "", this),
191
 
            new Among ( "ar\u00EDais", 55, 2, "", this),
192
 
            new Among ( "er\u00EDais", 55, 2, "", this),
193
 
            new Among ( "ir\u00EDais", 55, 2, "", this),
194
 
            new Among ( "aseis", -1, 2, "", this),
195
 
            new Among ( "ieseis", -1, 2, "", this),
196
 
            new Among ( "asteis", -1, 2, "", this),
197
 
            new Among ( "isteis", -1, 2, "", this),
198
 
            new Among ( "\u00E1is", -1, 2, "", this),
199
 
            new Among ( "\u00E9is", -1, 1, "", this),
200
 
            new Among ( "ar\u00E9is", 64, 2, "", this),
201
 
            new Among ( "er\u00E9is", 64, 2, "", this),
202
 
            new Among ( "ir\u00E9is", 64, 2, "", this),
203
 
            new Among ( "ados", -1, 2, "", this),
204
 
            new Among ( "idos", -1, 2, "", this),
205
 
            new Among ( "amos", -1, 2, "", this),
206
 
            new Among ( "\u00E1bamos", 70, 2, "", this),
207
 
            new Among ( "\u00E1ramos", 70, 2, "", this),
208
 
            new Among ( "i\u00E9ramos", 70, 2, "", this),
209
 
            new Among ( "\u00EDamos", 70, 2, "", this),
210
 
            new Among ( "ar\u00EDamos", 74, 2, "", this),
211
 
            new Among ( "er\u00EDamos", 74, 2, "", this),
212
 
            new Among ( "ir\u00EDamos", 74, 2, "", this),
213
 
            new Among ( "emos", -1, 1, "", this),
214
 
            new Among ( "aremos", 78, 2, "", this),
215
 
            new Among ( "eremos", 78, 2, "", this),
216
 
            new Among ( "iremos", 78, 2, "", this),
217
 
            new Among ( "\u00E1semos", 78, 2, "", this),
218
 
            new Among ( "i\u00E9semos", 78, 2, "", this),
219
 
            new Among ( "imos", -1, 2, "", this),
220
 
            new Among ( "ar\u00E1s", -1, 2, "", this),
221
 
            new Among ( "er\u00E1s", -1, 2, "", this),
222
 
            new Among ( "ir\u00E1s", -1, 2, "", this),
223
 
            new Among ( "\u00EDs", -1, 2, "", this),
224
 
            new Among ( "ar\u00E1", -1, 2, "", this),
225
 
            new Among ( "er\u00E1", -1, 2, "", this),
226
 
            new Among ( "ir\u00E1", -1, 2, "", this),
227
 
            new Among ( "ar\u00E9", -1, 2, "", this),
228
 
            new Among ( "er\u00E9", -1, 2, "", this),
229
 
            new Among ( "ir\u00E9", -1, 2, "", this),
230
 
            new Among ( "i\u00F3", -1, 2, "", this)
231
 
        };
232
 
 
233
 
        private Among a_9[] = {
234
 
            new Among ( "a", -1, 1, "", this),
235
 
            new Among ( "e", -1, 2, "", this),
236
 
            new Among ( "o", -1, 1, "", this),
237
 
            new Among ( "os", -1, 1, "", this),
238
 
            new Among ( "\u00E1", -1, 1, "", this),
239
 
            new Among ( "\u00E9", -1, 2, "", this),
240
 
            new Among ( "\u00ED", -1, 1, "", this),
241
 
            new Among ( "\u00F3", -1, 1, "", this)
242
 
        };
243
 
 
244
 
        private static final char g_v[] = {17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 4, 10 };
245
 
 
246
 
        private int I_p2;
247
 
        private int I_p1;
248
 
        private int I_pV;
249
 
 
250
 
        private void copy_from(SpanishStemmer other) {
251
 
            I_p2 = other.I_p2;
252
 
            I_p1 = other.I_p1;
253
 
            I_pV = other.I_pV;
254
 
            super.copy_from(other);
255
 
        }
256
 
 
257
 
        private boolean r_mark_regions() {
258
 
            int v_1;
259
 
            int v_2;
260
 
            int v_3;
261
 
            int v_6;
262
 
            int v_8;
263
 
            // (, line 31
264
 
            I_pV = limit;
265
 
            I_p1 = limit;
266
 
            I_p2 = limit;
267
 
            // do, line 37
268
 
            v_1 = cursor;
269
 
            lab0: do {
270
 
                // (, line 37
271
 
                // or, line 39
272
 
                lab1: do {
273
 
                    v_2 = cursor;
274
 
                    lab2: do {
275
 
                        // (, line 38
276
 
                        if (!(in_grouping(g_v, 97, 252)))
277
 
                        {
278
 
                            break lab2;
279
 
                        }
280
 
                        // or, line 38
281
 
                        lab3: do {
282
 
                            v_3 = cursor;
283
 
                            lab4: do {
284
 
                                // (, line 38
285
 
                                if (!(out_grouping(g_v, 97, 252)))
286
 
                                {
287
 
                                    break lab4;
288
 
                                }
289
 
                                // gopast, line 38
290
 
                                golab5: while(true)
291
 
                                {
292
 
                                    lab6: do {
293
 
                                        if (!(in_grouping(g_v, 97, 252)))
294
 
                                        {
295
 
                                            break lab6;
296
 
                                        }
297
 
                                        break golab5;
298
 
                                    } while (false);
299
 
                                    if (cursor >= limit)
300
 
                                    {
301
 
                                        break lab4;
302
 
                                    }
303
 
                                    cursor++;
304
 
                                }
305
 
                                break lab3;
306
 
                            } while (false);
307
 
                            cursor = v_3;
308
 
                            // (, line 38
309
 
                            if (!(in_grouping(g_v, 97, 252)))
310
 
                            {
311
 
                                break lab2;
312
 
                            }
313
 
                            // gopast, line 38
314
 
                            golab7: while(true)
315
 
                            {
316
 
                                lab8: do {
317
 
                                    if (!(out_grouping(g_v, 97, 252)))
318
 
                                    {
319
 
                                        break lab8;
320
 
                                    }
321
 
                                    break golab7;
322
 
                                } while (false);
323
 
                                if (cursor >= limit)
324
 
                                {
325
 
                                    break lab2;
326
 
                                }
327
 
                                cursor++;
328
 
                            }
329
 
                        } while (false);
330
 
                        break lab1;
331
 
                    } while (false);
332
 
                    cursor = v_2;
333
 
                    // (, line 40
334
 
                    if (!(out_grouping(g_v, 97, 252)))
335
 
                    {
336
 
                        break lab0;
337
 
                    }
338
 
                    // or, line 40
339
 
                    lab9: do {
340
 
                        v_6 = cursor;
341
 
                        lab10: do {
342
 
                            // (, line 40
343
 
                            if (!(out_grouping(g_v, 97, 252)))
344
 
                            {
345
 
                                break lab10;
346
 
                            }
347
 
                            // gopast, line 40
348
 
                            golab11: while(true)
349
 
                            {
350
 
                                lab12: do {
351
 
                                    if (!(in_grouping(g_v, 97, 252)))
352
 
                                    {
353
 
                                        break lab12;
354
 
                                    }
355
 
                                    break golab11;
356
 
                                } while (false);
357
 
                                if (cursor >= limit)
358
 
                                {
359
 
                                    break lab10;
360
 
                                }
361
 
                                cursor++;
362
 
                            }
363
 
                            break lab9;
364
 
                        } while (false);
365
 
                        cursor = v_6;
366
 
                        // (, line 40
367
 
                        if (!(in_grouping(g_v, 97, 252)))
368
 
                        {
369
 
                            break lab0;
370
 
                        }
371
 
                        // next, line 40
372
 
                        if (cursor >= limit)
373
 
                        {
374
 
                            break lab0;
375
 
                        }
376
 
                        cursor++;
377
 
                    } while (false);
378
 
                } while (false);
379
 
                // setmark pV, line 41
380
 
                I_pV = cursor;
381
 
            } while (false);
382
 
            cursor = v_1;
383
 
            // do, line 43
384
 
            v_8 = cursor;
385
 
            lab13: do {
386
 
                // (, line 43
387
 
                // gopast, line 44
388
 
                golab14: while(true)
389
 
                {
390
 
                    lab15: do {
391
 
                        if (!(in_grouping(g_v, 97, 252)))
392
 
                        {
393
 
                            break lab15;
394
 
                        }
395
 
                        break golab14;
396
 
                    } while (false);
397
 
                    if (cursor >= limit)
398
 
                    {
399
 
                        break lab13;
400
 
                    }
401
 
                    cursor++;
402
 
                }
403
 
                // gopast, line 44
404
 
                golab16: while(true)
405
 
                {
406
 
                    lab17: do {
407
 
                        if (!(out_grouping(g_v, 97, 252)))
408
 
                        {
409
 
                            break lab17;
410
 
                        }
411
 
                        break golab16;
412
 
                    } while (false);
413
 
                    if (cursor >= limit)
414
 
                    {
415
 
                        break lab13;
416
 
                    }
417
 
                    cursor++;
418
 
                }
419
 
                // setmark p1, line 44
420
 
                I_p1 = cursor;
421
 
                // gopast, line 45
422
 
                golab18: while(true)
423
 
                {
424
 
                    lab19: do {
425
 
                        if (!(in_grouping(g_v, 97, 252)))
426
 
                        {
427
 
                            break lab19;
428
 
                        }
429
 
                        break golab18;
430
 
                    } while (false);
431
 
                    if (cursor >= limit)
432
 
                    {
433
 
                        break lab13;
434
 
                    }
435
 
                    cursor++;
436
 
                }
437
 
                // gopast, line 45
438
 
                golab20: while(true)
439
 
                {
440
 
                    lab21: do {
441
 
                        if (!(out_grouping(g_v, 97, 252)))
442
 
                        {
443
 
                            break lab21;
444
 
                        }
445
 
                        break golab20;
446
 
                    } while (false);
447
 
                    if (cursor >= limit)
448
 
                    {
449
 
                        break lab13;
450
 
                    }
451
 
                    cursor++;
452
 
                }
453
 
                // setmark p2, line 45
454
 
                I_p2 = cursor;
455
 
            } while (false);
456
 
            cursor = v_8;
457
 
            return true;
458
 
        }
459
 
 
460
 
        private boolean r_postlude() {
461
 
            int among_var;
462
 
            int v_1;
463
 
            // repeat, line 49
464
 
            replab0: while(true)
465
 
            {
466
 
                v_1 = cursor;
467
 
                lab1: do {
468
 
                    // (, line 49
469
 
                    // [, line 50
470
 
                    bra = cursor;
471
 
                    // substring, line 50
472
 
                    among_var = find_among(a_0, 6);
473
 
                    if (among_var == 0)
474
 
                    {
475
 
                        break lab1;
476
 
                    }
477
 
                    // ], line 50
478
 
                    ket = cursor;
479
 
                    switch(among_var) {
480
 
                        case 0:
481
 
                            break lab1;
482
 
                        case 1:
483
 
                            // (, line 51
484
 
                            // <-, line 51
485
 
                            slice_from("a");
486
 
                            break;
487
 
                        case 2:
488
 
                            // (, line 52
489
 
                            // <-, line 52
490
 
                            slice_from("e");
491
 
                            break;
492
 
                        case 3:
493
 
                            // (, line 53
494
 
                            // <-, line 53
495
 
                            slice_from("i");
496
 
                            break;
497
 
                        case 4:
498
 
                            // (, line 54
499
 
                            // <-, line 54
500
 
                            slice_from("o");
501
 
                            break;
502
 
                        case 5:
503
 
                            // (, line 55
504
 
                            // <-, line 55
505
 
                            slice_from("u");
506
 
                            break;
507
 
                        case 6:
508
 
                            // (, line 57
509
 
                            // next, line 57
510
 
                            if (cursor >= limit)
511
 
                            {
512
 
                                break lab1;
513
 
                            }
514
 
                            cursor++;
515
 
                            break;
516
 
                    }
517
 
                    continue replab0;
518
 
                } while (false);
519
 
                cursor = v_1;
520
 
                break replab0;
521
 
            }
522
 
            return true;
523
 
        }
524
 
 
525
 
        private boolean r_RV() {
526
 
            if (!(I_pV <= cursor))
527
 
            {
528
 
                return false;
529
 
            }
530
 
            return true;
531
 
        }
532
 
 
533
 
        private boolean r_R1() {
534
 
            if (!(I_p1 <= cursor))
535
 
            {
536
 
                return false;
537
 
            }
538
 
            return true;
539
 
        }
540
 
 
541
 
        private boolean r_R2() {
542
 
            if (!(I_p2 <= cursor))
543
 
            {
544
 
                return false;
545
 
            }
546
 
            return true;
547
 
        }
548
 
 
549
 
        private boolean r_attached_pronoun() {
550
 
            int among_var;
551
 
            // (, line 67
552
 
            // [, line 68
553
 
            ket = cursor;
554
 
            // substring, line 68
555
 
            if (find_among_b(a_1, 13) == 0)
556
 
            {
557
 
                return false;
558
 
            }
559
 
            // ], line 68
560
 
            bra = cursor;
561
 
            // substring, line 72
562
 
            among_var = find_among_b(a_2, 11);
563
 
            if (among_var == 0)
564
 
            {
565
 
                return false;
566
 
            }
567
 
            // call RV, line 72
568
 
            if (!r_RV())
569
 
            {
570
 
                return false;
571
 
            }
572
 
            switch(among_var) {
573
 
                case 0:
574
 
                    return false;
575
 
                case 1:
576
 
                    // (, line 73
577
 
                    // ], line 73
578
 
                    bra = cursor;
579
 
                    // <-, line 73
580
 
                    slice_from("iendo");
581
 
                    break;
582
 
                case 2:
583
 
                    // (, line 74
584
 
                    // ], line 74
585
 
                    bra = cursor;
586
 
                    // <-, line 74
587
 
                    slice_from("ando");
588
 
                    break;
589
 
                case 3:
590
 
                    // (, line 75
591
 
                    // ], line 75
592
 
                    bra = cursor;
593
 
                    // <-, line 75
594
 
                    slice_from("ar");
595
 
                    break;
596
 
                case 4:
597
 
                    // (, line 76
598
 
                    // ], line 76
599
 
                    bra = cursor;
600
 
                    // <-, line 76
601
 
                    slice_from("er");
602
 
                    break;
603
 
                case 5:
604
 
                    // (, line 77
605
 
                    // ], line 77
606
 
                    bra = cursor;
607
 
                    // <-, line 77
608
 
                    slice_from("ir");
609
 
                    break;
610
 
                case 6:
611
 
                    // (, line 81
612
 
                    // delete, line 81
613
 
                    slice_del();
614
 
                    break;
615
 
                case 7:
616
 
                    // (, line 82
617
 
                    // literal, line 82
618
 
                    if (!(eq_s_b(1, "u")))
619
 
                    {
620
 
                        return false;
621
 
                    }
622
 
                    // delete, line 82
623
 
                    slice_del();
624
 
                    break;
625
 
            }
626
 
            return true;
627
 
        }
628
 
 
629
 
        private boolean r_standard_suffix() {
630
 
            int among_var;
631
 
            int v_1;
632
 
            int v_2;
633
 
            int v_3;
634
 
            int v_4;
635
 
            int v_5;
636
 
            // (, line 86
637
 
            // [, line 87
638
 
            ket = cursor;
639
 
            // substring, line 87
640
 
            among_var = find_among_b(a_6, 46);
641
 
            if (among_var == 0)
642
 
            {
643
 
                return false;
644
 
            }
645
 
            // ], line 87
646
 
            bra = cursor;
647
 
            switch(among_var) {
648
 
                case 0:
649
 
                    return false;
650
 
                case 1:
651
 
                    // (, line 98
652
 
                    // call R2, line 99
653
 
                    if (!r_R2())
654
 
                    {
655
 
                        return false;
656
 
                    }
657
 
                    // delete, line 99
658
 
                    slice_del();
659
 
                    break;
660
 
                case 2:
661
 
                    // (, line 104
662
 
                    // call R2, line 105
663
 
                    if (!r_R2())
664
 
                    {
665
 
                        return false;
666
 
                    }
667
 
                    // delete, line 105
668
 
                    slice_del();
669
 
                    // try, line 106
670
 
                    v_1 = limit - cursor;
671
 
                    lab0: do {
672
 
                        // (, line 106
673
 
                        // [, line 106
674
 
                        ket = cursor;
675
 
                        // literal, line 106
676
 
                        if (!(eq_s_b(2, "ic")))
677
 
                        {
678
 
                            cursor = limit - v_1;
679
 
                            break lab0;
680
 
                        }
681
 
                        // ], line 106
682
 
                        bra = cursor;
683
 
                        // call R2, line 106
684
 
                        if (!r_R2())
685
 
                        {
686
 
                            cursor = limit - v_1;
687
 
                            break lab0;
688
 
                        }
689
 
                        // delete, line 106
690
 
                        slice_del();
691
 
                    } while (false);
692
 
                    break;
693
 
                case 3:
694
 
                    // (, line 110
695
 
                    // call R2, line 111
696
 
                    if (!r_R2())
697
 
                    {
698
 
                        return false;
699
 
                    }
700
 
                    // <-, line 111
701
 
                    slice_from("log");
702
 
                    break;
703
 
                case 4:
704
 
                    // (, line 114
705
 
                    // call R2, line 115
706
 
                    if (!r_R2())
707
 
                    {
708
 
                        return false;
709
 
                    }
710
 
                    // <-, line 115
711
 
                    slice_from("u");
712
 
                    break;
713
 
                case 5:
714
 
                    // (, line 118
715
 
                    // call R2, line 119
716
 
                    if (!r_R2())
717
 
                    {
718
 
                        return false;
719
 
                    }
720
 
                    // <-, line 119
721
 
                    slice_from("ente");
722
 
                    break;
723
 
                case 6:
724
 
                    // (, line 122
725
 
                    // call R1, line 123
726
 
                    if (!r_R1())
727
 
                    {
728
 
                        return false;
729
 
                    }
730
 
                    // delete, line 123
731
 
                    slice_del();
732
 
                    // try, line 124
733
 
                    v_2 = limit - cursor;
734
 
                    lab1: do {
735
 
                        // (, line 124
736
 
                        // [, line 125
737
 
                        ket = cursor;
738
 
                        // substring, line 125
739
 
                        among_var = find_among_b(a_3, 4);
740
 
                        if (among_var == 0)
741
 
                        {
742
 
                            cursor = limit - v_2;
743
 
                            break lab1;
744
 
                        }
745
 
                        // ], line 125
746
 
                        bra = cursor;
747
 
                        // call R2, line 125
748
 
                        if (!r_R2())
749
 
                        {
750
 
                            cursor = limit - v_2;
751
 
                            break lab1;
752
 
                        }
753
 
                        // delete, line 125
754
 
                        slice_del();
755
 
                        switch(among_var) {
756
 
                            case 0:
757
 
                                cursor = limit - v_2;
758
 
                                break lab1;
759
 
                            case 1:
760
 
                                // (, line 126
761
 
                                // [, line 126
762
 
                                ket = cursor;
763
 
                                // literal, line 126
764
 
                                if (!(eq_s_b(2, "at")))
765
 
                                {
766
 
                                    cursor = limit - v_2;
767
 
                                    break lab1;
768
 
                                }
769
 
                                // ], line 126
770
 
                                bra = cursor;
771
 
                                // call R2, line 126
772
 
                                if (!r_R2())
773
 
                                {
774
 
                                    cursor = limit - v_2;
775
 
                                    break lab1;
776
 
                                }
777
 
                                // delete, line 126
778
 
                                slice_del();
779
 
                                break;
780
 
                        }
781
 
                    } while (false);
782
 
                    break;
783
 
                case 7:
784
 
                    // (, line 134
785
 
                    // call R2, line 135
786
 
                    if (!r_R2())
787
 
                    {
788
 
                        return false;
789
 
                    }
790
 
                    // delete, line 135
791
 
                    slice_del();
792
 
                    // try, line 136
793
 
                    v_3 = limit - cursor;
794
 
                    lab2: do {
795
 
                        // (, line 136
796
 
                        // [, line 137
797
 
                        ket = cursor;
798
 
                        // substring, line 137
799
 
                        among_var = find_among_b(a_4, 3);
800
 
                        if (among_var == 0)
801
 
                        {
802
 
                            cursor = limit - v_3;
803
 
                            break lab2;
804
 
                        }
805
 
                        // ], line 137
806
 
                        bra = cursor;
807
 
                        switch(among_var) {
808
 
                            case 0:
809
 
                                cursor = limit - v_3;
810
 
                                break lab2;
811
 
                            case 1:
812
 
                                // (, line 140
813
 
                                // call R2, line 140
814
 
                                if (!r_R2())
815
 
                                {
816
 
                                    cursor = limit - v_3;
817
 
                                    break lab2;
818
 
                                }
819
 
                                // delete, line 140
820
 
                                slice_del();
821
 
                                break;
822
 
                        }
823
 
                    } while (false);
824
 
                    break;
825
 
                case 8:
826
 
                    // (, line 146
827
 
                    // call R2, line 147
828
 
                    if (!r_R2())
829
 
                    {
830
 
                        return false;
831
 
                    }
832
 
                    // delete, line 147
833
 
                    slice_del();
834
 
                    // try, line 148
835
 
                    v_4 = limit - cursor;
836
 
                    lab3: do {
837
 
                        // (, line 148
838
 
                        // [, line 149
839
 
                        ket = cursor;
840
 
                        // substring, line 149
841
 
                        among_var = find_among_b(a_5, 3);
842
 
                        if (among_var == 0)
843
 
                        {
844
 
                            cursor = limit - v_4;
845
 
                            break lab3;
846
 
                        }
847
 
                        // ], line 149
848
 
                        bra = cursor;
849
 
                        switch(among_var) {
850
 
                            case 0:
851
 
                                cursor = limit - v_4;
852
 
                                break lab3;
853
 
                            case 1:
854
 
                                // (, line 152
855
 
                                // call R2, line 152
856
 
                                if (!r_R2())
857
 
                                {
858
 
                                    cursor = limit - v_4;
859
 
                                    break lab3;
860
 
                                }
861
 
                                // delete, line 152
862
 
                                slice_del();
863
 
                                break;
864
 
                        }
865
 
                    } while (false);
866
 
                    break;
867
 
                case 9:
868
 
                    // (, line 158
869
 
                    // call R2, line 159
870
 
                    if (!r_R2())
871
 
                    {
872
 
                        return false;
873
 
                    }
874
 
                    // delete, line 159
875
 
                    slice_del();
876
 
                    // try, line 160
877
 
                    v_5 = limit - cursor;
878
 
                    lab4: do {
879
 
                        // (, line 160
880
 
                        // [, line 161
881
 
                        ket = cursor;
882
 
                        // literal, line 161
883
 
                        if (!(eq_s_b(2, "at")))
884
 
                        {
885
 
                            cursor = limit - v_5;
886
 
                            break lab4;
887
 
                        }
888
 
                        // ], line 161
889
 
                        bra = cursor;
890
 
                        // call R2, line 161
891
 
                        if (!r_R2())
892
 
                        {
893
 
                            cursor = limit - v_5;
894
 
                            break lab4;
895
 
                        }
896
 
                        // delete, line 161
897
 
                        slice_del();
898
 
                    } while (false);
899
 
                    break;
900
 
            }
901
 
            return true;
902
 
        }
903
 
 
904
 
        private boolean r_y_verb_suffix() {
905
 
            int among_var;
906
 
            int v_1;
907
 
            int v_2;
908
 
            // (, line 167
909
 
            // setlimit, line 168
910
 
            v_1 = limit - cursor;
911
 
            // tomark, line 168
912
 
            if (cursor < I_pV)
913
 
            {
914
 
                return false;
915
 
            }
916
 
            cursor = I_pV;
917
 
            v_2 = limit_backward;
918
 
            limit_backward = cursor;
919
 
            cursor = limit - v_1;
920
 
            // (, line 168
921
 
            // [, line 168
922
 
            ket = cursor;
923
 
            // substring, line 168
924
 
            among_var = find_among_b(a_7, 12);
925
 
            if (among_var == 0)
926
 
            {
927
 
                limit_backward = v_2;
928
 
                return false;
929
 
            }
930
 
            // ], line 168
931
 
            bra = cursor;
932
 
            limit_backward = v_2;
933
 
            switch(among_var) {
934
 
                case 0:
935
 
                    return false;
936
 
                case 1:
937
 
                    // (, line 171
938
 
                    // literal, line 171
939
 
                    if (!(eq_s_b(1, "u")))
940
 
                    {
941
 
                        return false;
942
 
                    }
943
 
                    // delete, line 171
944
 
                    slice_del();
945
 
                    break;
946
 
            }
947
 
            return true;
948
 
        }
949
 
 
950
 
        private boolean r_verb_suffix() {
951
 
            int among_var;
952
 
            int v_1;
953
 
            int v_2;
954
 
            int v_3;
955
 
            int v_4;
956
 
            // (, line 175
957
 
            // setlimit, line 176
958
 
            v_1 = limit - cursor;
959
 
            // tomark, line 176
960
 
            if (cursor < I_pV)
961
 
            {
962
 
                return false;
963
 
            }
964
 
            cursor = I_pV;
965
 
            v_2 = limit_backward;
966
 
            limit_backward = cursor;
967
 
            cursor = limit - v_1;
968
 
            // (, line 176
969
 
            // [, line 176
970
 
            ket = cursor;
971
 
            // substring, line 176
972
 
            among_var = find_among_b(a_8, 96);
973
 
            if (among_var == 0)
974
 
            {
975
 
                limit_backward = v_2;
976
 
                return false;
977
 
            }
978
 
            // ], line 176
979
 
            bra = cursor;
980
 
            limit_backward = v_2;
981
 
            switch(among_var) {
982
 
                case 0:
983
 
                    return false;
984
 
                case 1:
985
 
                    // (, line 179
986
 
                    // try, line 179
987
 
                    v_3 = limit - cursor;
988
 
                    lab0: do {
989
 
                        // (, line 179
990
 
                        // literal, line 179
991
 
                        if (!(eq_s_b(1, "u")))
992
 
                        {
993
 
                            cursor = limit - v_3;
994
 
                            break lab0;
995
 
                        }
996
 
                        // test, line 179
997
 
                        v_4 = limit - cursor;
998
 
                        // literal, line 179
999
 
                        if (!(eq_s_b(1, "g")))
1000
 
                        {
1001
 
                            cursor = limit - v_3;
1002
 
                            break lab0;
1003
 
                        }
1004
 
                        cursor = limit - v_4;
1005
 
                    } while (false);
1006
 
                    // ], line 179
1007
 
                    bra = cursor;
1008
 
                    // delete, line 179
1009
 
                    slice_del();
1010
 
                    break;
1011
 
                case 2:
1012
 
                    // (, line 200
1013
 
                    // delete, line 200
1014
 
                    slice_del();
1015
 
                    break;
1016
 
            }
1017
 
            return true;
1018
 
        }
1019
 
 
1020
 
        private boolean r_residual_suffix() {
1021
 
            int among_var;
1022
 
            int v_1;
1023
 
            int v_2;
1024
 
            // (, line 204
1025
 
            // [, line 205
1026
 
            ket = cursor;
1027
 
            // substring, line 205
1028
 
            among_var = find_among_b(a_9, 8);
1029
 
            if (among_var == 0)
1030
 
            {
1031
 
                return false;
1032
 
            }
1033
 
            // ], line 205
1034
 
            bra = cursor;
1035
 
            switch(among_var) {
1036
 
                case 0:
1037
 
                    return false;
1038
 
                case 1:
1039
 
                    // (, line 208
1040
 
                    // call RV, line 208
1041
 
                    if (!r_RV())
1042
 
                    {
1043
 
                        return false;
1044
 
                    }
1045
 
                    // delete, line 208
1046
 
                    slice_del();
1047
 
                    break;
1048
 
                case 2:
1049
 
                    // (, line 210
1050
 
                    // call RV, line 210
1051
 
                    if (!r_RV())
1052
 
                    {
1053
 
                        return false;
1054
 
                    }
1055
 
                    // delete, line 210
1056
 
                    slice_del();
1057
 
                    // try, line 210
1058
 
                    v_1 = limit - cursor;
1059
 
                    lab0: do {
1060
 
                        // (, line 210
1061
 
                        // [, line 210
1062
 
                        ket = cursor;
1063
 
                        // literal, line 210
1064
 
                        if (!(eq_s_b(1, "u")))
1065
 
                        {
1066
 
                            cursor = limit - v_1;
1067
 
                            break lab0;
1068
 
                        }
1069
 
                        // ], line 210
1070
 
                        bra = cursor;
1071
 
                        // test, line 210
1072
 
                        v_2 = limit - cursor;
1073
 
                        // literal, line 210
1074
 
                        if (!(eq_s_b(1, "g")))
1075
 
                        {
1076
 
                            cursor = limit - v_1;
1077
 
                            break lab0;
1078
 
                        }
1079
 
                        cursor = limit - v_2;
1080
 
                        // call RV, line 210
1081
 
                        if (!r_RV())
1082
 
                        {
1083
 
                            cursor = limit - v_1;
1084
 
                            break lab0;
1085
 
                        }
1086
 
                        // delete, line 210
1087
 
                        slice_del();
1088
 
                    } while (false);
1089
 
                    break;
1090
 
            }
1091
 
            return true;
1092
 
        }
1093
 
 
1094
 
        public boolean stem() {
1095
 
            int v_1;
1096
 
            int v_2;
1097
 
            int v_3;
1098
 
            int v_4;
1099
 
            int v_5;
1100
 
            int v_6;
1101
 
            // (, line 215
1102
 
            // do, line 216
1103
 
            v_1 = cursor;
1104
 
            lab0: do {
1105
 
                // call mark_regions, line 216
1106
 
                if (!r_mark_regions())
1107
 
                {
1108
 
                    break lab0;
1109
 
                }
1110
 
            } while (false);
1111
 
            cursor = v_1;
1112
 
            // backwards, line 217
1113
 
            limit_backward = cursor; cursor = limit;
1114
 
            // (, line 217
1115
 
            // do, line 218
1116
 
            v_2 = limit - cursor;
1117
 
            lab1: do {
1118
 
                // call attached_pronoun, line 218
1119
 
                if (!r_attached_pronoun())
1120
 
                {
1121
 
                    break lab1;
1122
 
                }
1123
 
            } while (false);
1124
 
            cursor = limit - v_2;
1125
 
            // do, line 219
1126
 
            v_3 = limit - cursor;
1127
 
            lab2: do {
1128
 
                // (, line 219
1129
 
                // or, line 219
1130
 
                lab3: do {
1131
 
                    v_4 = limit - cursor;
1132
 
                    lab4: do {
1133
 
                        // call standard_suffix, line 219
1134
 
                        if (!r_standard_suffix())
1135
 
                        {
1136
 
                            break lab4;
1137
 
                        }
1138
 
                        break lab3;
1139
 
                    } while (false);
1140
 
                    cursor = limit - v_4;
1141
 
                    lab5: do {
1142
 
                        // call y_verb_suffix, line 220
1143
 
                        if (!r_y_verb_suffix())
1144
 
                        {
1145
 
                            break lab5;
1146
 
                        }
1147
 
                        break lab3;
1148
 
                    } while (false);
1149
 
                    cursor = limit - v_4;
1150
 
                    // call verb_suffix, line 221
1151
 
                    if (!r_verb_suffix())
1152
 
                    {
1153
 
                        break lab2;
1154
 
                    }
1155
 
                } while (false);
1156
 
            } while (false);
1157
 
            cursor = limit - v_3;
1158
 
            // do, line 223
1159
 
            v_5 = limit - cursor;
1160
 
            lab6: do {
1161
 
                // call residual_suffix, line 223
1162
 
                if (!r_residual_suffix())
1163
 
                {
1164
 
                    break lab6;
1165
 
                }
1166
 
            } while (false);
1167
 
            cursor = limit - v_5;
1168
 
            cursor = limit_backward;            // do, line 225
1169
 
            v_6 = cursor;
1170
 
            lab7: do {
1171
 
                // call postlude, line 225
1172
 
                if (!r_postlude())
1173
 
                {
1174
 
                    break lab7;
1175
 
                }
1176
 
            } while (false);
1177
 
            cursor = v_6;
1178
 
            return true;
1179
 
        }
1180
 
 
1181
 
}
1182