java/galago/src/org/tartarus/snowball/ext/finnishStemmer.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 finnishStemmer extends SnowballProgram {
  11
  12         private Among a_0[] = {
  13             new Among ( "pa", -1, 1, "", this),
  14             new Among ( "sti", -1, 2, "", this),
  15             new Among ( "kaan", -1, 1, "", this),
  16             new Among ( "han", -1, 1, "", this),
  17             new Among ( "kin", -1, 1, "", this),
  18             new Among ( "h\u00E4n", -1, 1, "", this),
  19             new Among ( "k\u00E4\u00E4n", -1, 1, "", this),
  20             new Among ( "ko", -1, 1, "", this),
  21             new Among ( "p\u00E4", -1, 1, "", this),
  22             new Among ( "k\u00F6", -1, 1, "", this)
  23         };
  24
  25         private Among a_1[] = {
  26             new Among ( "lla", -1, -1, "", this),
  27             new Among ( "na", -1, -1, "", this),
  28             new Among ( "ssa", -1, -1, "", this),
  29             new Among ( "ta", -1, -1, "", this),
  30             new Among ( "lta", 3, -1, "", this),
  31             new Among ( "sta", 3, -1, "", this)
  32         };
  33
  34         private Among a_2[] = {
  35             new Among ( "ll\u00E4", -1, -1, "", this),
  36             new Among ( "n\u00E4", -1, -1, "", this),
  37             new Among ( "ss\u00E4", -1, -1, "", this),
  38             new Among ( "t\u00E4", -1, -1, "", this),
  39             new Among ( "lt\u00E4", 3, -1, "", this),
  40             new Among ( "st\u00E4", 3, -1, "", this)
  41         };
  42
  43         private Among a_3[] = {
  44             new Among ( "lle", -1, -1, "", this),
  45             new Among ( "ine", -1, -1, "", this)
  46         };
  47
  48         private Among a_4[] = {
  49             new Among ( "nsa", -1, 3, "", this),
  50             new Among ( "mme", -1, 3, "", this),
  51             new Among ( "nne", -1, 3, "", this),
  52             new Among ( "ni", -1, 2, "", this),
  53             new Among ( "si", -1, 1, "", this),
  54             new Among ( "an", -1, 4, "", this),
  55             new Among ( "en", -1, 6, "", this),
  56             new Among ( "\u00E4n", -1, 5, "", this),
  57             new Among ( "ns\u00E4", -1, 3, "", this)
  58         };
  59
  60         private Among a_5[] = {
  61             new Among ( "aa", -1, -1, "", this),
  62             new Among ( "ee", -1, -1, "", this),
  63             new Among ( "ii", -1, -1, "", this),
  64             new Among ( "oo", -1, -1, "", this),
  65             new Among ( "uu", -1, -1, "", this),
  66             new Among ( "\u00E4\u00E4", -1, -1, "", this),
  67             new Among ( "\u00F6\u00F6", -1, -1, "", this)
  68         };
  69
  70         private Among a_6[] = {
  71             new Among ( "a", -1, 8, "", this),
  72             new Among ( "lla", 0, -1, "", this),
  73             new Among ( "na", 0, -1, "", this),
  74             new Among ( "ssa", 0, -1, "", this),
  75             new Among ( "ta", 0, -1, "", this),
  76             new Among ( "lta", 4, -1, "", this),
  77             new Among ( "sta", 4, -1, "", this),
  78             new Among ( "tta", 4, 9, "", this),
  79             new Among ( "lle", -1, -1, "", this),
  80             new Among ( "ine", -1, -1, "", this),
  81             new Among ( "ksi", -1, -1, "", this),
  82             new Among ( "n", -1, 7, "", this),
  83             new Among ( "han", 11, 1, "", this),
  84             new Among ( "den", 11, -1, "r_VI", this),
  85             new Among ( "seen", 11, -1, "r_LONG", this),
  86             new Among ( "hen", 11, 2, "", this),
  87             new Among ( "tten", 11, -1, "r_VI", this),
  88             new Among ( "hin", 11, 3, "", this),
  89             new Among ( "siin", 11, -1, "r_VI", this),
  90             new Among ( "hon", 11, 4, "", this),
  91             new Among ( "h\u00E4n", 11, 5, "", this),
  92             new Among ( "h\u00F6n", 11, 6, "", this),
  93             new Among ( "\u00E4", -1, 8, "", this),
  94             new Among ( "ll\u00E4", 22, -1, "", this),
  95             new Among ( "n\u00E4", 22, -1, "", this),
  96             new Among ( "ss\u00E4", 22, -1, "", this),
  97             new Among ( "t\u00E4", 22, -1, "", this),
  98             new Among ( "lt\u00E4", 26, -1, "", this),
  99             new Among ( "st\u00E4", 26, -1, "", this),
 100             new Among ( "tt\u00E4", 26, 9, "", this)
 101         };
 102
 103         private Among a_7[] = {
 104             new Among ( "eja", -1, -1, "", this),
 105             new Among ( "mma", -1, 1, "", this),
 106             new Among ( "imma", 1, -1, "", this),
 107             new Among ( "mpa", -1, 1, "", this),
 108             new Among ( "impa", 3, -1, "", this),
 109             new Among ( "mmi", -1, 1, "", this),
 110             new Among ( "immi", 5, -1, "", this),
 111             new Among ( "mpi", -1, 1, "", this),
 112             new Among ( "impi", 7, -1, "", this),
 113             new Among ( "ej\u00E4", -1, -1, "", this),
 114             new Among ( "mm\u00E4", -1, 1, "", this),
 115             new Among ( "imm\u00E4", 10, -1, "", this),
 116             new Among ( "mp\u00E4", -1, 1, "", this),
 117             new Among ( "imp\u00E4", 12, -1, "", this)
 118         };
 119
 120         private Among a_8[] = {
 121             new Among ( "i", -1, -1, "", this),
 122             new Among ( "j", -1, -1, "", this)
 123         };
 124
 125         private Among a_9[] = {
 126             new Among ( "mma", -1, 1, "", this),
 127             new Among ( "imma", 0, -1, "", this)
 128         };
 129
 130         private static final char g_AEI[] = {17, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8 };
 131
 132         private static final char g_V1[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32 };
 133
 134         private static final char g_V2[] = {17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32 };
 135
 136         private static final char g_particle_end[] = {17, 97, 24, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32 };
 137
 138         private boolean B_ending_removed;
 139         private StringBuffer S_x = new StringBuffer();
 140         private int I_p2;
 141         private int I_p1;
 142
 143         private void copy_from(finnishStemmer other) {
 144             B_ending_removed = other.B_ending_removed;
 145             S_x = other.S_x;
 146             I_p2 = other.I_p2;
 147             I_p1 = other.I_p1;
 148             super.copy_from(other);
 149         }
 150
 151         private boolean r_mark_regions() {
 152             int v_1;
 153             int v_3;
 154             // (, line 41
 155             I_p1 = limit;
 156             I_p2 = limit;
 157             // goto, line 46
 158             golab0: while(true)
 159             {
 160                 v_1 = cursor;
 161                 lab1: do {
 162                     if (!(in_grouping(g_V1, 97, 246)))
 163                     {
 164                         break lab1;
 165                     }
 166                     cursor = v_1;
 167                     break golab0;
 168                 } while (false);
 169                 cursor = v_1;
 170                 if (cursor >= limit)
 171                 {
 172                     return false;
 173                 }
 174                 cursor++;
 175             }
 176             // gopast, line 46
 177             golab2: while(true)
 178             {
 179                 lab3: do {
 180                     if (!(out_grouping(g_V1, 97, 246)))
 181                     {
 182                         break lab3;
 183                     }
 184                     break golab2;
 185                 } while (false);
 186                 if (cursor >= limit)
 187                 {
 188                     return false;
 189                 }
 190                 cursor++;
 191             }
 192             // setmark p1, line 46
 193             I_p1 = cursor;
 194             // goto, line 47
 195             golab4: while(true)
 196             {
 197                 v_3 = cursor;
 198                 lab5: do {
 199                     if (!(in_grouping(g_V1, 97, 246)))
 200                     {
 201                         break lab5;
 202                     }
 203                     cursor = v_3;
 204                     break golab4;
 205                 } while (false);
 206                 cursor = v_3;
 207                 if (cursor >= limit)
 208                 {
 209                     return false;
 210                 }
 211                 cursor++;
 212             }
 213             // gopast, line 47
 214             golab6: while(true)
 215             {
 216                 lab7: do {
 217                     if (!(out_grouping(g_V1, 97, 246)))
 218                     {
 219                         break lab7;
 220                     }
 221                     break golab6;
 222                 } while (false);
 223                 if (cursor >= limit)
 224                 {
 225                     return false;
 226                 }
 227                 cursor++;
 228             }
 229             // setmark p2, line 47
 230             I_p2 = cursor;
 231             return true;
 232         }
 233
 234         private boolean r_R2() {
 235             if (!(I_p2 <= cursor))
 236             {
 237                 return false;
 238             }
 239             return true;
 240         }
 241
 242         private boolean r_particle_etc() {
 243             int among_var;
 244             int v_1;
 245             int v_2;
 246             // (, line 54
 247             // setlimit, line 55
 248             v_1 = limit - cursor;
 249             // tomark, line 55
 250             if (cursor < I_p1)
 251             {
 252                 return false;
 253             }
 254             cursor = I_p1;
 255             v_2 = limit_backward;
 256             limit_backward = cursor;
 257             cursor = limit - v_1;
 258             // (, line 55
 259             // [, line 55
 260             ket = cursor;
 261             // substring, line 55
 262             among_var = find_among_b(a_0, 10);
 263             if (among_var == 0)
 264             {
 265                 limit_backward = v_2;
 266                 return false;
 267             }
 268             // ], line 55
 269             bra = cursor;
 270             limit_backward = v_2;
 271             switch(among_var) {
 272                 case 0:
 273                     return false;
 274                 case 1:
 275                     // (, line 62
 276                     if (!(in_grouping_b(g_particle_end, 97, 246)))
 277                     {
 278                         return false;
 279                     }
 280                     break;
 281                 case 2:
 282                     // (, line 64
 283                     // call R2, line 64
 284                     if (!r_R2())
 285                     {
 286                         return false;
 287                     }
 288                     break;
 289             }
 290             // delete, line 66
 291             slice_del();
 292             return true;
 293         }
 294
 295         private boolean r_possessive() {
 296             int among_var;
 297             int v_1;
 298             int v_2;
 299             int v_3;
 300             // (, line 68
 301             // setlimit, line 69
 302             v_1 = limit - cursor;
 303             // tomark, line 69
 304             if (cursor < I_p1)
 305             {
 306                 return false;
 307             }
 308             cursor = I_p1;
 309             v_2 = limit_backward;
 310             limit_backward = cursor;
 311             cursor = limit - v_1;
 312             // (, line 69
 313             // [, line 69
 314             ket = cursor;
 315             // substring, line 69
 316             among_var = find_among_b(a_4, 9);
 317             if (among_var == 0)
 318             {
 319                 limit_backward = v_2;
 320                 return false;
 321             }
 322             // ], line 69
 323             bra = cursor;
 324             limit_backward = v_2;
 325             switch(among_var) {
 326                 case 0:
 327                     return false;
 328                 case 1:
 329                     // (, line 72
 330                     // not, line 72
 331                     {
 332                         v_3 = limit - cursor;
 333                         lab0: do {
 334                             // literal, line 72
 335                             if (!(eq_s_b(1, "k")))
 336                             {
 337                                 break lab0;
 338                             }
 339                             return false;
 340                         } while (false);
 341                         cursor = limit - v_3;
 342                     }
 343                     // delete, line 72
 344                     slice_del();
 345                     break;
 346                 case 2:
 347                     // (, line 74
 348                     // delete, line 74
 349                     slice_del();
 350                     // [, line 74
 351                     ket = cursor;
 352                     // literal, line 74
 353                     if (!(eq_s_b(3, "kse")))
 354                     {
 355                         return false;
 356                     }
 357                     // ], line 74
 358                     bra = cursor;
 359                     // <-, line 74
 360                     slice_from("ksi");
 361                     break;
 362                 case 3:
 363                     // (, line 78
 364                     // delete, line 78
 365                     slice_del();
 366                     break;
 367                 case 4:
 368                     // (, line 81
 369                     // among, line 81
 370                     if (find_among_b(a_1, 6) == 0)
 371                     {
 372                         return false;
 373                     }
 374                     // delete, line 81
 375                     slice_del();
 376                     break;
 377                 case 5:
 378                     // (, line 83
 379                     // among, line 83
 380                     if (find_among_b(a_2, 6) == 0)
 381                     {
 382                         return false;
 383                     }
 384                     // delete, line 84
 385                     slice_del();
 386                     break;
 387                 case 6:
 388                     // (, line 86
 389                     // among, line 86
 390                     if (find_among_b(a_3, 2) == 0)
 391                     {
 392                         return false;
 393                     }
 394                     // delete, line 86
 395                     slice_del();
 396                     break;
 397             }
 398             return true;
 399         }
 400
 401         private boolean r_LONG() {
 402             // among, line 91
 403             if (find_among_b(a_5, 7) == 0)
 404             {
 405                 return false;
 406             }
 407             return true;
 408         }
 409
 410         private boolean r_VI() {
 411             // (, line 93
 412             // literal, line 93
 413             if (!(eq_s_b(1, "i")))
 414             {
 415                 return false;
 416             }
 417             if (!(in_grouping_b(g_V2, 97, 246)))
 418             {
 419                 return false;
 420             }
 421             return true;
 422         }
 423
 424         private boolean r_case_ending() {
 425             int among_var;
 426             int v_1;
 427             int v_2;
 428             int v_3;
 429             int v_4;
 430             int v_5;
 431             // (, line 95
 432             // setlimit, line 96
 433             v_1 = limit - cursor;
 434             // tomark, line 96
 435             if (cursor < I_p1)
 436             {
 437                 return false;
 438             }
 439             cursor = I_p1;
 440             v_2 = limit_backward;
 441             limit_backward = cursor;
 442             cursor = limit - v_1;
 443             // (, line 96
 444             // [, line 96
 445             ket = cursor;
 446             // substring, line 96
 447             among_var = find_among_b(a_6, 30);
 448             if (among_var == 0)
 449             {
 450                 limit_backward = v_2;
 451                 return false;
 452             }
 453             // ], line 96
 454             bra = cursor;
 455             limit_backward = v_2;
 456             switch(among_var) {
 457                 case 0:
 458                     return false;
 459                 case 1:
 460                     // (, line 98
 461                     // literal, line 98
 462                     if (!(eq_s_b(1, "a")))
 463                     {
 464                         return false;
 465                     }
 466                     break;
 467                 case 2:
 468                     // (, line 99
 469                     // literal, line 99
 470                     if (!(eq_s_b(1, "e")))
 471                     {
 472                         return false;
 473                     }
 474                     break;
 475                 case 3:
 476                     // (, line 100
 477                     // literal, line 100
 478                     if (!(eq_s_b(1, "i")))
 479                     {
 480                         return false;
 481                     }
 482                     break;
 483                 case 4:
 484                     // (, line 101
 485                     // literal, line 101
 486                     if (!(eq_s_b(1, "o")))
 487                     {
 488                         return false;
 489                     }
 490                     break;
 491                 case 5:
 492                     // (, line 102
 493                     // literal, line 102
 494                     if (!(eq_s_b(1, "\u00E4")))
 495                     {
 496                         return false;
 497                     }
 498                     break;
 499                 case 6:
 500                     // (, line 103
 501                     // literal, line 103
 502                     if (!(eq_s_b(1, "\u00F6")))
 503                     {
 504                         return false;
 505                     }
 506                     break;
 507                 case 7:
 508                     // (, line 111
 509                     // try, line 111
 510                     v_3 = limit - cursor;
 511                     lab0: do {
 512                         // (, line 111
 513                         // and, line 113
 514                         v_4 = limit - cursor;
 515                         // or, line 112
 516                         lab1: do {
 517                             v_5 = limit - cursor;
 518                             lab2: do {
 519                                 // call LONG, line 111
 520                                 if (!r_LONG())
 521                                 {
 522                                     break lab2;
 523                                 }
 524                                 break lab1;
 525                             } while (false);
 526                             cursor = limit - v_5;
 527                             // literal, line 112
 528                             if (!(eq_s_b(2, "ie")))
 529                             {
 530                                 cursor = limit - v_3;
 531                                 break lab0;
 532                             }
 533                         } while (false);
 534                         cursor = limit - v_4;
 535                         // next, line 113
 536                         if (cursor <= limit_backward)
 537                         {
 538                             cursor = limit - v_3;
 539                             break lab0;
 540                         }
 541                         cursor--;
 542                         // ], line 113
 543                         bra = cursor;
 544                     } while (false);
 545                     break;
 546                 case 8:
 547                     // (, line 119
 548                     if (!(in_grouping_b(g_V1, 97, 246)))
 549                     {
 550                         return false;
 551                     }
 552                     if (!(out_grouping_b(g_V1, 97, 246)))
 553                     {
 554                         return false;
 555                     }
 556                     break;
 557                 case 9:
 558                     // (, line 121
 559                     // literal, line 121
 560                     if (!(eq_s_b(1, "e")))
 561                     {
 562                         return false;
 563                     }
 564                     break;
 565             }
 566             // delete, line 138
 567             slice_del();
 568             // set ending_removed, line 139
 569             B_ending_removed = true;
 570             return true;
 571         }
 572
 573         private boolean r_other_endings() {
 574             int among_var;
 575             int v_1;
 576             int v_2;
 577             int v_3;
 578             // (, line 141
 579             // setlimit, line 142
 580             v_1 = limit - cursor;
 581             // tomark, line 142
 582             if (cursor < I_p2)
 583             {
 584                 return false;
 585             }
 586             cursor = I_p2;
 587             v_2 = limit_backward;
 588             limit_backward = cursor;
 589             cursor = limit - v_1;
 590             // (, line 142
 591             // [, line 142
 592             ket = cursor;
 593             // substring, line 142
 594             among_var = find_among_b(a_7, 14);
 595             if (among_var == 0)
 596             {
 597                 limit_backward = v_2;
 598                 return false;
 599             }
 600             // ], line 142
 601             bra = cursor;
 602             limit_backward = v_2;
 603             switch(among_var) {
 604                 case 0:
 605                     return false;
 606                 case 1:
 607                     // (, line 146
 608                     // not, line 146
 609                     {
 610                         v_3 = limit - cursor;
 611                         lab0: do {
 612                             // literal, line 146
 613                             if (!(eq_s_b(2, "po")))
 614                             {
 615                                 break lab0;
 616                             }
 617                             return false;
 618                         } while (false);
 619                         cursor = limit - v_3;
 620                     }
 621                     break;
 622             }
 623             // delete, line 151
 624             slice_del();
 625             return true;
 626         }
 627
 628         private boolean r_i_plural() {
 629             int v_1;
 630             int v_2;
 631             // (, line 153
 632             // setlimit, line 154
 633             v_1 = limit - cursor;
 634             // tomark, line 154
 635             if (cursor < I_p1)
 636             {
 637                 return false;
 638             }
 639             cursor = I_p1;
 640             v_2 = limit_backward;
 641             limit_backward = cursor;
 642             cursor = limit - v_1;
 643             // (, line 154
 644             // [, line 154
 645             ket = cursor;
 646             // substring, line 154
 647             if (find_among_b(a_8, 2) == 0)
 648             {
 649                 limit_backward = v_2;
 650                 return false;
 651             }
 652             // ], line 154
 653             bra = cursor;
 654             limit_backward = v_2;
 655             // delete, line 158
 656             slice_del();
 657             return true;
 658         }
 659
 660         private boolean r_t_plural() {
 661             int among_var;
 662             int v_1;
 663             int v_2;
 664             int v_3;
 665             int v_4;
 666             int v_5;
 667             int v_6;
 668             // (, line 160
 669             // setlimit, line 161
 670             v_1 = limit - cursor;
 671             // tomark, line 161
 672             if (cursor < I_p1)
 673             {
 674                 return false;
 675             }
 676             cursor = I_p1;
 677             v_2 = limit_backward;
 678             limit_backward = cursor;
 679             cursor = limit - v_1;
 680             // (, line 161
 681             // [, line 162
 682             ket = cursor;
 683             // literal, line 162
 684             if (!(eq_s_b(1, "t")))
 685             {
 686                 limit_backward = v_2;
 687                 return false;
 688             }
 689             // ], line 162
 690             bra = cursor;
 691             // test, line 162
 692             v_3 = limit - cursor;
 693             if (!(in_grouping_b(g_V1, 97, 246)))
 694             {
 695                 limit_backward = v_2;
 696                 return false;
 697             }
 698             cursor = limit - v_3;
 699             // delete, line 163
 700             slice_del();
 701             limit_backward = v_2;
 702             // setlimit, line 165
 703             v_4 = limit - cursor;
 704             // tomark, line 165
 705             if (cursor < I_p2)
 706             {
 707                 return false;
 708             }
 709             cursor = I_p2;
 710             v_5 = limit_backward;
 711             limit_backward = cursor;
 712             cursor = limit - v_4;
 713             // (, line 165
 714             // [, line 165
 715             ket = cursor;
 716             // substring, line 165
 717             among_var = find_among_b(a_9, 2);
 718             if (among_var == 0)
 719             {
 720                 limit_backward = v_5;
 721                 return false;
 722             }
 723             // ], line 165
 724             bra = cursor;
 725             limit_backward = v_5;
 726             switch(among_var) {
 727                 case 0:
 728                     return false;
 729                 case 1:
 730                     // (, line 167
 731                     // not, line 167
 732                     {
 733                         v_6 = limit - cursor;
 734                         lab0: do {
 735                             // literal, line 167
 736                             if (!(eq_s_b(2, "po")))
 737                             {
 738                                 break lab0;
 739                             }
 740                             return false;
 741                         } while (false);
 742                         cursor = limit - v_6;
 743                     }
 744                     break;
 745             }
 746             // delete, line 170
 747             slice_del();
 748             return true;
 749         }
 750
 751         private boolean r_tidy() {
 752             int v_1;
 753             int v_2;
 754             int v_3;
 755             int v_4;
 756             int v_5;
 757             int v_6;
 758             int v_7;
 759             int v_8;
 760             int v_9;
 761             // (, line 172
 762             // setlimit, line 173
 763             v_1 = limit - cursor;
 764             // tomark, line 173
 765             if (cursor < I_p1)
 766             {
 767                 return false;
 768             }
 769             cursor = I_p1;
 770             v_2 = limit_backward;
 771             limit_backward = cursor;
 772             cursor = limit - v_1;
 773             // (, line 173
 774             // do, line 174
 775             v_3 = limit - cursor;
 776             lab0: do {
 777                 // (, line 174
 778                 // and, line 174
 779                 v_4 = limit - cursor;
 780                 // call LONG, line 174
 781                 if (!r_LONG())
 782                 {
 783                     break lab0;
 784                 }
 785                 cursor = limit - v_4;
 786                 // (, line 174
 787                 // [, line 174
 788                 ket = cursor;
 789                 // next, line 174
 790                 if (cursor <= limit_backward)
 791                 {
 792                     break lab0;
 793                 }
 794                 cursor--;
 795                 // ], line 174
 796                 bra = cursor;
 797                 // delete, line 174
 798                 slice_del();
 799             } while (false);
 800             cursor = limit - v_3;
 801             // do, line 175
 802             v_5 = limit - cursor;
 803             lab1: do {
 804                 // (, line 175
 805                 // [, line 175
 806                 ket = cursor;
 807                 if (!(in_grouping_b(g_AEI, 97, 228)))
 808                 {
 809                     break lab1;
 810                 }
 811                 // ], line 175
 812                 bra = cursor;
 813                 if (!(out_grouping_b(g_V1, 97, 246)))
 814                 {
 815                     break lab1;
 816                 }
 817                 // delete, line 175
 818                 slice_del();
 819             } while (false);
 820             cursor = limit - v_5;
 821             // do, line 176
 822             v_6 = limit - cursor;
 823             lab2: do {
 824                 // (, line 176
 825                 // [, line 176
 826                 ket = cursor;
 827                 // literal, line 176
 828                 if (!(eq_s_b(1, "j")))
 829                 {
 830                     break lab2;
 831                 }
 832                 // ], line 176
 833                 bra = cursor;
 834                 // or, line 176
 835                 lab3: do {
 836                     v_7 = limit - cursor;
 837                     lab4: do {
 838                         // literal, line 176
 839                         if (!(eq_s_b(1, "o")))
 840                         {
 841                             break lab4;
 842                         }
 843                         break lab3;
 844                     } while (false);
 845                     cursor = limit - v_7;
 846                     // literal, line 176
 847                     if (!(eq_s_b(1, "u")))
 848                     {
 849                         break lab2;
 850                     }
 851                 } while (false);
 852                 // delete, line 176
 853                 slice_del();
 854             } while (false);
 855             cursor = limit - v_6;
 856             // do, line 177
 857             v_8 = limit - cursor;
 858             lab5: do {
 859                 // (, line 177
 860                 // [, line 177
 861                 ket = cursor;
 862                 // literal, line 177
 863                 if (!(eq_s_b(1, "o")))
 864                 {
 865                     break lab5;
 866                 }
 867                 // ], line 177
 868                 bra = cursor;
 869                 // literal, line 177
 870                 if (!(eq_s_b(1, "j")))
 871                 {
 872                     break lab5;
 873                 }
 874                 // delete, line 177
 875                 slice_del();
 876             } while (false);
 877             cursor = limit - v_8;
 878             limit_backward = v_2;
 879             // goto, line 179
 880             golab6: while(true)
 881             {
 882                 v_9 = limit - cursor;
 883                 lab7: do {
 884                     if (!(out_grouping_b(g_V1, 97, 246)))
 885                     {
 886                         break lab7;
 887                     }
 888                     cursor = limit - v_9;
 889                     break golab6;
 890                 } while (false);
 891                 cursor = limit - v_9;
 892                 if (cursor <= limit_backward)
 893                 {
 894                     return false;
 895                 }
 896                 cursor--;
 897             }
 898             // [, line 179
 899             ket = cursor;
 900             // next, line 179
 901             if (cursor <= limit_backward)
 902             {
 903                 return false;
 904             }
 905             cursor--;
 906             // ], line 179
 907             bra = cursor;
 908             // -> x, line 179
 909             S_x = slice_to(S_x);
 910             // name x, line 179
 911             if (!(eq_v_b(S_x)))
 912             {
 913                 return false;
 914             }
 915             // delete, line 179
 916             slice_del();
 917             return true;
 918         }
 919
 920         public boolean stem() {
 921             int v_1;
 922             int v_2;
 923             int v_3;
 924             int v_4;
 925             int v_5;
 926             int v_6;
 927             int v_7;
 928             int v_8;
 929             int v_9;
 930             // (, line 183
 931             // do, line 185
 932             v_1 = cursor;
 933             lab0: do {
 934                 // call mark_regions, line 185
 935                 if (!r_mark_regions())
 936                 {
 937                     break lab0;
 938                 }
 939             } while (false);
 940             cursor = v_1;
 941             // unset ending_removed, line 186
 942             B_ending_removed = false;
 943             // backwards, line 187
 944             limit_backward = cursor; cursor = limit;
 945             // (, line 187
 946             // do, line 188
 947             v_2 = limit - cursor;
 948             lab1: do {
 949                 // call particle_etc, line 188
 950                 if (!r_particle_etc())
 951                 {
 952                     break lab1;
 953                 }
 954             } while (false);
 955             cursor = limit - v_2;
 956             // do, line 189
 957             v_3 = limit - cursor;
 958             lab2: do {
 959                 // call possessive, line 189
 960                 if (!r_possessive())
 961                 {
 962                     break lab2;
 963                 }
 964             } while (false);
 965             cursor = limit - v_3;
 966             // do, line 190
 967             v_4 = limit - cursor;
 968             lab3: do {
 969                 // call case_ending, line 190
 970                 if (!r_case_ending())
 971                 {
 972                     break lab3;
 973                 }
 974             } while (false);
 975             cursor = limit - v_4;
 976             // do, line 191
 977             v_5 = limit - cursor;
 978             lab4: do {
 979                 // call other_endings, line 191
 980                 if (!r_other_endings())
 981                 {
 982                     break lab4;
 983                 }
 984             } while (false);
 985             cursor = limit - v_5;
 986             // or, line 192
 987             lab5: do {
 988                 v_6 = limit - cursor;
 989                 lab6: do {
 990                     // (, line 192
 991                     // Boolean test ending_removed, line 192
 992                     if (!(B_ending_removed))
 993                     {
 994                         break lab6;
 995                     }
 996                     // do, line 192
 997                     v_7 = limit - cursor;
 998                     lab7: do {
 999                         // call i_plural, line 192
1000                         if (!r_i_plural())
1001                         {
1002                             break lab7;
1003                         }
1004                     } while (false);
1005                     cursor = limit - v_7;
1006                     break lab5;
1007                 } while (false);
1008                 cursor = limit - v_6;
1009                 // do, line 192
1010                 v_8 = limit - cursor;
1011                 lab8: do {
1012                     // call t_plural, line 192
1013                     if (!r_t_plural())
1014                     {
1015                         break lab8;
1016                     }
1017                 } while (false);
1018                 cursor = limit - v_8;
1019             } while (false);
1020             // do, line 193
1021             v_9 = limit - cursor;
1022             lab9: do {
1023                 // call tidy, line 193
1024                 if (!r_tidy())
1025                 {
1026                     break lab9;
1027                 }
1028             } while (false);
1029             cursor = limit - v_9;
1030             cursor = limit_backward;            return true;
1031         }
1032
1033 }
1034