lucene-java-3.5.0/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