← 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/KpStemmer.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/KpStemmer.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 KpStemmer extends SnowballProgram {
11
 
 
12
 
        private Among a_0[] = {
13
 
            new Among ( "nde", -1, 7, "", this),
14
 
            new Among ( "en", -1, 6, "", this),
15
 
            new Among ( "s", -1, 2, "", this),
16
 
            new Among ( "'s", 2, 1, "", this),
17
 
            new Among ( "es", 2, 4, "", this),
18
 
            new Among ( "ies", 4, 3, "", this),
19
 
            new Among ( "aus", 2, 5, "", this)
20
 
        };
21
 
 
22
 
        private Among a_1[] = {
23
 
            new Among ( "de", -1, 5, "", this),
24
 
            new Among ( "ge", -1, 2, "", this),
25
 
            new Among ( "ische", -1, 4, "", this),
26
 
            new Among ( "je", -1, 1, "", this),
27
 
            new Among ( "lijke", -1, 3, "", this),
28
 
            new Among ( "le", -1, 9, "", this),
29
 
            new Among ( "ene", -1, 10, "", this),
30
 
            new Among ( "re", -1, 8, "", this),
31
 
            new Among ( "se", -1, 7, "", this),
32
 
            new Among ( "te", -1, 6, "", this),
33
 
            new Among ( "ieve", -1, 11, "", this)
34
 
        };
35
 
 
36
 
        private Among a_2[] = {
37
 
            new Among ( "heid", -1, 3, "", this),
38
 
            new Among ( "fie", -1, 7, "", this),
39
 
            new Among ( "gie", -1, 8, "", this),
40
 
            new Among ( "atie", -1, 1, "", this),
41
 
            new Among ( "isme", -1, 5, "", this),
42
 
            new Among ( "ing", -1, 5, "", this),
43
 
            new Among ( "arij", -1, 6, "", this),
44
 
            new Among ( "erij", -1, 5, "", this),
45
 
            new Among ( "sel", -1, 3, "", this),
46
 
            new Among ( "rder", -1, 4, "", this),
47
 
            new Among ( "ster", -1, 3, "", this),
48
 
            new Among ( "iteit", -1, 2, "", this),
49
 
            new Among ( "dst", -1, 10, "", this),
50
 
            new Among ( "tst", -1, 9, "", this)
51
 
        };
52
 
 
53
 
        private Among a_3[] = {
54
 
            new Among ( "end", -1, 10, "", this),
55
 
            new Among ( "atief", -1, 2, "", this),
56
 
            new Among ( "erig", -1, 10, "", this),
57
 
            new Among ( "achtig", -1, 9, "", this),
58
 
            new Among ( "ioneel", -1, 1, "", this),
59
 
            new Among ( "baar", -1, 3, "", this),
60
 
            new Among ( "laar", -1, 5, "", this),
61
 
            new Among ( "naar", -1, 4, "", this),
62
 
            new Among ( "raar", -1, 6, "", this),
63
 
            new Among ( "eriger", -1, 10, "", this),
64
 
            new Among ( "achtiger", -1, 9, "", this),
65
 
            new Among ( "lijker", -1, 8, "", this),
66
 
            new Among ( "tant", -1, 7, "", this),
67
 
            new Among ( "erigst", -1, 10, "", this),
68
 
            new Among ( "achtigst", -1, 9, "", this),
69
 
            new Among ( "lijkst", -1, 8, "", this)
70
 
        };
71
 
 
72
 
        private Among a_4[] = {
73
 
            new Among ( "ig", -1, 1, "", this),
74
 
            new Among ( "iger", -1, 1, "", this),
75
 
            new Among ( "igst", -1, 1, "", this)
76
 
        };
77
 
 
78
 
        private Among a_5[] = {
79
 
            new Among ( "ft", -1, 2, "", this),
80
 
            new Among ( "kt", -1, 1, "", this),
81
 
            new Among ( "pt", -1, 3, "", this)
82
 
        };
83
 
 
84
 
        private Among a_6[] = {
85
 
            new Among ( "bb", -1, 1, "", this),
86
 
            new Among ( "cc", -1, 2, "", this),
87
 
            new Among ( "dd", -1, 3, "", this),
88
 
            new Among ( "ff", -1, 4, "", this),
89
 
            new Among ( "gg", -1, 5, "", this),
90
 
            new Among ( "hh", -1, 6, "", this),
91
 
            new Among ( "jj", -1, 7, "", this),
92
 
            new Among ( "kk", -1, 8, "", this),
93
 
            new Among ( "ll", -1, 9, "", this),
94
 
            new Among ( "mm", -1, 10, "", this),
95
 
            new Among ( "nn", -1, 11, "", this),
96
 
            new Among ( "pp", -1, 12, "", this),
97
 
            new Among ( "qq", -1, 13, "", this),
98
 
            new Among ( "rr", -1, 14, "", this),
99
 
            new Among ( "ss", -1, 15, "", this),
100
 
            new Among ( "tt", -1, 16, "", this),
101
 
            new Among ( "v", -1, 21, "", this),
102
 
            new Among ( "vv", 16, 17, "", this),
103
 
            new Among ( "ww", -1, 18, "", this),
104
 
            new Among ( "xx", -1, 19, "", this),
105
 
            new Among ( "z", -1, 22, "", this),
106
 
            new Among ( "zz", 20, 20, "", this)
107
 
        };
108
 
 
109
 
        private Among a_7[] = {
110
 
            new Among ( "d", -1, 1, "", this),
111
 
            new Among ( "t", -1, 2, "", this)
112
 
        };
113
 
 
114
 
        private static final char g_v[] = {17, 65, 16, 1 };
115
 
 
116
 
        private static final char g_v_WX[] = {17, 65, 208, 1 };
117
 
 
118
 
        private static final char g_AOU[] = {1, 64, 16 };
119
 
 
120
 
        private static final char g_AIOU[] = {1, 65, 16 };
121
 
 
122
 
        private boolean B_GE_removed;
123
 
        private boolean B_stemmed;
124
 
        private boolean B_Y_found;
125
 
        private int I_p2;
126
 
        private int I_p1;
127
 
        private int I_x;
128
 
        private StringBuilder S_ch = new StringBuilder();
129
 
 
130
 
        private void copy_from(KpStemmer other) {
131
 
            B_GE_removed = other.B_GE_removed;
132
 
            B_stemmed = other.B_stemmed;
133
 
            B_Y_found = other.B_Y_found;
134
 
            I_p2 = other.I_p2;
135
 
            I_p1 = other.I_p1;
136
 
            I_x = other.I_x;
137
 
            S_ch = other.S_ch;
138
 
            super.copy_from(other);
139
 
        }
140
 
 
141
 
        private boolean r_R1() {
142
 
            // (, line 32
143
 
            // setmark x, line 32
144
 
            I_x = cursor;
145
 
            if (!(I_x >= I_p1))
146
 
            {
147
 
                return false;
148
 
            }
149
 
            return true;
150
 
        }
151
 
 
152
 
        private boolean r_R2() {
153
 
            // (, line 33
154
 
            // setmark x, line 33
155
 
            I_x = cursor;
156
 
            if (!(I_x >= I_p2))
157
 
            {
158
 
                return false;
159
 
            }
160
 
            return true;
161
 
        }
162
 
 
163
 
        private boolean r_V() {
164
 
            int v_1;
165
 
            int v_2;
166
 
            // test, line 35
167
 
            v_1 = limit - cursor;
168
 
            // (, line 35
169
 
            // or, line 35
170
 
            lab0: do {
171
 
                v_2 = limit - cursor;
172
 
                lab1: do {
173
 
                    if (!(in_grouping_b(g_v, 97, 121)))
174
 
                    {
175
 
                        break lab1;
176
 
                    }
177
 
                    break lab0;
178
 
                } while (false);
179
 
                cursor = limit - v_2;
180
 
                // literal, line 35
181
 
                if (!(eq_s_b(2, "ij")))
182
 
                {
183
 
                    return false;
184
 
                }
185
 
            } while (false);
186
 
            cursor = limit - v_1;
187
 
            return true;
188
 
        }
189
 
 
190
 
        private boolean r_VX() {
191
 
            int v_1;
192
 
            int v_2;
193
 
            // test, line 36
194
 
            v_1 = limit - cursor;
195
 
            // (, line 36
196
 
            // next, line 36
197
 
            if (cursor <= limit_backward)
198
 
            {
199
 
                return false;
200
 
            }
201
 
            cursor--;
202
 
            // or, line 36
203
 
            lab0: do {
204
 
                v_2 = limit - cursor;
205
 
                lab1: do {
206
 
                    if (!(in_grouping_b(g_v, 97, 121)))
207
 
                    {
208
 
                        break lab1;
209
 
                    }
210
 
                    break lab0;
211
 
                } while (false);
212
 
                cursor = limit - v_2;
213
 
                // literal, line 36
214
 
                if (!(eq_s_b(2, "ij")))
215
 
                {
216
 
                    return false;
217
 
                }
218
 
            } while (false);
219
 
            cursor = limit - v_1;
220
 
            return true;
221
 
        }
222
 
 
223
 
        private boolean r_C() {
224
 
            int v_1;
225
 
            int v_2;
226
 
            // test, line 37
227
 
            v_1 = limit - cursor;
228
 
            // (, line 37
229
 
            // not, line 37
230
 
            {
231
 
                v_2 = limit - cursor;
232
 
                lab0: do {
233
 
                    // literal, line 37
234
 
                    if (!(eq_s_b(2, "ij")))
235
 
                    {
236
 
                        break lab0;
237
 
                    }
238
 
                    return false;
239
 
                } while (false);
240
 
                cursor = limit - v_2;
241
 
            }
242
 
            if (!(out_grouping_b(g_v, 97, 121)))
243
 
            {
244
 
                return false;
245
 
            }
246
 
            cursor = limit - v_1;
247
 
            return true;
248
 
        }
249
 
 
250
 
        private boolean r_lengthen_V() {
251
 
            int v_1;
252
 
            int v_2;
253
 
            int v_3;
254
 
            int v_4;
255
 
            int v_5;
256
 
            int v_6;
257
 
            int v_7;
258
 
            int v_8;
259
 
            // do, line 39
260
 
            v_1 = limit - cursor;
261
 
            lab0: do {
262
 
                // (, line 39
263
 
                if (!(out_grouping_b(g_v_WX, 97, 121)))
264
 
                {
265
 
                    break lab0;
266
 
                }
267
 
                // [, line 40
268
 
                ket = cursor;
269
 
                // or, line 40
270
 
                lab1: do {
271
 
                    v_2 = limit - cursor;
272
 
                    lab2: do {
273
 
                        // (, line 40
274
 
                        if (!(in_grouping_b(g_AOU, 97, 117)))
275
 
                        {
276
 
                            break lab2;
277
 
                        }
278
 
                        // ], line 40
279
 
                        bra = cursor;
280
 
                        // test, line 40
281
 
                        v_3 = limit - cursor;
282
 
                        // (, line 40
283
 
                        // or, line 40
284
 
                        lab3: do {
285
 
                            v_4 = limit - cursor;
286
 
                            lab4: do {
287
 
                                if (!(out_grouping_b(g_v, 97, 121)))
288
 
                                {
289
 
                                    break lab4;
290
 
                                }
291
 
                                break lab3;
292
 
                            } while (false);
293
 
                            cursor = limit - v_4;
294
 
                            // atlimit, line 40
295
 
                            if (cursor > limit_backward)
296
 
                            {
297
 
                                break lab2;
298
 
                            }
299
 
                        } while (false);
300
 
                        cursor = limit - v_3;
301
 
                        break lab1;
302
 
                    } while (false);
303
 
                    cursor = limit - v_2;
304
 
                    // (, line 41
305
 
                    // literal, line 41
306
 
                    if (!(eq_s_b(1, "e")))
307
 
                    {
308
 
                        break lab0;
309
 
                    }
310
 
                    // ], line 41
311
 
                    bra = cursor;
312
 
                    // test, line 41
313
 
                    v_5 = limit - cursor;
314
 
                    // (, line 41
315
 
                    // or, line 41
316
 
                    lab5: do {
317
 
                        v_6 = limit - cursor;
318
 
                        lab6: do {
319
 
                            if (!(out_grouping_b(g_v, 97, 121)))
320
 
                            {
321
 
                                break lab6;
322
 
                            }
323
 
                            break lab5;
324
 
                        } while (false);
325
 
                        cursor = limit - v_6;
326
 
                        // atlimit, line 41
327
 
                        if (cursor > limit_backward)
328
 
                        {
329
 
                            break lab0;
330
 
                        }
331
 
                    } while (false);
332
 
                    // not, line 42
333
 
                    {
334
 
                        v_7 = limit - cursor;
335
 
                        lab7: do {
336
 
                            if (!(in_grouping_b(g_AIOU, 97, 117)))
337
 
                            {
338
 
                                break lab7;
339
 
                            }
340
 
                            break lab0;
341
 
                        } while (false);
342
 
                        cursor = limit - v_7;
343
 
                    }
344
 
                    // not, line 43
345
 
                    {
346
 
                        v_8 = limit - cursor;
347
 
                        lab8: do {
348
 
                            // (, line 43
349
 
                            // next, line 43
350
 
                            if (cursor <= limit_backward)
351
 
                            {
352
 
                                break lab8;
353
 
                            }
354
 
                            cursor--;
355
 
                            if (!(in_grouping_b(g_AIOU, 97, 117)))
356
 
                            {
357
 
                                break lab8;
358
 
                            }
359
 
                            if (!(out_grouping_b(g_v, 97, 121)))
360
 
                            {
361
 
                                break lab8;
362
 
                            }
363
 
                            break lab0;
364
 
                        } while (false);
365
 
                        cursor = limit - v_8;
366
 
                    }
367
 
                    cursor = limit - v_5;
368
 
                } while (false);
369
 
                // -> ch, line 44
370
 
                S_ch = slice_to(S_ch);
371
 
                // <+ ch, line 44
372
 
                {
373
 
                    int c = cursor;
374
 
                    insert(cursor, cursor, S_ch);
375
 
                    cursor = c;
376
 
                }
377
 
            } while (false);
378
 
            cursor = limit - v_1;
379
 
            return true;
380
 
        }
381
 
 
382
 
        private boolean r_Step_1() {
383
 
            int among_var;
384
 
            int v_1;
385
 
            int v_2;
386
 
            int v_3;
387
 
            int v_4;
388
 
            // (, line 48
389
 
            // [, line 49
390
 
            ket = cursor;
391
 
            // among, line 49
392
 
            among_var = find_among_b(a_0, 7);
393
 
            if (among_var == 0)
394
 
            {
395
 
                return false;
396
 
            }
397
 
            // (, line 49
398
 
            // ], line 49
399
 
            bra = cursor;
400
 
            switch(among_var) {
401
 
                case 0:
402
 
                    return false;
403
 
                case 1:
404
 
                    // (, line 51
405
 
                    // delete, line 51
406
 
                    slice_del();
407
 
                    break;
408
 
                case 2:
409
 
                    // (, line 52
410
 
                    // call R1, line 52
411
 
                    if (!r_R1())
412
 
                    {
413
 
                        return false;
414
 
                    }
415
 
                    // not, line 52
416
 
                    {
417
 
                        v_1 = limit - cursor;
418
 
                        lab0: do {
419
 
                            // (, line 52
420
 
                            // literal, line 52
421
 
                            if (!(eq_s_b(1, "t")))
422
 
                            {
423
 
                                break lab0;
424
 
                            }
425
 
                            // call R1, line 52
426
 
                            if (!r_R1())
427
 
                            {
428
 
                                break lab0;
429
 
                            }
430
 
                            return false;
431
 
                        } while (false);
432
 
                        cursor = limit - v_1;
433
 
                    }
434
 
                    // call C, line 52
435
 
                    if (!r_C())
436
 
                    {
437
 
                        return false;
438
 
                    }
439
 
                    // delete, line 52
440
 
                    slice_del();
441
 
                    break;
442
 
                case 3:
443
 
                    // (, line 53
444
 
                    // call R1, line 53
445
 
                    if (!r_R1())
446
 
                    {
447
 
                        return false;
448
 
                    }
449
 
                    // <-, line 53
450
 
                    slice_from("ie");
451
 
                    break;
452
 
                case 4:
453
 
                    // (, line 55
454
 
                    // or, line 55
455
 
                    lab1: do {
456
 
                        v_2 = limit - cursor;
457
 
                        lab2: do {
458
 
                            // (, line 55
459
 
                            // literal, line 55
460
 
                            if (!(eq_s_b(2, "ar")))
461
 
                            {
462
 
                                break lab2;
463
 
                            }
464
 
                            // call R1, line 55
465
 
                            if (!r_R1())
466
 
                            {
467
 
                                break lab2;
468
 
                            }
469
 
                            // call C, line 55
470
 
                            if (!r_C())
471
 
                            {
472
 
                                break lab2;
473
 
                            }
474
 
                            // ], line 55
475
 
                            bra = cursor;
476
 
                            // delete, line 55
477
 
                            slice_del();
478
 
                            // call lengthen_V, line 55
479
 
                            if (!r_lengthen_V())
480
 
                            {
481
 
                                break lab2;
482
 
                            }
483
 
                            break lab1;
484
 
                        } while (false);
485
 
                        cursor = limit - v_2;
486
 
                        lab3: do {
487
 
                            // (, line 56
488
 
                            // literal, line 56
489
 
                            if (!(eq_s_b(2, "er")))
490
 
                            {
491
 
                                break lab3;
492
 
                            }
493
 
                            // call R1, line 56
494
 
                            if (!r_R1())
495
 
                            {
496
 
                                break lab3;
497
 
                            }
498
 
                            // call C, line 56
499
 
                            if (!r_C())
500
 
                            {
501
 
                                break lab3;
502
 
                            }
503
 
                            // ], line 56
504
 
                            bra = cursor;
505
 
                            // delete, line 56
506
 
                            slice_del();
507
 
                            break lab1;
508
 
                        } while (false);
509
 
                        cursor = limit - v_2;
510
 
                        // (, line 57
511
 
                        // call R1, line 57
512
 
                        if (!r_R1())
513
 
                        {
514
 
                            return false;
515
 
                        }
516
 
                        // call C, line 57
517
 
                        if (!r_C())
518
 
                        {
519
 
                            return false;
520
 
                        }
521
 
                        // <-, line 57
522
 
                        slice_from("e");
523
 
                    } while (false);
524
 
                    break;
525
 
                case 5:
526
 
                    // (, line 59
527
 
                    // call R1, line 59
528
 
                    if (!r_R1())
529
 
                    {
530
 
                        return false;
531
 
                    }
532
 
                    // call V, line 59
533
 
                    if (!r_V())
534
 
                    {
535
 
                        return false;
536
 
                    }
537
 
                    // <-, line 59
538
 
                    slice_from("au");
539
 
                    break;
540
 
                case 6:
541
 
                    // (, line 60
542
 
                    // or, line 60
543
 
                    lab4: do {
544
 
                        v_3 = limit - cursor;
545
 
                        lab5: do {
546
 
                            // (, line 60
547
 
                            // literal, line 60
548
 
                            if (!(eq_s_b(3, "hed")))
549
 
                            {
550
 
                                break lab5;
551
 
                            }
552
 
                            // call R1, line 60
553
 
                            if (!r_R1())
554
 
                            {
555
 
                                break lab5;
556
 
                            }
557
 
                            // ], line 60
558
 
                            bra = cursor;
559
 
                            // <-, line 60
560
 
                            slice_from("heid");
561
 
                            break lab4;
562
 
                        } while (false);
563
 
                        cursor = limit - v_3;
564
 
                        lab6: do {
565
 
                            // (, line 61
566
 
                            // literal, line 61
567
 
                            if (!(eq_s_b(2, "nd")))
568
 
                            {
569
 
                                break lab6;
570
 
                            }
571
 
                            // delete, line 61
572
 
                            slice_del();
573
 
                            break lab4;
574
 
                        } while (false);
575
 
                        cursor = limit - v_3;
576
 
                        lab7: do {
577
 
                            // (, line 62
578
 
                            // literal, line 62
579
 
                            if (!(eq_s_b(1, "d")))
580
 
                            {
581
 
                                break lab7;
582
 
                            }
583
 
                            // call R1, line 62
584
 
                            if (!r_R1())
585
 
                            {
586
 
                                break lab7;
587
 
                            }
588
 
                            // call C, line 62
589
 
                            if (!r_C())
590
 
                            {
591
 
                                break lab7;
592
 
                            }
593
 
                            // ], line 62
594
 
                            bra = cursor;
595
 
                            // delete, line 62
596
 
                            slice_del();
597
 
                            break lab4;
598
 
                        } while (false);
599
 
                        cursor = limit - v_3;
600
 
                        lab8: do {
601
 
                            // (, line 63
602
 
                            // or, line 63
603
 
                            lab9: do {
604
 
                                v_4 = limit - cursor;
605
 
                                lab10: do {
606
 
                                    // literal, line 63
607
 
                                    if (!(eq_s_b(1, "i")))
608
 
                                    {
609
 
                                        break lab10;
610
 
                                    }
611
 
                                    break lab9;
612
 
                                } while (false);
613
 
                                cursor = limit - v_4;
614
 
                                // literal, line 63
615
 
                                if (!(eq_s_b(1, "j")))
616
 
                                {
617
 
                                    break lab8;
618
 
                                }
619
 
                            } while (false);
620
 
                            // call V, line 63
621
 
                            if (!r_V())
622
 
                            {
623
 
                                break lab8;
624
 
                            }
625
 
                            // delete, line 63
626
 
                            slice_del();
627
 
                            break lab4;
628
 
                        } while (false);
629
 
                        cursor = limit - v_3;
630
 
                        // (, line 64
631
 
                        // call R1, line 64
632
 
                        if (!r_R1())
633
 
                        {
634
 
                            return false;
635
 
                        }
636
 
                        // call C, line 64
637
 
                        if (!r_C())
638
 
                        {
639
 
                            return false;
640
 
                        }
641
 
                        // delete, line 64
642
 
                        slice_del();
643
 
                        // call lengthen_V, line 64
644
 
                        if (!r_lengthen_V())
645
 
                        {
646
 
                            return false;
647
 
                        }
648
 
                    } while (false);
649
 
                    break;
650
 
                case 7:
651
 
                    // (, line 65
652
 
                    // <-, line 65
653
 
                    slice_from("nd");
654
 
                    break;
655
 
            }
656
 
            return true;
657
 
        }
658
 
 
659
 
        private boolean r_Step_2() {
660
 
            int among_var;
661
 
            int v_1;
662
 
            // (, line 70
663
 
            // [, line 71
664
 
            ket = cursor;
665
 
            // among, line 71
666
 
            among_var = find_among_b(a_1, 11);
667
 
            if (among_var == 0)
668
 
            {
669
 
                return false;
670
 
            }
671
 
            // (, line 71
672
 
            // ], line 71
673
 
            bra = cursor;
674
 
            switch(among_var) {
675
 
                case 0:
676
 
                    return false;
677
 
                case 1:
678
 
                    // (, line 72
679
 
                    // or, line 72
680
 
                    lab0: do {
681
 
                        v_1 = limit - cursor;
682
 
                        lab1: do {
683
 
                            // (, line 72
684
 
                            // literal, line 72
685
 
                            if (!(eq_s_b(2, "'t")))
686
 
                            {
687
 
                                break lab1;
688
 
                            }
689
 
                            // ], line 72
690
 
                            bra = cursor;
691
 
                            // delete, line 72
692
 
                            slice_del();
693
 
                            break lab0;
694
 
                        } while (false);
695
 
                        cursor = limit - v_1;
696
 
                        lab2: do {
697
 
                            // (, line 73
698
 
                            // literal, line 73
699
 
                            if (!(eq_s_b(2, "et")))
700
 
                            {
701
 
                                break lab2;
702
 
                            }
703
 
                            // ], line 73
704
 
                            bra = cursor;
705
 
                            // call R1, line 73
706
 
                            if (!r_R1())
707
 
                            {
708
 
                                break lab2;
709
 
                            }
710
 
                            // call C, line 73
711
 
                            if (!r_C())
712
 
                            {
713
 
                                break lab2;
714
 
                            }
715
 
                            // delete, line 73
716
 
                            slice_del();
717
 
                            break lab0;
718
 
                        } while (false);
719
 
                        cursor = limit - v_1;
720
 
                        lab3: do {
721
 
                            // (, line 74
722
 
                            // literal, line 74
723
 
                            if (!(eq_s_b(3, "rnt")))
724
 
                            {
725
 
                                break lab3;
726
 
                            }
727
 
                            // ], line 74
728
 
                            bra = cursor;
729
 
                            // <-, line 74
730
 
                            slice_from("rn");
731
 
                            break lab0;
732
 
                        } while (false);
733
 
                        cursor = limit - v_1;
734
 
                        lab4: do {
735
 
                            // (, line 75
736
 
                            // literal, line 75
737
 
                            if (!(eq_s_b(1, "t")))
738
 
                            {
739
 
                                break lab4;
740
 
                            }
741
 
                            // ], line 75
742
 
                            bra = cursor;
743
 
                            // call R1, line 75
744
 
                            if (!r_R1())
745
 
                            {
746
 
                                break lab4;
747
 
                            }
748
 
                            // call VX, line 75
749
 
                            if (!r_VX())
750
 
                            {
751
 
                                break lab4;
752
 
                            }
753
 
                            // delete, line 75
754
 
                            slice_del();
755
 
                            break lab0;
756
 
                        } while (false);
757
 
                        cursor = limit - v_1;
758
 
                        lab5: do {
759
 
                            // (, line 76
760
 
                            // literal, line 76
761
 
                            if (!(eq_s_b(3, "ink")))
762
 
                            {
763
 
                                break lab5;
764
 
                            }
765
 
                            // ], line 76
766
 
                            bra = cursor;
767
 
                            // <-, line 76
768
 
                            slice_from("ing");
769
 
                            break lab0;
770
 
                        } while (false);
771
 
                        cursor = limit - v_1;
772
 
                        lab6: do {
773
 
                            // (, line 77
774
 
                            // literal, line 77
775
 
                            if (!(eq_s_b(2, "mp")))
776
 
                            {
777
 
                                break lab6;
778
 
                            }
779
 
                            // ], line 77
780
 
                            bra = cursor;
781
 
                            // <-, line 77
782
 
                            slice_from("m");
783
 
                            break lab0;
784
 
                        } while (false);
785
 
                        cursor = limit - v_1;
786
 
                        lab7: do {
787
 
                            // (, line 78
788
 
                            // literal, line 78
789
 
                            if (!(eq_s_b(1, "'")))
790
 
                            {
791
 
                                break lab7;
792
 
                            }
793
 
                            // ], line 78
794
 
                            bra = cursor;
795
 
                            // call R1, line 78
796
 
                            if (!r_R1())
797
 
                            {
798
 
                                break lab7;
799
 
                            }
800
 
                            // delete, line 78
801
 
                            slice_del();
802
 
                            break lab0;
803
 
                        } while (false);
804
 
                        cursor = limit - v_1;
805
 
                        // (, line 79
806
 
                        // ], line 79
807
 
                        bra = cursor;
808
 
                        // call R1, line 79
809
 
                        if (!r_R1())
810
 
                        {
811
 
                            return false;
812
 
                        }
813
 
                        // call C, line 79
814
 
                        if (!r_C())
815
 
                        {
816
 
                            return false;
817
 
                        }
818
 
                        // delete, line 79
819
 
                        slice_del();
820
 
                    } while (false);
821
 
                    break;
822
 
                case 2:
823
 
                    // (, line 80
824
 
                    // call R1, line 80
825
 
                    if (!r_R1())
826
 
                    {
827
 
                        return false;
828
 
                    }
829
 
                    // <-, line 80
830
 
                    slice_from("g");
831
 
                    break;
832
 
                case 3:
833
 
                    // (, line 81
834
 
                    // call R1, line 81
835
 
                    if (!r_R1())
836
 
                    {
837
 
                        return false;
838
 
                    }
839
 
                    // <-, line 81
840
 
                    slice_from("lijk");
841
 
                    break;
842
 
                case 4:
843
 
                    // (, line 82
844
 
                    // call R1, line 82
845
 
                    if (!r_R1())
846
 
                    {
847
 
                        return false;
848
 
                    }
849
 
                    // <-, line 82
850
 
                    slice_from("isch");
851
 
                    break;
852
 
                case 5:
853
 
                    // (, line 83
854
 
                    // call R1, line 83
855
 
                    if (!r_R1())
856
 
                    {
857
 
                        return false;
858
 
                    }
859
 
                    // call C, line 83
860
 
                    if (!r_C())
861
 
                    {
862
 
                        return false;
863
 
                    }
864
 
                    // delete, line 83
865
 
                    slice_del();
866
 
                    break;
867
 
                case 6:
868
 
                    // (, line 84
869
 
                    // call R1, line 84
870
 
                    if (!r_R1())
871
 
                    {
872
 
                        return false;
873
 
                    }
874
 
                    // <-, line 84
875
 
                    slice_from("t");
876
 
                    break;
877
 
                case 7:
878
 
                    // (, line 85
879
 
                    // call R1, line 85
880
 
                    if (!r_R1())
881
 
                    {
882
 
                        return false;
883
 
                    }
884
 
                    // <-, line 85
885
 
                    slice_from("s");
886
 
                    break;
887
 
                case 8:
888
 
                    // (, line 86
889
 
                    // call R1, line 86
890
 
                    if (!r_R1())
891
 
                    {
892
 
                        return false;
893
 
                    }
894
 
                    // <-, line 86
895
 
                    slice_from("r");
896
 
                    break;
897
 
                case 9:
898
 
                    // (, line 87
899
 
                    // call R1, line 87
900
 
                    if (!r_R1())
901
 
                    {
902
 
                        return false;
903
 
                    }
904
 
                    // delete, line 87
905
 
                    slice_del();
906
 
                    // attach, line 87
907
 
                    insert(cursor, cursor, "l");
908
 
                    // call lengthen_V, line 87
909
 
                    if (!r_lengthen_V())
910
 
                    {
911
 
                        return false;
912
 
                    }
913
 
                    break;
914
 
                case 10:
915
 
                    // (, line 88
916
 
                    // call R1, line 88
917
 
                    if (!r_R1())
918
 
                    {
919
 
                        return false;
920
 
                    }
921
 
                    // call C, line 88
922
 
                    if (!r_C())
923
 
                    {
924
 
                        return false;
925
 
                    }
926
 
                    // delete, line 88
927
 
                    slice_del();
928
 
                    // attach, line 88
929
 
                    insert(cursor, cursor, "en");
930
 
                    // call lengthen_V, line 88
931
 
                    if (!r_lengthen_V())
932
 
                    {
933
 
                        return false;
934
 
                    }
935
 
                    break;
936
 
                case 11:
937
 
                    // (, line 89
938
 
                    // call R1, line 89
939
 
                    if (!r_R1())
940
 
                    {
941
 
                        return false;
942
 
                    }
943
 
                    // call C, line 89
944
 
                    if (!r_C())
945
 
                    {
946
 
                        return false;
947
 
                    }
948
 
                    // <-, line 89
949
 
                    slice_from("ief");
950
 
                    break;
951
 
            }
952
 
            return true;
953
 
        }
954
 
 
955
 
        private boolean r_Step_3() {
956
 
            int among_var;
957
 
            // (, line 94
958
 
            // [, line 95
959
 
            ket = cursor;
960
 
            // among, line 95
961
 
            among_var = find_among_b(a_2, 14);
962
 
            if (among_var == 0)
963
 
            {
964
 
                return false;
965
 
            }
966
 
            // (, line 95
967
 
            // ], line 95
968
 
            bra = cursor;
969
 
            switch(among_var) {
970
 
                case 0:
971
 
                    return false;
972
 
                case 1:
973
 
                    // (, line 96
974
 
                    // call R1, line 96
975
 
                    if (!r_R1())
976
 
                    {
977
 
                        return false;
978
 
                    }
979
 
                    // <-, line 96
980
 
                    slice_from("eer");
981
 
                    break;
982
 
                case 2:
983
 
                    // (, line 97
984
 
                    // call R1, line 97
985
 
                    if (!r_R1())
986
 
                    {
987
 
                        return false;
988
 
                    }
989
 
                    // delete, line 97
990
 
                    slice_del();
991
 
                    // call lengthen_V, line 97
992
 
                    if (!r_lengthen_V())
993
 
                    {
994
 
                        return false;
995
 
                    }
996
 
                    break;
997
 
                case 3:
998
 
                    // (, line 100
999
 
                    // call R1, line 100
1000
 
                    if (!r_R1())
1001
 
                    {
1002
 
                        return false;
1003
 
                    }
1004
 
                    // delete, line 100
1005
 
                    slice_del();
1006
 
                    break;
1007
 
                case 4:
1008
 
                    // (, line 101
1009
 
                    // <-, line 101
1010
 
                    slice_from("r");
1011
 
                    break;
1012
 
                case 5:
1013
 
                    // (, line 104
1014
 
                    // call R1, line 104
1015
 
                    if (!r_R1())
1016
 
                    {
1017
 
                        return false;
1018
 
                    }
1019
 
                    // delete, line 104
1020
 
                    slice_del();
1021
 
                    // call lengthen_V, line 104
1022
 
                    if (!r_lengthen_V())
1023
 
                    {
1024
 
                        return false;
1025
 
                    }
1026
 
                    break;
1027
 
                case 6:
1028
 
                    // (, line 105
1029
 
                    // call R1, line 105
1030
 
                    if (!r_R1())
1031
 
                    {
1032
 
                        return false;
1033
 
                    }
1034
 
                    // call C, line 105
1035
 
                    if (!r_C())
1036
 
                    {
1037
 
                        return false;
1038
 
                    }
1039
 
                    // <-, line 105
1040
 
                    slice_from("aar");
1041
 
                    break;
1042
 
                case 7:
1043
 
                    // (, line 106
1044
 
                    // call R2, line 106
1045
 
                    if (!r_R2())
1046
 
                    {
1047
 
                        return false;
1048
 
                    }
1049
 
                    // delete, line 106
1050
 
                    slice_del();
1051
 
                    // attach, line 106
1052
 
                    insert(cursor, cursor, "f");
1053
 
                    // call lengthen_V, line 106
1054
 
                    if (!r_lengthen_V())
1055
 
                    {
1056
 
                        return false;
1057
 
                    }
1058
 
                    break;
1059
 
                case 8:
1060
 
                    // (, line 107
1061
 
                    // call R2, line 107
1062
 
                    if (!r_R2())
1063
 
                    {
1064
 
                        return false;
1065
 
                    }
1066
 
                    // delete, line 107
1067
 
                    slice_del();
1068
 
                    // attach, line 107
1069
 
                    insert(cursor, cursor, "g");
1070
 
                    // call lengthen_V, line 107
1071
 
                    if (!r_lengthen_V())
1072
 
                    {
1073
 
                        return false;
1074
 
                    }
1075
 
                    break;
1076
 
                case 9:
1077
 
                    // (, line 108
1078
 
                    // call R1, line 108
1079
 
                    if (!r_R1())
1080
 
                    {
1081
 
                        return false;
1082
 
                    }
1083
 
                    // call C, line 108
1084
 
                    if (!r_C())
1085
 
                    {
1086
 
                        return false;
1087
 
                    }
1088
 
                    // <-, line 108
1089
 
                    slice_from("t");
1090
 
                    break;
1091
 
                case 10:
1092
 
                    // (, line 109
1093
 
                    // call R1, line 109
1094
 
                    if (!r_R1())
1095
 
                    {
1096
 
                        return false;
1097
 
                    }
1098
 
                    // call C, line 109
1099
 
                    if (!r_C())
1100
 
                    {
1101
 
                        return false;
1102
 
                    }
1103
 
                    // <-, line 109
1104
 
                    slice_from("d");
1105
 
                    break;
1106
 
            }
1107
 
            return true;
1108
 
        }
1109
 
 
1110
 
        private boolean r_Step_4() {
1111
 
            int among_var;
1112
 
            int v_1;
1113
 
            // (, line 114
1114
 
            // or, line 134
1115
 
            lab0: do {
1116
 
                v_1 = limit - cursor;
1117
 
                lab1: do {
1118
 
                    // (, line 115
1119
 
                    // [, line 115
1120
 
                    ket = cursor;
1121
 
                    // among, line 115
1122
 
                    among_var = find_among_b(a_3, 16);
1123
 
                    if (among_var == 0)
1124
 
                    {
1125
 
                        break lab1;
1126
 
                    }
1127
 
                    // (, line 115
1128
 
                    // ], line 115
1129
 
                    bra = cursor;
1130
 
                    switch(among_var) {
1131
 
                        case 0:
1132
 
                            break lab1;
1133
 
                        case 1:
1134
 
                            // (, line 116
1135
 
                            // call R1, line 116
1136
 
                            if (!r_R1())
1137
 
                            {
1138
 
                                break lab1;
1139
 
                            }
1140
 
                            // <-, line 116
1141
 
                            slice_from("ie");
1142
 
                            break;
1143
 
                        case 2:
1144
 
                            // (, line 117
1145
 
                            // call R1, line 117
1146
 
                            if (!r_R1())
1147
 
                            {
1148
 
                                break lab1;
1149
 
                            }
1150
 
                            // <-, line 117
1151
 
                            slice_from("eer");
1152
 
                            break;
1153
 
                        case 3:
1154
 
                            // (, line 118
1155
 
                            // call R1, line 118
1156
 
                            if (!r_R1())
1157
 
                            {
1158
 
                                break lab1;
1159
 
                            }
1160
 
                            // delete, line 118
1161
 
                            slice_del();
1162
 
                            break;
1163
 
                        case 4:
1164
 
                            // (, line 119
1165
 
                            // call R1, line 119
1166
 
                            if (!r_R1())
1167
 
                            {
1168
 
                                break lab1;
1169
 
                            }
1170
 
                            // call V, line 119
1171
 
                            if (!r_V())
1172
 
                            {
1173
 
                                break lab1;
1174
 
                            }
1175
 
                            // <-, line 119
1176
 
                            slice_from("n");
1177
 
                            break;
1178
 
                        case 5:
1179
 
                            // (, line 120
1180
 
                            // call R1, line 120
1181
 
                            if (!r_R1())
1182
 
                            {
1183
 
                                break lab1;
1184
 
                            }
1185
 
                            // call V, line 120
1186
 
                            if (!r_V())
1187
 
                            {
1188
 
                                break lab1;
1189
 
                            }
1190
 
                            // <-, line 120
1191
 
                            slice_from("l");
1192
 
                            break;
1193
 
                        case 6:
1194
 
                            // (, line 121
1195
 
                            // call R1, line 121
1196
 
                            if (!r_R1())
1197
 
                            {
1198
 
                                break lab1;
1199
 
                            }
1200
 
                            // call V, line 121
1201
 
                            if (!r_V())
1202
 
                            {
1203
 
                                break lab1;
1204
 
                            }
1205
 
                            // <-, line 121
1206
 
                            slice_from("r");
1207
 
                            break;
1208
 
                        case 7:
1209
 
                            // (, line 122
1210
 
                            // call R1, line 122
1211
 
                            if (!r_R1())
1212
 
                            {
1213
 
                                break lab1;
1214
 
                            }
1215
 
                            // <-, line 122
1216
 
                            slice_from("teer");
1217
 
                            break;
1218
 
                        case 8:
1219
 
                            // (, line 124
1220
 
                            // call R1, line 124
1221
 
                            if (!r_R1())
1222
 
                            {
1223
 
                                break lab1;
1224
 
                            }
1225
 
                            // <-, line 124
1226
 
                            slice_from("lijk");
1227
 
                            break;
1228
 
                        case 9:
1229
 
                            // (, line 127
1230
 
                            // call R1, line 127
1231
 
                            if (!r_R1())
1232
 
                            {
1233
 
                                break lab1;
1234
 
                            }
1235
 
                            // delete, line 127
1236
 
                            slice_del();
1237
 
                            break;
1238
 
                        case 10:
1239
 
                            // (, line 131
1240
 
                            // call R1, line 131
1241
 
                            if (!r_R1())
1242
 
                            {
1243
 
                                break lab1;
1244
 
                            }
1245
 
                            // call C, line 131
1246
 
                            if (!r_C())
1247
 
                            {
1248
 
                                break lab1;
1249
 
                            }
1250
 
                            // delete, line 131
1251
 
                            slice_del();
1252
 
                            // call lengthen_V, line 131
1253
 
                            if (!r_lengthen_V())
1254
 
                            {
1255
 
                                break lab1;
1256
 
                            }
1257
 
                            break;
1258
 
                    }
1259
 
                    break lab0;
1260
 
                } while (false);
1261
 
                cursor = limit - v_1;
1262
 
                // (, line 135
1263
 
                // [, line 135
1264
 
                ket = cursor;
1265
 
                // among, line 135
1266
 
                among_var = find_among_b(a_4, 3);
1267
 
                if (among_var == 0)
1268
 
                {
1269
 
                    return false;
1270
 
                }
1271
 
                // (, line 135
1272
 
                // ], line 135
1273
 
                bra = cursor;
1274
 
                switch(among_var) {
1275
 
                    case 0:
1276
 
                        return false;
1277
 
                    case 1:
1278
 
                        // (, line 138
1279
 
                        // call R1, line 138
1280
 
                        if (!r_R1())
1281
 
                        {
1282
 
                            return false;
1283
 
                        }
1284
 
                        // call C, line 138
1285
 
                        if (!r_C())
1286
 
                        {
1287
 
                            return false;
1288
 
                        }
1289
 
                        // delete, line 138
1290
 
                        slice_del();
1291
 
                        // call lengthen_V, line 138
1292
 
                        if (!r_lengthen_V())
1293
 
                        {
1294
 
                            return false;
1295
 
                        }
1296
 
                        break;
1297
 
                }
1298
 
            } while (false);
1299
 
            return true;
1300
 
        }
1301
 
 
1302
 
        private boolean r_Step_7() {
1303
 
            int among_var;
1304
 
            // (, line 144
1305
 
            // [, line 145
1306
 
            ket = cursor;
1307
 
            // among, line 145
1308
 
            among_var = find_among_b(a_5, 3);
1309
 
            if (among_var == 0)
1310
 
            {
1311
 
                return false;
1312
 
            }
1313
 
            // (, line 145
1314
 
            // ], line 145
1315
 
            bra = cursor;
1316
 
            switch(among_var) {
1317
 
                case 0:
1318
 
                    return false;
1319
 
                case 1:
1320
 
                    // (, line 146
1321
 
                    // <-, line 146
1322
 
                    slice_from("k");
1323
 
                    break;
1324
 
                case 2:
1325
 
                    // (, line 147
1326
 
                    // <-, line 147
1327
 
                    slice_from("f");
1328
 
                    break;
1329
 
                case 3:
1330
 
                    // (, line 148
1331
 
                    // <-, line 148
1332
 
                    slice_from("p");
1333
 
                    break;
1334
 
            }
1335
 
            return true;
1336
 
        }
1337
 
 
1338
 
        private boolean r_Step_6() {
1339
 
            int among_var;
1340
 
            // (, line 153
1341
 
            // [, line 154
1342
 
            ket = cursor;
1343
 
            // among, line 154
1344
 
            among_var = find_among_b(a_6, 22);
1345
 
            if (among_var == 0)
1346
 
            {
1347
 
                return false;
1348
 
            }
1349
 
            // (, line 154
1350
 
            // ], line 154
1351
 
            bra = cursor;
1352
 
            switch(among_var) {
1353
 
                case 0:
1354
 
                    return false;
1355
 
                case 1:
1356
 
                    // (, line 155
1357
 
                    // <-, line 155
1358
 
                    slice_from("b");
1359
 
                    break;
1360
 
                case 2:
1361
 
                    // (, line 156
1362
 
                    // <-, line 156
1363
 
                    slice_from("c");
1364
 
                    break;
1365
 
                case 3:
1366
 
                    // (, line 157
1367
 
                    // <-, line 157
1368
 
                    slice_from("d");
1369
 
                    break;
1370
 
                case 4:
1371
 
                    // (, line 158
1372
 
                    // <-, line 158
1373
 
                    slice_from("f");
1374
 
                    break;
1375
 
                case 5:
1376
 
                    // (, line 159
1377
 
                    // <-, line 159
1378
 
                    slice_from("g");
1379
 
                    break;
1380
 
                case 6:
1381
 
                    // (, line 160
1382
 
                    // <-, line 160
1383
 
                    slice_from("h");
1384
 
                    break;
1385
 
                case 7:
1386
 
                    // (, line 161
1387
 
                    // <-, line 161
1388
 
                    slice_from("j");
1389
 
                    break;
1390
 
                case 8:
1391
 
                    // (, line 162
1392
 
                    // <-, line 162
1393
 
                    slice_from("k");
1394
 
                    break;
1395
 
                case 9:
1396
 
                    // (, line 163
1397
 
                    // <-, line 163
1398
 
                    slice_from("l");
1399
 
                    break;
1400
 
                case 10:
1401
 
                    // (, line 164
1402
 
                    // <-, line 164
1403
 
                    slice_from("m");
1404
 
                    break;
1405
 
                case 11:
1406
 
                    // (, line 165
1407
 
                    // <-, line 165
1408
 
                    slice_from("n");
1409
 
                    break;
1410
 
                case 12:
1411
 
                    // (, line 166
1412
 
                    // <-, line 166
1413
 
                    slice_from("p");
1414
 
                    break;
1415
 
                case 13:
1416
 
                    // (, line 167
1417
 
                    // <-, line 167
1418
 
                    slice_from("q");
1419
 
                    break;
1420
 
                case 14:
1421
 
                    // (, line 168
1422
 
                    // <-, line 168
1423
 
                    slice_from("r");
1424
 
                    break;
1425
 
                case 15:
1426
 
                    // (, line 169
1427
 
                    // <-, line 169
1428
 
                    slice_from("s");
1429
 
                    break;
1430
 
                case 16:
1431
 
                    // (, line 170
1432
 
                    // <-, line 170
1433
 
                    slice_from("t");
1434
 
                    break;
1435
 
                case 17:
1436
 
                    // (, line 171
1437
 
                    // <-, line 171
1438
 
                    slice_from("v");
1439
 
                    break;
1440
 
                case 18:
1441
 
                    // (, line 172
1442
 
                    // <-, line 172
1443
 
                    slice_from("w");
1444
 
                    break;
1445
 
                case 19:
1446
 
                    // (, line 173
1447
 
                    // <-, line 173
1448
 
                    slice_from("x");
1449
 
                    break;
1450
 
                case 20:
1451
 
                    // (, line 174
1452
 
                    // <-, line 174
1453
 
                    slice_from("z");
1454
 
                    break;
1455
 
                case 21:
1456
 
                    // (, line 175
1457
 
                    // <-, line 175
1458
 
                    slice_from("f");
1459
 
                    break;
1460
 
                case 22:
1461
 
                    // (, line 176
1462
 
                    // <-, line 176
1463
 
                    slice_from("s");
1464
 
                    break;
1465
 
            }
1466
 
            return true;
1467
 
        }
1468
 
 
1469
 
        private boolean r_Step_1c() {
1470
 
            int among_var;
1471
 
            int v_1;
1472
 
            int v_2;
1473
 
            // (, line 181
1474
 
            // [, line 182
1475
 
            ket = cursor;
1476
 
            // among, line 182
1477
 
            among_var = find_among_b(a_7, 2);
1478
 
            if (among_var == 0)
1479
 
            {
1480
 
                return false;
1481
 
            }
1482
 
            // (, line 182
1483
 
            // ], line 182
1484
 
            bra = cursor;
1485
 
            // call R1, line 182
1486
 
            if (!r_R1())
1487
 
            {
1488
 
                return false;
1489
 
            }
1490
 
            // call C, line 182
1491
 
            if (!r_C())
1492
 
            {
1493
 
                return false;
1494
 
            }
1495
 
            switch(among_var) {
1496
 
                case 0:
1497
 
                    return false;
1498
 
                case 1:
1499
 
                    // (, line 183
1500
 
                    // not, line 183
1501
 
                    {
1502
 
                        v_1 = limit - cursor;
1503
 
                        lab0: do {
1504
 
                            // (, line 183
1505
 
                            // literal, line 183
1506
 
                            if (!(eq_s_b(1, "n")))
1507
 
                            {
1508
 
                                break lab0;
1509
 
                            }
1510
 
                            // call R1, line 183
1511
 
                            if (!r_R1())
1512
 
                            {
1513
 
                                break lab0;
1514
 
                            }
1515
 
                            return false;
1516
 
                        } while (false);
1517
 
                        cursor = limit - v_1;
1518
 
                    }
1519
 
                    // delete, line 183
1520
 
                    slice_del();
1521
 
                    break;
1522
 
                case 2:
1523
 
                    // (, line 184
1524
 
                    // not, line 184
1525
 
                    {
1526
 
                        v_2 = limit - cursor;
1527
 
                        lab1: do {
1528
 
                            // (, line 184
1529
 
                            // literal, line 184
1530
 
                            if (!(eq_s_b(1, "h")))
1531
 
                            {
1532
 
                                break lab1;
1533
 
                            }
1534
 
                            // call R1, line 184
1535
 
                            if (!r_R1())
1536
 
                            {
1537
 
                                break lab1;
1538
 
                            }
1539
 
                            return false;
1540
 
                        } while (false);
1541
 
                        cursor = limit - v_2;
1542
 
                    }
1543
 
                    // delete, line 184
1544
 
                    slice_del();
1545
 
                    break;
1546
 
            }
1547
 
            return true;
1548
 
        }
1549
 
 
1550
 
        private boolean r_Lose_prefix() {
1551
 
            int v_1;
1552
 
            int v_2;
1553
 
            int v_3;
1554
 
            // (, line 189
1555
 
            // [, line 190
1556
 
            bra = cursor;
1557
 
            // literal, line 190
1558
 
            if (!(eq_s(2, "ge")))
1559
 
            {
1560
 
                return false;
1561
 
            }
1562
 
            // ], line 190
1563
 
            ket = cursor;
1564
 
            // test, line 190
1565
 
            v_1 = cursor;
1566
 
            // hop, line 190
1567
 
            {
1568
 
                int c = cursor + 3;
1569
 
                if (0 > c || c > limit)
1570
 
                {
1571
 
                    return false;
1572
 
                }
1573
 
                cursor = c;
1574
 
            }
1575
 
            cursor = v_1;
1576
 
            // (, line 190
1577
 
            // goto, line 190
1578
 
            golab0: while(true)
1579
 
            {
1580
 
                v_2 = cursor;
1581
 
                lab1: do {
1582
 
                    if (!(in_grouping(g_v, 97, 121)))
1583
 
                    {
1584
 
                        break lab1;
1585
 
                    }
1586
 
                    cursor = v_2;
1587
 
                    break golab0;
1588
 
                } while (false);
1589
 
                cursor = v_2;
1590
 
                if (cursor >= limit)
1591
 
                {
1592
 
                    return false;
1593
 
                }
1594
 
                cursor++;
1595
 
            }
1596
 
            // goto, line 190
1597
 
            golab2: while(true)
1598
 
            {
1599
 
                v_3 = cursor;
1600
 
                lab3: do {
1601
 
                    if (!(out_grouping(g_v, 97, 121)))
1602
 
                    {
1603
 
                        break lab3;
1604
 
                    }
1605
 
                    cursor = v_3;
1606
 
                    break golab2;
1607
 
                } while (false);
1608
 
                cursor = v_3;
1609
 
                if (cursor >= limit)
1610
 
                {
1611
 
                    return false;
1612
 
                }
1613
 
                cursor++;
1614
 
            }
1615
 
            // set GE_removed, line 191
1616
 
            B_GE_removed = true;
1617
 
            // delete, line 192
1618
 
            slice_del();
1619
 
            return true;
1620
 
        }
1621
 
 
1622
 
        private boolean r_Lose_infix() {
1623
 
            int v_2;
1624
 
            int v_3;
1625
 
            int v_4;
1626
 
            // (, line 195
1627
 
            // next, line 196
1628
 
            if (cursor >= limit)
1629
 
            {
1630
 
                return false;
1631
 
            }
1632
 
            cursor++;
1633
 
            // gopast, line 197
1634
 
            golab0: while(true)
1635
 
            {
1636
 
                lab1: do {
1637
 
                    // (, line 197
1638
 
                    // [, line 197
1639
 
                    bra = cursor;
1640
 
                    // literal, line 197
1641
 
                    if (!(eq_s(2, "ge")))
1642
 
                    {
1643
 
                        break lab1;
1644
 
                    }
1645
 
                    // ], line 197
1646
 
                    ket = cursor;
1647
 
                    break golab0;
1648
 
                } while (false);
1649
 
                if (cursor >= limit)
1650
 
                {
1651
 
                    return false;
1652
 
                }
1653
 
                cursor++;
1654
 
            }
1655
 
            // test, line 197
1656
 
            v_2 = cursor;
1657
 
            // hop, line 197
1658
 
            {
1659
 
                int c = cursor + 3;
1660
 
                if (0 > c || c > limit)
1661
 
                {
1662
 
                    return false;
1663
 
                }
1664
 
                cursor = c;
1665
 
            }
1666
 
            cursor = v_2;
1667
 
            // (, line 197
1668
 
            // goto, line 197
1669
 
            golab2: while(true)
1670
 
            {
1671
 
                v_3 = cursor;
1672
 
                lab3: do {
1673
 
                    if (!(in_grouping(g_v, 97, 121)))
1674
 
                    {
1675
 
                        break lab3;
1676
 
                    }
1677
 
                    cursor = v_3;
1678
 
                    break golab2;
1679
 
                } while (false);
1680
 
                cursor = v_3;
1681
 
                if (cursor >= limit)
1682
 
                {
1683
 
                    return false;
1684
 
                }
1685
 
                cursor++;
1686
 
            }
1687
 
            // goto, line 197
1688
 
            golab4: while(true)
1689
 
            {
1690
 
                v_4 = cursor;
1691
 
                lab5: do {
1692
 
                    if (!(out_grouping(g_v, 97, 121)))
1693
 
                    {
1694
 
                        break lab5;
1695
 
                    }
1696
 
                    cursor = v_4;
1697
 
                    break golab4;
1698
 
                } while (false);
1699
 
                cursor = v_4;
1700
 
                if (cursor >= limit)
1701
 
                {
1702
 
                    return false;
1703
 
                }
1704
 
                cursor++;
1705
 
            }
1706
 
            // set GE_removed, line 198
1707
 
            B_GE_removed = true;
1708
 
            // delete, line 199
1709
 
            slice_del();
1710
 
            return true;
1711
 
        }
1712
 
 
1713
 
        private boolean r_measure() {
1714
 
            int v_1;
1715
 
            int v_2;
1716
 
            int v_5;
1717
 
            int v_6;
1718
 
            int v_9;
1719
 
            int v_10;
1720
 
            // (, line 202
1721
 
            // do, line 203
1722
 
            v_1 = cursor;
1723
 
            lab0: do {
1724
 
                // (, line 203
1725
 
                // tolimit, line 204
1726
 
                cursor = limit;
1727
 
                // setmark p1, line 205
1728
 
                I_p1 = cursor;
1729
 
                // setmark p2, line 206
1730
 
                I_p2 = cursor;
1731
 
            } while (false);
1732
 
            cursor = v_1;
1733
 
            // do, line 208
1734
 
            v_2 = cursor;
1735
 
            lab1: do {
1736
 
                // (, line 208
1737
 
                // repeat, line 209
1738
 
                replab2: while(true)
1739
 
                {
1740
 
                    lab3: do {
1741
 
                        if (!(out_grouping(g_v, 97, 121)))
1742
 
                        {
1743
 
                            break lab3;
1744
 
                        }
1745
 
                        continue replab2;
1746
 
                    } while (false);
1747
 
                    break replab2;
1748
 
                }
1749
 
                // atleast, line 209
1750
 
                {
1751
 
                    int v_4 = 1;
1752
 
                    // atleast, line 209
1753
 
                    replab4: while(true)
1754
 
                    {
1755
 
                        v_5 = cursor;
1756
 
                        lab5: do {
1757
 
                            // (, line 209
1758
 
                            // or, line 209
1759
 
                            lab6: do {
1760
 
                                v_6 = cursor;
1761
 
                                lab7: do {
1762
 
                                    // literal, line 209
1763
 
                                    if (!(eq_s(2, "ij")))
1764
 
                                    {
1765
 
                                        break lab7;
1766
 
                                    }
1767
 
                                    break lab6;
1768
 
                                } while (false);
1769
 
                                cursor = v_6;
1770
 
                                if (!(in_grouping(g_v, 97, 121)))
1771
 
                                {
1772
 
                                    break lab5;
1773
 
                                }
1774
 
                            } while (false);
1775
 
                            v_4--;
1776
 
                            continue replab4;
1777
 
                        } while (false);
1778
 
                        cursor = v_5;
1779
 
                        break replab4;
1780
 
                    }
1781
 
                    if (v_4 > 0)
1782
 
                    {
1783
 
                        break lab1;
1784
 
                    }
1785
 
                }
1786
 
                if (!(out_grouping(g_v, 97, 121)))
1787
 
                {
1788
 
                    break lab1;
1789
 
                }
1790
 
                // setmark p1, line 209
1791
 
                I_p1 = cursor;
1792
 
                // repeat, line 210
1793
 
                replab8: while(true)
1794
 
                {
1795
 
                    lab9: do {
1796
 
                        if (!(out_grouping(g_v, 97, 121)))
1797
 
                        {
1798
 
                            break lab9;
1799
 
                        }
1800
 
                        continue replab8;
1801
 
                    } while (false);
1802
 
                    break replab8;
1803
 
                }
1804
 
                // atleast, line 210
1805
 
                {
1806
 
                    int v_8 = 1;
1807
 
                    // atleast, line 210
1808
 
                    replab10: while(true)
1809
 
                    {
1810
 
                        v_9 = cursor;
1811
 
                        lab11: do {
1812
 
                            // (, line 210
1813
 
                            // or, line 210
1814
 
                            lab12: do {
1815
 
                                v_10 = cursor;
1816
 
                                lab13: do {
1817
 
                                    // literal, line 210
1818
 
                                    if (!(eq_s(2, "ij")))
1819
 
                                    {
1820
 
                                        break lab13;
1821
 
                                    }
1822
 
                                    break lab12;
1823
 
                                } while (false);
1824
 
                                cursor = v_10;
1825
 
                                if (!(in_grouping(g_v, 97, 121)))
1826
 
                                {
1827
 
                                    break lab11;
1828
 
                                }
1829
 
                            } while (false);
1830
 
                            v_8--;
1831
 
                            continue replab10;
1832
 
                        } while (false);
1833
 
                        cursor = v_9;
1834
 
                        break replab10;
1835
 
                    }
1836
 
                    if (v_8 > 0)
1837
 
                    {
1838
 
                        break lab1;
1839
 
                    }
1840
 
                }
1841
 
                if (!(out_grouping(g_v, 97, 121)))
1842
 
                {
1843
 
                    break lab1;
1844
 
                }
1845
 
                // setmark p2, line 210
1846
 
                I_p2 = cursor;
1847
 
            } while (false);
1848
 
            cursor = v_2;
1849
 
            return true;
1850
 
        }
1851
 
 
1852
 
        public boolean stem() {
1853
 
            int v_1;
1854
 
            int v_2;
1855
 
            int v_3;
1856
 
            int v_4;
1857
 
            int v_5;
1858
 
            int v_6;
1859
 
            int v_7;
1860
 
            int v_8;
1861
 
            int v_9;
1862
 
            int v_10;
1863
 
            int v_11;
1864
 
            int v_12;
1865
 
            int v_13;
1866
 
            int v_14;
1867
 
            int v_15;
1868
 
            int v_16;
1869
 
            int v_18;
1870
 
            int v_19;
1871
 
            int v_20;
1872
 
            // (, line 214
1873
 
            // unset Y_found, line 216
1874
 
            B_Y_found = false;
1875
 
            // unset stemmed, line 217
1876
 
            B_stemmed = false;
1877
 
            // do, line 218
1878
 
            v_1 = cursor;
1879
 
            lab0: do {
1880
 
                // (, line 218
1881
 
                // [, line 218
1882
 
                bra = cursor;
1883
 
                // literal, line 218
1884
 
                if (!(eq_s(1, "y")))
1885
 
                {
1886
 
                    break lab0;
1887
 
                }
1888
 
                // ], line 218
1889
 
                ket = cursor;
1890
 
                // <-, line 218
1891
 
                slice_from("Y");
1892
 
                // set Y_found, line 218
1893
 
                B_Y_found = true;
1894
 
            } while (false);
1895
 
            cursor = v_1;
1896
 
            // do, line 219
1897
 
            v_2 = cursor;
1898
 
            lab1: do {
1899
 
                // repeat, line 219
1900
 
                replab2: while(true)
1901
 
                {
1902
 
                    v_3 = cursor;
1903
 
                    lab3: do {
1904
 
                        // (, line 219
1905
 
                        // goto, line 219
1906
 
                        golab4: while(true)
1907
 
                        {
1908
 
                            v_4 = cursor;
1909
 
                            lab5: do {
1910
 
                                // (, line 219
1911
 
                                if (!(in_grouping(g_v, 97, 121)))
1912
 
                                {
1913
 
                                    break lab5;
1914
 
                                }
1915
 
                                // [, line 219
1916
 
                                bra = cursor;
1917
 
                                // literal, line 219
1918
 
                                if (!(eq_s(1, "y")))
1919
 
                                {
1920
 
                                    break lab5;
1921
 
                                }
1922
 
                                // ], line 219
1923
 
                                ket = cursor;
1924
 
                                cursor = v_4;
1925
 
                                break golab4;
1926
 
                            } while (false);
1927
 
                            cursor = v_4;
1928
 
                            if (cursor >= limit)
1929
 
                            {
1930
 
                                break lab3;
1931
 
                            }
1932
 
                            cursor++;
1933
 
                        }
1934
 
                        // <-, line 219
1935
 
                        slice_from("Y");
1936
 
                        // set Y_found, line 219
1937
 
                        B_Y_found = true;
1938
 
                        continue replab2;
1939
 
                    } while (false);
1940
 
                    cursor = v_3;
1941
 
                    break replab2;
1942
 
                }
1943
 
            } while (false);
1944
 
            cursor = v_2;
1945
 
            // call measure, line 221
1946
 
            if (!r_measure())
1947
 
            {
1948
 
                return false;
1949
 
            }
1950
 
            // backwards, line 223
1951
 
            limit_backward = cursor; cursor = limit;
1952
 
            // (, line 223
1953
 
            // do, line 224
1954
 
            v_5 = limit - cursor;
1955
 
            lab6: do {
1956
 
                // (, line 224
1957
 
                // call Step_1, line 224
1958
 
                if (!r_Step_1())
1959
 
                {
1960
 
                    break lab6;
1961
 
                }
1962
 
                // set stemmed, line 224
1963
 
                B_stemmed = true;
1964
 
            } while (false);
1965
 
            cursor = limit - v_5;
1966
 
            // do, line 225
1967
 
            v_6 = limit - cursor;
1968
 
            lab7: do {
1969
 
                // (, line 225
1970
 
                // call Step_2, line 225
1971
 
                if (!r_Step_2())
1972
 
                {
1973
 
                    break lab7;
1974
 
                }
1975
 
                // set stemmed, line 225
1976
 
                B_stemmed = true;
1977
 
            } while (false);
1978
 
            cursor = limit - v_6;
1979
 
            // do, line 226
1980
 
            v_7 = limit - cursor;
1981
 
            lab8: do {
1982
 
                // (, line 226
1983
 
                // call Step_3, line 226
1984
 
                if (!r_Step_3())
1985
 
                {
1986
 
                    break lab8;
1987
 
                }
1988
 
                // set stemmed, line 226
1989
 
                B_stemmed = true;
1990
 
            } while (false);
1991
 
            cursor = limit - v_7;
1992
 
            // do, line 227
1993
 
            v_8 = limit - cursor;
1994
 
            lab9: do {
1995
 
                // (, line 227
1996
 
                // call Step_4, line 227
1997
 
                if (!r_Step_4())
1998
 
                {
1999
 
                    break lab9;
2000
 
                }
2001
 
                // set stemmed, line 227
2002
 
                B_stemmed = true;
2003
 
            } while (false);
2004
 
            cursor = limit - v_8;
2005
 
            cursor = limit_backward;            // unset GE_removed, line 229
2006
 
            B_GE_removed = false;
2007
 
            // do, line 230
2008
 
            v_9 = cursor;
2009
 
            lab10: do {
2010
 
                // (, line 230
2011
 
                // and, line 230
2012
 
                v_10 = cursor;
2013
 
                // call Lose_prefix, line 230
2014
 
                if (!r_Lose_prefix())
2015
 
                {
2016
 
                    break lab10;
2017
 
                }
2018
 
                cursor = v_10;
2019
 
                // call measure, line 230
2020
 
                if (!r_measure())
2021
 
                {
2022
 
                    break lab10;
2023
 
                }
2024
 
            } while (false);
2025
 
            cursor = v_9;
2026
 
            // backwards, line 231
2027
 
            limit_backward = cursor; cursor = limit;
2028
 
            // (, line 231
2029
 
            // do, line 232
2030
 
            v_11 = limit - cursor;
2031
 
            lab11: do {
2032
 
                // (, line 232
2033
 
                // Boolean test GE_removed, line 232
2034
 
                if (!(B_GE_removed))
2035
 
                {
2036
 
                    break lab11;
2037
 
                }
2038
 
                // call Step_1c, line 232
2039
 
                if (!r_Step_1c())
2040
 
                {
2041
 
                    break lab11;
2042
 
                }
2043
 
            } while (false);
2044
 
            cursor = limit - v_11;
2045
 
            cursor = limit_backward;            // unset GE_removed, line 234
2046
 
            B_GE_removed = false;
2047
 
            // do, line 235
2048
 
            v_12 = cursor;
2049
 
            lab12: do {
2050
 
                // (, line 235
2051
 
                // and, line 235
2052
 
                v_13 = cursor;
2053
 
                // call Lose_infix, line 235
2054
 
                if (!r_Lose_infix())
2055
 
                {
2056
 
                    break lab12;
2057
 
                }
2058
 
                cursor = v_13;
2059
 
                // call measure, line 235
2060
 
                if (!r_measure())
2061
 
                {
2062
 
                    break lab12;
2063
 
                }
2064
 
            } while (false);
2065
 
            cursor = v_12;
2066
 
            // backwards, line 236
2067
 
            limit_backward = cursor; cursor = limit;
2068
 
            // (, line 236
2069
 
            // do, line 237
2070
 
            v_14 = limit - cursor;
2071
 
            lab13: do {
2072
 
                // (, line 237
2073
 
                // Boolean test GE_removed, line 237
2074
 
                if (!(B_GE_removed))
2075
 
                {
2076
 
                    break lab13;
2077
 
                }
2078
 
                // call Step_1c, line 237
2079
 
                if (!r_Step_1c())
2080
 
                {
2081
 
                    break lab13;
2082
 
                }
2083
 
            } while (false);
2084
 
            cursor = limit - v_14;
2085
 
            cursor = limit_backward;            // backwards, line 239
2086
 
            limit_backward = cursor; cursor = limit;
2087
 
            // (, line 239
2088
 
            // do, line 240
2089
 
            v_15 = limit - cursor;
2090
 
            lab14: do {
2091
 
                // (, line 240
2092
 
                // call Step_7, line 240
2093
 
                if (!r_Step_7())
2094
 
                {
2095
 
                    break lab14;
2096
 
                }
2097
 
                // set stemmed, line 240
2098
 
                B_stemmed = true;
2099
 
            } while (false);
2100
 
            cursor = limit - v_15;
2101
 
            // do, line 241
2102
 
            v_16 = limit - cursor;
2103
 
            lab15: do {
2104
 
                // (, line 241
2105
 
                // or, line 241
2106
 
                lab16: do {
2107
 
                    lab17: do {
2108
 
                        // Boolean test stemmed, line 241
2109
 
                        if (!(B_stemmed))
2110
 
                        {
2111
 
                            break lab17;
2112
 
                        }
2113
 
                        break lab16;
2114
 
                    } while (false);
2115
 
                    // Boolean test GE_removed, line 241
2116
 
                    if (!(B_GE_removed))
2117
 
                    {
2118
 
                        break lab15;
2119
 
                    }
2120
 
                } while (false);
2121
 
                // call Step_6, line 241
2122
 
                if (!r_Step_6())
2123
 
                {
2124
 
                    break lab15;
2125
 
                }
2126
 
            } while (false);
2127
 
            cursor = limit - v_16;
2128
 
            cursor = limit_backward;            // do, line 243
2129
 
            v_18 = cursor;
2130
 
            lab18: do {
2131
 
                // (, line 243
2132
 
                // Boolean test Y_found, line 243
2133
 
                if (!(B_Y_found))
2134
 
                {
2135
 
                    break lab18;
2136
 
                }
2137
 
                // repeat, line 243
2138
 
                replab19: while(true)
2139
 
                {
2140
 
                    v_19 = cursor;
2141
 
                    lab20: do {
2142
 
                        // (, line 243
2143
 
                        // goto, line 243
2144
 
                        golab21: while(true)
2145
 
                        {
2146
 
                            v_20 = cursor;
2147
 
                            lab22: do {
2148
 
                                // (, line 243
2149
 
                                // [, line 243
2150
 
                                bra = cursor;
2151
 
                                // literal, line 243
2152
 
                                if (!(eq_s(1, "Y")))
2153
 
                                {
2154
 
                                    break lab22;
2155
 
                                }
2156
 
                                // ], line 243
2157
 
                                ket = cursor;
2158
 
                                cursor = v_20;
2159
 
                                break golab21;
2160
 
                            } while (false);
2161
 
                            cursor = v_20;
2162
 
                            if (cursor >= limit)
2163
 
                            {
2164
 
                                break lab20;
2165
 
                            }
2166
 
                            cursor++;
2167
 
                        }
2168
 
                        // <-, line 243
2169
 
                        slice_from("y");
2170
 
                        continue replab19;
2171
 
                    } while (false);
2172
 
                    cursor = v_19;
2173
 
                    break replab19;
2174
 
                }
2175
 
            } while (false);
2176
 
            cursor = v_18;
2177
 
            return true;
2178
 
        }
2179
 
 
2180
 
}
2181