lucene-java-3.5.0/lucene/contrib/analyzers/common/src/java/org/tartarus/snowball/ext/TurkishStemmer.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 TurkishStemmer extends SnowballProgram {
  11
  12         private Among a_0[] = {
  13             new Among ( "m", -1, -1, "", this),
  14             new Among ( "n", -1, -1, "", this),
  15             new Among ( "miz", -1, -1, "", this),
  16             new Among ( "niz", -1, -1, "", this),
  17             new Among ( "muz", -1, -1, "", this),
  18             new Among ( "nuz", -1, -1, "", this),
  19             new Among ( "m\u00FCz", -1, -1, "", this),
  20             new Among ( "n\u00FCz", -1, -1, "", this),
  21             new Among ( "m\u0131z", -1, -1, "", this),
  22             new Among ( "n\u0131z", -1, -1, "", this)
  23         };
  24
  25         private Among a_1[] = {
  26             new Among ( "leri", -1, -1, "", this),
  27             new Among ( "lar\u0131", -1, -1, "", this)
  28         };
  29
  30         private Among a_2[] = {
  31             new Among ( "ni", -1, -1, "", this),
  32             new Among ( "nu", -1, -1, "", this),
  33             new Among ( "n\u00FC", -1, -1, "", this),
  34             new Among ( "n\u0131", -1, -1, "", this)
  35         };
  36
  37         private Among a_3[] = {
  38             new Among ( "in", -1, -1, "", this),
  39             new Among ( "un", -1, -1, "", this),
  40             new Among ( "\u00FCn", -1, -1, "", this),
  41             new Among ( "\u0131n", -1, -1, "", this)
  42         };
  43
  44         private Among a_4[] = {
  45             new Among ( "a", -1, -1, "", this),
  46             new Among ( "e", -1, -1, "", this)
  47         };
  48
  49         private Among a_5[] = {
  50             new Among ( "na", -1, -1, "", this),
  51             new Among ( "ne", -1, -1, "", this)
  52         };
  53
  54         private Among a_6[] = {
  55             new Among ( "da", -1, -1, "", this),
  56             new Among ( "ta", -1, -1, "", this),
  57             new Among ( "de", -1, -1, "", this),
  58             new Among ( "te", -1, -1, "", this)
  59         };
  60
  61         private Among a_7[] = {
  62             new Among ( "nda", -1, -1, "", this),
  63             new Among ( "nde", -1, -1, "", this)
  64         };
  65
  66         private Among a_8[] = {
  67             new Among ( "dan", -1, -1, "", this),
  68             new Among ( "tan", -1, -1, "", this),
  69             new Among ( "den", -1, -1, "", this),
  70             new Among ( "ten", -1, -1, "", this)
  71         };
  72
  73         private Among a_9[] = {
  74             new Among ( "ndan", -1, -1, "", this),
  75             new Among ( "nden", -1, -1, "", this)
  76         };
  77
  78         private Among a_10[] = {
  79             new Among ( "la", -1, -1, "", this),
  80             new Among ( "le", -1, -1, "", this)
  81         };
  82
  83         private Among a_11[] = {
  84             new Among ( "ca", -1, -1, "", this),
  85             new Among ( "ce", -1, -1, "", this)
  86         };
  87
  88         private Among a_12[] = {
  89             new Among ( "im", -1, -1, "", this),
  90             new Among ( "um", -1, -1, "", this),
  91             new Among ( "\u00FCm", -1, -1, "", this),
  92             new Among ( "\u0131m", -1, -1, "", this)
  93         };
  94
  95         private Among a_13[] = {
  96             new Among ( "sin", -1, -1, "", this),
  97             new Among ( "sun", -1, -1, "", this),
  98             new Among ( "s\u00FCn", -1, -1, "", this),
  99             new Among ( "s\u0131n", -1, -1, "", this)
 100         };
 101
 102         private Among a_14[] = {
 103             new Among ( "iz", -1, -1, "", this),
 104             new Among ( "uz", -1, -1, "", this),
 105             new Among ( "\u00FCz", -1, -1, "", this),
 106             new Among ( "\u0131z", -1, -1, "", this)
 107         };
 108
 109         private Among a_15[] = {
 110             new Among ( "siniz", -1, -1, "", this),
 111             new Among ( "sunuz", -1, -1, "", this),
 112             new Among ( "s\u00FCn\u00FCz", -1, -1, "", this),
 113             new Among ( "s\u0131n\u0131z", -1, -1, "", this)
 114         };
 115
 116         private Among a_16[] = {
 117             new Among ( "lar", -1, -1, "", this),
 118             new Among ( "ler", -1, -1, "", this)
 119         };
 120
 121         private Among a_17[] = {
 122             new Among ( "niz", -1, -1, "", this),
 123             new Among ( "nuz", -1, -1, "", this),
 124             new Among ( "n\u00FCz", -1, -1, "", this),
 125             new Among ( "n\u0131z", -1, -1, "", this)
 126         };
 127
 128         private Among a_18[] = {
 129             new Among ( "dir", -1, -1, "", this),
 130             new Among ( "tir", -1, -1, "", this),
 131             new Among ( "dur", -1, -1, "", this),
 132             new Among ( "tur", -1, -1, "", this),
 133             new Among ( "d\u00FCr", -1, -1, "", this),
 134             new Among ( "t\u00FCr", -1, -1, "", this),
 135             new Among ( "d\u0131r", -1, -1, "", this),
 136             new Among ( "t\u0131r", -1, -1, "", this)
 137         };
 138
 139         private Among a_19[] = {
 140             new Among ( "cas\u0131na", -1, -1, "", this),
 141             new Among ( "cesine", -1, -1, "", this)
 142         };
 143
 144         private Among a_20[] = {
 145             new Among ( "di", -1, -1, "", this),
 146             new Among ( "ti", -1, -1, "", this),
 147             new Among ( "dik", -1, -1, "", this),
 148             new Among ( "tik", -1, -1, "", this),
 149             new Among ( "duk", -1, -1, "", this),
 150             new Among ( "tuk", -1, -1, "", this),
 151             new Among ( "d\u00FCk", -1, -1, "", this),
 152             new Among ( "t\u00FCk", -1, -1, "", this),
 153             new Among ( "d\u0131k", -1, -1, "", this),
 154             new Among ( "t\u0131k", -1, -1, "", this),
 155             new Among ( "dim", -1, -1, "", this),
 156             new Among ( "tim", -1, -1, "", this),
 157             new Among ( "dum", -1, -1, "", this),
 158             new Among ( "tum", -1, -1, "", this),
 159             new Among ( "d\u00FCm", -1, -1, "", this),
 160             new Among ( "t\u00FCm", -1, -1, "", this),
 161             new Among ( "d\u0131m", -1, -1, "", this),
 162             new Among ( "t\u0131m", -1, -1, "", this),
 163             new Among ( "din", -1, -1, "", this),
 164             new Among ( "tin", -1, -1, "", this),
 165             new Among ( "dun", -1, -1, "", this),
 166             new Among ( "tun", -1, -1, "", this),
 167             new Among ( "d\u00FCn", -1, -1, "", this),
 168             new Among ( "t\u00FCn", -1, -1, "", this),
 169             new Among ( "d\u0131n", -1, -1, "", this),
 170             new Among ( "t\u0131n", -1, -1, "", this),
 171             new Among ( "du", -1, -1, "", this),
 172             new Among ( "tu", -1, -1, "", this),
 173             new Among ( "d\u00FC", -1, -1, "", this),
 174             new Among ( "t\u00FC", -1, -1, "", this),
 175             new Among ( "d\u0131", -1, -1, "", this),
 176             new Among ( "t\u0131", -1, -1, "", this)
 177         };
 178
 179         private Among a_21[] = {
 180             new Among ( "sa", -1, -1, "", this),
 181             new Among ( "se", -1, -1, "", this),
 182             new Among ( "sak", -1, -1, "", this),
 183             new Among ( "sek", -1, -1, "", this),
 184             new Among ( "sam", -1, -1, "", this),
 185             new Among ( "sem", -1, -1, "", this),
 186             new Among ( "san", -1, -1, "", this),
 187             new Among ( "sen", -1, -1, "", this)
 188         };
 189
 190         private Among a_22[] = {
 191             new Among ( "mi\u015F", -1, -1, "", this),
 192             new Among ( "mu\u015F", -1, -1, "", this),
 193             new Among ( "m\u00FC\u015F", -1, -1, "", this),
 194             new Among ( "m\u0131\u015F", -1, -1, "", this)
 195         };
 196
 197         private Among a_23[] = {
 198             new Among ( "b", -1, 1, "", this),
 199             new Among ( "c", -1, 2, "", this),
 200             new Among ( "d", -1, 3, "", this),
 201             new Among ( "\u011F", -1, 4, "", this)
 202         };
 203
 204         private static final char g_vowel[] = {17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 8, 0, 0, 0, 0, 0, 0, 1 };
 205
 206         private static final char g_U[] = {1, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1 };
 207
 208         private static final char g_vowel1[] = {1, 64, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 209
 210         private static final char g_vowel2[] = {17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130 };
 211
 212         private static final char g_vowel3[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 213
 214         private static final char g_vowel4[] = {17 };
 215
 216         private static final char g_vowel5[] = {65 };
 217
 218         private static final char g_vowel6[] = {65 };
 219
 220         private boolean B_continue_stemming_noun_suffixes;
 221         private int I_strlen;
 222
 223         private void copy_from(TurkishStemmer other) {
 224             B_continue_stemming_noun_suffixes = other.B_continue_stemming_noun_suffixes;
 225             I_strlen = other.I_strlen;
 226             super.copy_from(other);
 227         }
 228
 229         private boolean r_check_vowel_harmony() {
 230             int v_1;
 231             int v_2;
 232             int v_3;
 233             int v_4;
 234             int v_5;
 235             int v_6;
 236             int v_7;
 237             int v_8;
 238             int v_9;
 239             int v_10;
 240             int v_11;
 241             // (, line 111
 242             // test, line 112
 243             v_1 = limit - cursor;
 244             // (, line 113
 245             // (, line 114
 246             // goto, line 114
 247             golab0: while(true)
 248             {
 249                 v_2 = limit - cursor;
 250                 lab1: do {
 251                     if (!(in_grouping_b(g_vowel, 97, 305)))
 252                     {
 253                         break lab1;
 254                     }
 255                     cursor = limit - v_2;
 256                     break golab0;
 257                 } while (false);
 258                 cursor = limit - v_2;
 259                 if (cursor <= limit_backward)
 260                 {
 261                     return false;
 262                 }
 263                 cursor--;
 264             }
 265             // (, line 115
 266             // or, line 116
 267             lab2: do {
 268                 v_3 = limit - cursor;
 269                 lab3: do {
 270                     // (, line 116
 271                     // literal, line 116
 272                     if (!(eq_s_b(1, "a")))
 273                     {
 274                         break lab3;
 275                     }
 276                     // goto, line 116
 277                     golab4: while(true)
 278                     {
 279                         v_4 = limit - cursor;
 280                         lab5: do {
 281                             if (!(in_grouping_b(g_vowel1, 97, 305)))
 282                             {
 283                                 break lab5;
 284                             }
 285                             cursor = limit - v_4;
 286                             break golab4;
 287                         } while (false);
 288                         cursor = limit - v_4;
 289                         if (cursor <= limit_backward)
 290                         {
 291                             break lab3;
 292                         }
 293                         cursor--;
 294                     }
 295                     break lab2;
 296                 } while (false);
 297                 cursor = limit - v_3;
 298                 lab6: do {
 299                     // (, line 117
 300                     // literal, line 117
 301                     if (!(eq_s_b(1, "e")))
 302                     {
 303                         break lab6;
 304                     }
 305                     // goto, line 117
 306                     golab7: while(true)
 307                     {
 308                         v_5 = limit - cursor;
 309                         lab8: do {
 310                             if (!(in_grouping_b(g_vowel2, 101, 252)))
 311                             {
 312                                 break lab8;
 313                             }
 314                             cursor = limit - v_5;
 315                             break golab7;
 316                         } while (false);
 317                         cursor = limit - v_5;
 318                         if (cursor <= limit_backward)
 319                         {
 320                             break lab6;
 321                         }
 322                         cursor--;
 323                     }
 324                     break lab2;
 325                 } while (false);
 326                 cursor = limit - v_3;
 327                 lab9: do {
 328                     // (, line 118
 329                     // literal, line 118
 330                     if (!(eq_s_b(1, "\u0131")))
 331                     {
 332                         break lab9;
 333                     }
 334                     // goto, line 118
 335                     golab10: while(true)
 336                     {
 337                         v_6 = limit - cursor;
 338                         lab11: do {
 339                             if (!(in_grouping_b(g_vowel3, 97, 305)))
 340                             {
 341                                 break lab11;
 342                             }
 343                             cursor = limit - v_6;
 344                             break golab10;
 345                         } while (false);
 346                         cursor = limit - v_6;
 347                         if (cursor <= limit_backward)
 348                         {
 349                             break lab9;
 350                         }
 351                         cursor--;
 352                     }
 353                     break lab2;
 354                 } while (false);
 355                 cursor = limit - v_3;
 356                 lab12: do {
 357                     // (, line 119
 358                     // literal, line 119
 359                     if (!(eq_s_b(1, "i")))
 360                     {
 361                         break lab12;
 362                     }
 363                     // goto, line 119
 364                     golab13: while(true)
 365                     {
 366                         v_7 = limit - cursor;
 367                         lab14: do {
 368                             if (!(in_grouping_b(g_vowel4, 101, 105)))
 369                             {
 370                                 break lab14;
 371                             }
 372                             cursor = limit - v_7;
 373                             break golab13;
 374                         } while (false);
 375                         cursor = limit - v_7;
 376                         if (cursor <= limit_backward)
 377                         {
 378                             break lab12;
 379                         }
 380                         cursor--;
 381                     }
 382                     break lab2;
 383                 } while (false);
 384                 cursor = limit - v_3;
 385                 lab15: do {
 386                     // (, line 120
 387                     // literal, line 120
 388                     if (!(eq_s_b(1, "o")))
 389                     {
 390                         break lab15;
 391                     }
 392                     // goto, line 120
 393                     golab16: while(true)
 394                     {
 395                         v_8 = limit - cursor;
 396                         lab17: do {
 397                             if (!(in_grouping_b(g_vowel5, 111, 117)))
 398                             {
 399                                 break lab17;
 400                             }
 401                             cursor = limit - v_8;
 402                             break golab16;
 403                         } while (false);
 404                         cursor = limit - v_8;
 405                         if (cursor <= limit_backward)
 406                         {
 407                             break lab15;
 408                         }
 409                         cursor--;
 410                     }
 411                     break lab2;
 412                 } while (false);
 413                 cursor = limit - v_3;
 414                 lab18: do {
 415                     // (, line 121
 416                     // literal, line 121
 417                     if (!(eq_s_b(1, "\u00F6")))
 418                     {
 419                         break lab18;
 420                     }
 421                     // goto, line 121
 422                     golab19: while(true)
 423                     {
 424                         v_9 = limit - cursor;
 425                         lab20: do {
 426                             if (!(in_grouping_b(g_vowel6, 246, 252)))
 427                             {
 428                                 break lab20;
 429                             }
 430                             cursor = limit - v_9;
 431                             break golab19;
 432                         } while (false);
 433                         cursor = limit - v_9;
 434                         if (cursor <= limit_backward)
 435                         {
 436                             break lab18;
 437                         }
 438                         cursor--;
 439                     }
 440                     break lab2;
 441                 } while (false);
 442                 cursor = limit - v_3;
 443                 lab21: do {
 444                     // (, line 122
 445                     // literal, line 122
 446                     if (!(eq_s_b(1, "u")))
 447                     {
 448                         break lab21;
 449                     }
 450                     // goto, line 122
 451                     golab22: while(true)
 452                     {
 453                         v_10 = limit - cursor;
 454                         lab23: do {
 455                             if (!(in_grouping_b(g_vowel5, 111, 117)))
 456                             {
 457                                 break lab23;
 458                             }
 459                             cursor = limit - v_10;
 460                             break golab22;
 461                         } while (false);
 462                         cursor = limit - v_10;
 463                         if (cursor <= limit_backward)
 464                         {
 465                             break lab21;
 466                         }
 467                         cursor--;
 468                     }
 469                     break lab2;
 470                 } while (false);
 471                 cursor = limit - v_3;
 472                 // (, line 123
 473                 // literal, line 123
 474                 if (!(eq_s_b(1, "\u00FC")))
 475                 {
 476                     return false;
 477                 }
 478                 // goto, line 123
 479                 golab24: while(true)
 480                 {
 481                     v_11 = limit - cursor;
 482                     lab25: do {
 483                         if (!(in_grouping_b(g_vowel6, 246, 252)))
 484                         {
 485                             break lab25;
 486                         }
 487                         cursor = limit - v_11;
 488                         break golab24;
 489                     } while (false);
 490                     cursor = limit - v_11;
 491                     if (cursor <= limit_backward)
 492                     {
 493                         return false;
 494                     }
 495                     cursor--;
 496                 }
 497             } while (false);
 498             cursor = limit - v_1;
 499             return true;
 500         }
 501
 502         private boolean r_mark_suffix_with_optional_n_consonant() {
 503             int v_1;
 504             int v_2;
 505             int v_3;
 506             int v_4;
 507             int v_5;
 508             int v_6;
 509             int v_7;
 510             // (, line 132
 511             // or, line 134
 512             lab0: do {
 513                 v_1 = limit - cursor;
 514                 lab1: do {
 515                     // (, line 133
 516                     // (, line 133
 517                     // test, line 133
 518                     v_2 = limit - cursor;
 519                     // literal, line 133
 520                     if (!(eq_s_b(1, "n")))
 521                     {
 522                         break lab1;
 523                     }
 524                     cursor = limit - v_2;
 525                     // next, line 133
 526                     if (cursor <= limit_backward)
 527                     {
 528                         break lab1;
 529                     }
 530                     cursor--;
 531                     // (, line 133
 532                     // test, line 133
 533                     v_3 = limit - cursor;
 534                     if (!(in_grouping_b(g_vowel, 97, 305)))
 535                     {
 536                         break lab1;
 537                     }
 538                     cursor = limit - v_3;
 539                     break lab0;
 540                 } while (false);
 541                 cursor = limit - v_1;
 542                 // (, line 135
 543                 // (, line 135
 544                 // not, line 135
 545                 {
 546                     v_4 = limit - cursor;
 547                     lab2: do {
 548                         // (, line 135
 549                         // test, line 135
 550                         v_5 = limit - cursor;
 551                         // literal, line 135
 552                         if (!(eq_s_b(1, "n")))
 553                         {
 554                             break lab2;
 555                         }
 556                         cursor = limit - v_5;
 557                         return false;
 558                     } while (false);
 559                     cursor = limit - v_4;
 560                 }
 561                 // test, line 135
 562                 v_6 = limit - cursor;
 563                 // (, line 135
 564                 // next, line 135
 565                 if (cursor <= limit_backward)
 566                 {
 567                     return false;
 568                 }
 569                 cursor--;
 570                 // (, line 135
 571                 // test, line 135
 572                 v_7 = limit - cursor;
 573                 if (!(in_grouping_b(g_vowel, 97, 305)))
 574                 {
 575                     return false;
 576                 }
 577                 cursor = limit - v_7;
 578                 cursor = limit - v_6;
 579             } while (false);
 580             return true;
 581         }
 582
 583         private boolean r_mark_suffix_with_optional_s_consonant() {
 584             int v_1;
 585             int v_2;
 586             int v_3;
 587             int v_4;
 588             int v_5;
 589             int v_6;
 590             int v_7;
 591             // (, line 143
 592             // or, line 145
 593             lab0: do {
 594                 v_1 = limit - cursor;
 595                 lab1: do {
 596                     // (, line 144
 597                     // (, line 144
 598                     // test, line 144
 599                     v_2 = limit - cursor;
 600                     // literal, line 144
 601                     if (!(eq_s_b(1, "s")))
 602                     {
 603                         break lab1;
 604                     }
 605                     cursor = limit - v_2;
 606                     // next, line 144
 607                     if (cursor <= limit_backward)
 608                     {
 609                         break lab1;
 610                     }
 611                     cursor--;
 612                     // (, line 144
 613                     // test, line 144
 614                     v_3 = limit - cursor;
 615                     if (!(in_grouping_b(g_vowel, 97, 305)))
 616                     {
 617                         break lab1;
 618                     }
 619                     cursor = limit - v_3;
 620                     break lab0;
 621                 } while (false);
 622                 cursor = limit - v_1;
 623                 // (, line 146
 624                 // (, line 146
 625                 // not, line 146
 626                 {
 627                     v_4 = limit - cursor;
 628                     lab2: do {
 629                         // (, line 146
 630                         // test, line 146
 631                         v_5 = limit - cursor;
 632                         // literal, line 146
 633                         if (!(eq_s_b(1, "s")))
 634                         {
 635                             break lab2;
 636                         }
 637                         cursor = limit - v_5;
 638                         return false;
 639                     } while (false);
 640                     cursor = limit - v_4;
 641                 }
 642                 // test, line 146
 643                 v_6 = limit - cursor;
 644                 // (, line 146
 645                 // next, line 146
 646                 if (cursor <= limit_backward)
 647                 {
 648                     return false;
 649                 }
 650                 cursor--;
 651                 // (, line 146
 652                 // test, line 146
 653                 v_7 = limit - cursor;
 654                 if (!(in_grouping_b(g_vowel, 97, 305)))
 655                 {
 656                     return false;
 657                 }
 658                 cursor = limit - v_7;
 659                 cursor = limit - v_6;
 660             } while (false);
 661             return true;
 662         }
 663
 664         private boolean r_mark_suffix_with_optional_y_consonant() {
 665             int v_1;
 666             int v_2;
 667             int v_3;
 668             int v_4;
 669             int v_5;
 670             int v_6;
 671             int v_7;
 672             // (, line 153
 673             // or, line 155
 674             lab0: do {
 675                 v_1 = limit - cursor;
 676                 lab1: do {
 677                     // (, line 154
 678                     // (, line 154
 679                     // test, line 154
 680                     v_2 = limit - cursor;
 681                     // literal, line 154
 682                     if (!(eq_s_b(1, "y")))
 683                     {
 684                         break lab1;
 685                     }
 686                     cursor = limit - v_2;
 687                     // next, line 154
 688                     if (cursor <= limit_backward)
 689                     {
 690                         break lab1;
 691                     }
 692                     cursor--;
 693                     // (, line 154
 694                     // test, line 154
 695                     v_3 = limit - cursor;
 696                     if (!(in_grouping_b(g_vowel, 97, 305)))
 697                     {
 698                         break lab1;
 699                     }
 700                     cursor = limit - v_3;
 701                     break lab0;
 702                 } while (false);
 703                 cursor = limit - v_1;
 704                 // (, line 156
 705                 // (, line 156
 706                 // not, line 156
 707                 {
 708                     v_4 = limit - cursor;
 709                     lab2: do {
 710                         // (, line 156
 711                         // test, line 156
 712                         v_5 = limit - cursor;
 713                         // literal, line 156
 714                         if (!(eq_s_b(1, "y")))
 715                         {
 716                             break lab2;
 717                         }
 718                         cursor = limit - v_5;
 719                         return false;
 720                     } while (false);
 721                     cursor = limit - v_4;
 722                 }
 723                 // test, line 156
 724                 v_6 = limit - cursor;
 725                 // (, line 156
 726                 // next, line 156
 727                 if (cursor <= limit_backward)
 728                 {
 729                     return false;
 730                 }
 731                 cursor--;
 732                 // (, line 156
 733                 // test, line 156
 734                 v_7 = limit - cursor;
 735                 if (!(in_grouping_b(g_vowel, 97, 305)))
 736                 {
 737                     return false;
 738                 }
 739                 cursor = limit - v_7;
 740                 cursor = limit - v_6;
 741             } while (false);
 742             return true;
 743         }
 744
 745         private boolean r_mark_suffix_with_optional_U_vowel() {
 746             int v_1;
 747             int v_2;
 748             int v_3;
 749             int v_4;
 750             int v_5;
 751             int v_6;
 752             int v_7;
 753             // (, line 159
 754             // or, line 161
 755             lab0: do {
 756                 v_1 = limit - cursor;
 757                 lab1: do {
 758                     // (, line 160
 759                     // (, line 160
 760                     // test, line 160
 761                     v_2 = limit - cursor;
 762                     if (!(in_grouping_b(g_U, 105, 305)))
 763                     {
 764                         break lab1;
 765                     }
 766                     cursor = limit - v_2;
 767                     // next, line 160
 768                     if (cursor <= limit_backward)
 769                     {
 770                         break lab1;
 771                     }
 772                     cursor--;
 773                     // (, line 160
 774                     // test, line 160
 775                     v_3 = limit - cursor;
 776                     if (!(out_grouping_b(g_vowel, 97, 305)))
 777                     {
 778                         break lab1;
 779                     }
 780                     cursor = limit - v_3;
 781                     break lab0;
 782                 } while (false);
 783                 cursor = limit - v_1;
 784                 // (, line 162
 785                 // (, line 162
 786                 // not, line 162
 787                 {
 788                     v_4 = limit - cursor;
 789                     lab2: do {
 790                         // (, line 162
 791                         // test, line 162
 792                         v_5 = limit - cursor;
 793                         if (!(in_grouping_b(g_U, 105, 305)))
 794                         {
 795                             break lab2;
 796                         }
 797                         cursor = limit - v_5;
 798                         return false;
 799                     } while (false);
 800                     cursor = limit - v_4;
 801                 }
 802                 // test, line 162
 803                 v_6 = limit - cursor;
 804                 // (, line 162
 805                 // next, line 162
 806                 if (cursor <= limit_backward)
 807                 {
 808                     return false;
 809                 }
 810                 cursor--;
 811                 // (, line 162
 812                 // test, line 162
 813                 v_7 = limit - cursor;
 814                 if (!(out_grouping_b(g_vowel, 97, 305)))
 815                 {
 816                     return false;
 817                 }
 818                 cursor = limit - v_7;
 819                 cursor = limit - v_6;
 820             } while (false);
 821             return true;
 822         }
 823
 824         private boolean r_mark_possessives() {
 825             // (, line 166
 826             // among, line 167
 827             if (find_among_b(a_0, 10) == 0)
 828             {
 829                 return false;
 830             }
 831             // (, line 169
 832             // call mark_suffix_with_optional_U_vowel, line 169
 833             if (!r_mark_suffix_with_optional_U_vowel())
 834             {
 835                 return false;
 836             }
 837             return true;
 838         }
 839
 840         private boolean r_mark_sU() {
 841             // (, line 172
 842             // call check_vowel_harmony, line 173
 843             if (!r_check_vowel_harmony())
 844             {
 845                 return false;
 846             }
 847             if (!(in_grouping_b(g_U, 105, 305)))
 848             {
 849                 return false;
 850             }
 851             // (, line 175
 852             // call mark_suffix_with_optional_s_consonant, line 175
 853             if (!r_mark_suffix_with_optional_s_consonant())
 854             {
 855                 return false;
 856             }
 857             return true;
 858         }
 859
 860         private boolean r_mark_lArI() {
 861             // (, line 178
 862             // among, line 179
 863             if (find_among_b(a_1, 2) == 0)
 864             {
 865                 return false;
 866             }
 867             return true;
 868         }
 869
 870         private boolean r_mark_yU() {
 871             // (, line 182
 872             // call check_vowel_harmony, line 183
 873             if (!r_check_vowel_harmony())
 874             {
 875                 return false;
 876             }
 877             if (!(in_grouping_b(g_U, 105, 305)))
 878             {
 879                 return false;
 880             }
 881             // (, line 185
 882             // call mark_suffix_with_optional_y_consonant, line 185
 883             if (!r_mark_suffix_with_optional_y_consonant())
 884             {
 885                 return false;
 886             }
 887             return true;
 888         }
 889
 890         private boolean r_mark_nU() {
 891             // (, line 188
 892             // call check_vowel_harmony, line 189
 893             if (!r_check_vowel_harmony())
 894             {
 895                 return false;
 896             }
 897             // among, line 190
 898             if (find_among_b(a_2, 4) == 0)
 899             {
 900                 return false;
 901             }
 902             return true;
 903         }
 904
 905         private boolean r_mark_nUn() {
 906             // (, line 193
 907             // call check_vowel_harmony, line 194
 908             if (!r_check_vowel_harmony())
 909             {
 910                 return false;
 911             }
 912             // among, line 195
 913             if (find_among_b(a_3, 4) == 0)
 914             {
 915                 return false;
 916             }
 917             // (, line 196
 918             // call mark_suffix_with_optional_n_consonant, line 196
 919             if (!r_mark_suffix_with_optional_n_consonant())
 920             {
 921                 return false;
 922             }
 923             return true;
 924         }
 925
 926         private boolean r_mark_yA() {
 927             // (, line 199
 928             // call check_vowel_harmony, line 200
 929             if (!r_check_vowel_harmony())
 930             {
 931                 return false;
 932             }
 933             // among, line 201
 934             if (find_among_b(a_4, 2) == 0)
 935             {
 936                 return false;
 937             }
 938             // (, line 202
 939             // call mark_suffix_with_optional_y_consonant, line 202
 940             if (!r_mark_suffix_with_optional_y_consonant())
 941             {
 942                 return false;
 943             }
 944             return true;
 945         }
 946
 947         private boolean r_mark_nA() {
 948             // (, line 205
 949             // call check_vowel_harmony, line 206
 950             if (!r_check_vowel_harmony())
 951             {
 952                 return false;
 953             }
 954             // among, line 207
 955             if (find_among_b(a_5, 2) == 0)
 956             {
 957                 return false;
 958             }
 959             return true;
 960         }
 961
 962         private boolean r_mark_DA() {
 963             // (, line 210
 964             // call check_vowel_harmony, line 211
 965             if (!r_check_vowel_harmony())
 966             {
 967                 return false;
 968             }
 969             // among, line 212
 970             if (find_among_b(a_6, 4) == 0)
 971             {
 972                 return false;
 973             }
 974             return true;
 975         }
 976
 977         private boolean r_mark_ndA() {
 978             // (, line 215
 979             // call check_vowel_harmony, line 216
 980             if (!r_check_vowel_harmony())
 981             {
 982                 return false;
 983             }
 984             // among, line 217
 985             if (find_among_b(a_7, 2) == 0)
 986             {
 987                 return false;
 988             }
 989             return true;
 990         }
 991
 992         private boolean r_mark_DAn() {
 993             // (, line 220
 994             // call check_vowel_harmony, line 221
 995             if (!r_check_vowel_harmony())
 996             {
 997                 return false;
 998             }
 999             // among, line 222
1000             if (find_among_b(a_8, 4) == 0)
1001             {
1002                 return false;
1003             }
1004             return true;
1005         }
1006
1007         private boolean r_mark_ndAn() {
1008             // (, line 225
1009             // call check_vowel_harmony, line 226
1010             if (!r_check_vowel_harmony())
1011             {
1012                 return false;
1013             }
1014             // among, line 227
1015             if (find_among_b(a_9, 2) == 0)
1016             {
1017                 return false;
1018             }
1019             return true;
1020         }
1021
1022         private boolean r_mark_ylA() {
1023             // (, line 230
1024             // call check_vowel_harmony, line 231
1025             if (!r_check_vowel_harmony())
1026             {
1027                 return false;
1028             }
1029             // among, line 232
1030             if (find_among_b(a_10, 2) == 0)
1031             {
1032                 return false;
1033             }
1034             // (, line 233
1035             // call mark_suffix_with_optional_y_consonant, line 233
1036             if (!r_mark_suffix_with_optional_y_consonant())
1037             {
1038                 return false;
1039             }
1040             return true;
1041         }
1042
1043         private boolean r_mark_ki() {
1044             // (, line 236
1045             // literal, line 237
1046             if (!(eq_s_b(2, "ki")))
1047             {
1048                 return false;
1049             }
1050             return true;
1051         }
1052
1053         private boolean r_mark_ncA() {
1054             // (, line 240
1055             // call check_vowel_harmony, line 241
1056             if (!r_check_vowel_harmony())
1057             {
1058                 return false;
1059             }
1060             // among, line 242
1061             if (find_among_b(a_11, 2) == 0)
1062             {
1063                 return false;
1064             }
1065             // (, line 243
1066             // call mark_suffix_with_optional_n_consonant, line 243
1067             if (!r_mark_suffix_with_optional_n_consonant())
1068             {
1069                 return false;
1070             }
1071             return true;
1072         }
1073
1074         private boolean r_mark_yUm() {
1075             // (, line 246
1076             // call check_vowel_harmony, line 247
1077             if (!r_check_vowel_harmony())
1078             {
1079                 return false;
1080             }
1081             // among, line 248
1082             if (find_among_b(a_12, 4) == 0)
1083             {
1084                 return false;
1085             }
1086             // (, line 249
1087             // call mark_suffix_with_optional_y_consonant, line 249
1088             if (!r_mark_suffix_with_optional_y_consonant())
1089             {
1090                 return false;
1091             }
1092             return true;
1093         }
1094
1095         private boolean r_mark_sUn() {
1096             // (, line 252
1097             // call check_vowel_harmony, line 253
1098             if (!r_check_vowel_harmony())
1099             {
1100                 return false;
1101             }
1102             // among, line 254
1103             if (find_among_b(a_13, 4) == 0)
1104             {
1105                 return false;
1106             }
1107             return true;
1108         }
1109
1110         private boolean r_mark_yUz() {
1111             // (, line 257
1112             // call check_vowel_harmony, line 258
1113             if (!r_check_vowel_harmony())
1114             {
1115                 return false;
1116             }
1117             // among, line 259
1118             if (find_among_b(a_14, 4) == 0)
1119             {
1120                 return false;
1121             }
1122             // (, line 260
1123             // call mark_suffix_with_optional_y_consonant, line 260
1124             if (!r_mark_suffix_with_optional_y_consonant())
1125             {
1126                 return false;
1127             }
1128             return true;
1129         }
1130
1131         private boolean r_mark_sUnUz() {
1132             // (, line 263
1133             // among, line 264
1134             if (find_among_b(a_15, 4) == 0)
1135             {
1136                 return false;
1137             }
1138             return true;
1139         }
1140
1141         private boolean r_mark_lAr() {
1142             // (, line 267
1143             // call check_vowel_harmony, line 268
1144             if (!r_check_vowel_harmony())
1145             {
1146                 return false;
1147             }
1148             // among, line 269
1149             if (find_among_b(a_16, 2) == 0)
1150             {
1151                 return false;
1152             }
1153             return true;
1154         }
1155
1156         private boolean r_mark_nUz() {
1157             // (, line 272
1158             // call check_vowel_harmony, line 273
1159             if (!r_check_vowel_harmony())
1160             {
1161                 return false;
1162             }
1163             // among, line 274
1164             if (find_among_b(a_17, 4) == 0)
1165             {
1166                 return false;
1167             }
1168             return true;
1169         }
1170
1171         private boolean r_mark_DUr() {
1172             // (, line 277
1173             // call check_vowel_harmony, line 278
1174             if (!r_check_vowel_harmony())
1175             {
1176                 return false;
1177             }
1178             // among, line 279
1179             if (find_among_b(a_18, 8) == 0)
1180             {
1181                 return false;
1182             }
1183             return true;
1184         }
1185
1186         private boolean r_mark_cAsInA() {
1187             // (, line 282
1188             // among, line 283
1189             if (find_among_b(a_19, 2) == 0)
1190             {
1191                 return false;
1192             }
1193             return true;
1194         }
1195
1196         private boolean r_mark_yDU() {
1197             // (, line 286
1198             // call check_vowel_harmony, line 287
1199             if (!r_check_vowel_harmony())
1200             {
1201                 return false;
1202             }
1203             // among, line 288
1204             if (find_among_b(a_20, 32) == 0)
1205             {
1206                 return false;
1207             }
1208             // (, line 292
1209             // call mark_suffix_with_optional_y_consonant, line 292
1210             if (!r_mark_suffix_with_optional_y_consonant())
1211             {
1212                 return false;
1213             }
1214             return true;
1215         }
1216
1217         private boolean r_mark_ysA() {
1218             // (, line 296
1219             // among, line 297
1220             if (find_among_b(a_21, 8) == 0)
1221             {
1222                 return false;
1223             }
1224             // (, line 298
1225             // call mark_suffix_with_optional_y_consonant, line 298
1226             if (!r_mark_suffix_with_optional_y_consonant())
1227             {
1228                 return false;
1229             }
1230             return true;
1231         }
1232
1233         private boolean r_mark_ymUs_() {
1234             // (, line 301
1235             // call check_vowel_harmony, line 302
1236             if (!r_check_vowel_harmony())
1237             {
1238                 return false;
1239             }
1240             // among, line 303
1241             if (find_among_b(a_22, 4) == 0)
1242             {
1243                 return false;
1244             }
1245             // (, line 304
1246             // call mark_suffix_with_optional_y_consonant, line 304
1247             if (!r_mark_suffix_with_optional_y_consonant())
1248             {
1249                 return false;
1250             }
1251             return true;
1252         }
1253
1254         private boolean r_mark_yken() {
1255             // (, line 307
1256             // literal, line 308
1257             if (!(eq_s_b(3, "ken")))
1258             {
1259                 return false;
1260             }
1261             // (, line 308
1262             // call mark_suffix_with_optional_y_consonant, line 308
1263             if (!r_mark_suffix_with_optional_y_consonant())
1264             {
1265                 return false;
1266             }
1267             return true;
1268         }
1269
1270         private boolean r_stem_nominal_verb_suffixes() {
1271             int v_1;
1272             int v_2;
1273             int v_3;
1274             int v_4;
1275             int v_5;
1276             int v_6;
1277             int v_7;
1278             int v_8;
1279             int v_9;
1280             int v_10;
1281             // (, line 311
1282             // [, line 312
1283             ket = cursor;
1284             // set continue_stemming_noun_suffixes, line 313
1285             B_continue_stemming_noun_suffixes = true;
1286             // or, line 315
1287             lab0: do {
1288                 v_1 = limit - cursor;
1289                 lab1: do {
1290                     // (, line 314
1291                     // or, line 314
1292                     lab2: do {
1293                         v_2 = limit - cursor;
1294                         lab3: do {
1295                             // call mark_ymUs_, line 314
1296                             if (!r_mark_ymUs_())
1297                             {
1298                                 break lab3;
1299                             }
1300                             break lab2;
1301                         } while (false);
1302                         cursor = limit - v_2;
1303                         lab4: do {
1304                             // call mark_yDU, line 314
1305                             if (!r_mark_yDU())
1306                             {
1307                                 break lab4;
1308                             }
1309                             break lab2;
1310                         } while (false);
1311                         cursor = limit - v_2;
1312                         lab5: do {
1313                             // call mark_ysA, line 314
1314                             if (!r_mark_ysA())
1315                             {
1316                                 break lab5;
1317                             }
1318                             break lab2;
1319                         } while (false);
1320                         cursor = limit - v_2;
1321                         // call mark_yken, line 314
1322                         if (!r_mark_yken())
1323                         {
1324                             break lab1;
1325                         }
1326                     } while (false);
1327                     break lab0;
1328                 } while (false);
1329                 cursor = limit - v_1;
1330                 lab6: do {
1331                     // (, line 316
1332                     // call mark_cAsInA, line 316
1333                     if (!r_mark_cAsInA())
1334                     {
1335                         break lab6;
1336                     }
1337                     // (, line 316
1338                     // or, line 316
1339                     lab7: do {
1340                         v_3 = limit - cursor;
1341                         lab8: do {
1342                             // call mark_sUnUz, line 316
1343                             if (!r_mark_sUnUz())
1344                             {
1345                                 break lab8;
1346                             }
1347                             break lab7;
1348                         } while (false);
1349                         cursor = limit - v_3;
1350                         lab9: do {
1351                             // call mark_lAr, line 316
1352                             if (!r_mark_lAr())
1353                             {
1354                                 break lab9;
1355                             }
1356                             break lab7;
1357                         } while (false);
1358                         cursor = limit - v_3;
1359                         lab10: do {
1360                             // call mark_yUm, line 316
1361                             if (!r_mark_yUm())
1362                             {
1363                                 break lab10;
1364                             }
1365                             break lab7;
1366                         } while (false);
1367                         cursor = limit - v_3;
1368                         lab11: do {
1369                             // call mark_sUn, line 316
1370                             if (!r_mark_sUn())
1371                             {
1372                                 break lab11;
1373                             }
1374                             break lab7;
1375                         } while (false);
1376                         cursor = limit - v_3;
1377                         lab12: do {
1378                             // call mark_yUz, line 316
1379                             if (!r_mark_yUz())
1380                             {
1381                                 break lab12;
1382                             }
1383                             break lab7;
1384                         } while (false);
1385                         cursor = limit - v_3;
1386                     } while (false);
1387                     // call mark_ymUs_, line 316
1388                     if (!r_mark_ymUs_())
1389                     {
1390                         break lab6;
1391                     }
1392                     break lab0;
1393                 } while (false);
1394                 cursor = limit - v_1;
1395                 lab13: do {
1396                     // (, line 318
1397                     // call mark_lAr, line 319
1398                     if (!r_mark_lAr())
1399                     {
1400                         break lab13;
1401                     }
1402                     // ], line 319
1403                     bra = cursor;
1404                     // delete, line 319
1405                     slice_del();
1406                     // try, line 319
1407                     v_4 = limit - cursor;
1408                     lab14: do {
1409                         // (, line 319
1410                         // [, line 319
1411                         ket = cursor;
1412                         // (, line 319
1413                         // or, line 319
1414                         lab15: do {
1415                             v_5 = limit - cursor;
1416                             lab16: do {
1417                                 // call mark_DUr, line 319
1418                                 if (!r_mark_DUr())
1419                                 {
1420                                     break lab16;
1421                                 }
1422                                 break lab15;
1423                             } while (false);
1424                             cursor = limit - v_5;
1425                             lab17: do {
1426                                 // call mark_yDU, line 319
1427                                 if (!r_mark_yDU())
1428                                 {
1429                                     break lab17;
1430                                 }
1431                                 break lab15;
1432                             } while (false);
1433                             cursor = limit - v_5;
1434                             lab18: do {
1435                                 // call mark_ysA, line 319
1436                                 if (!r_mark_ysA())
1437                                 {
1438                                     break lab18;
1439                                 }
1440                                 break lab15;
1441                             } while (false);
1442                             cursor = limit - v_5;
1443                             // call mark_ymUs_, line 319
1444                             if (!r_mark_ymUs_())
1445                             {
1446                                 cursor = limit - v_4;
1447                                 break lab14;
1448                             }
1449                         } while (false);
1450                     } while (false);
1451                     // unset continue_stemming_noun_suffixes, line 320
1452                     B_continue_stemming_noun_suffixes = false;
1453                     break lab0;
1454                 } while (false);
1455                 cursor = limit - v_1;
1456                 lab19: do {
1457                     // (, line 323
1458                     // call mark_nUz, line 323
1459                     if (!r_mark_nUz())
1460                     {
1461                         break lab19;
1462                     }
1463                     // (, line 323
1464                     // or, line 323
1465                     lab20: do {
1466                         v_6 = limit - cursor;
1467                         lab21: do {
1468                             // call mark_yDU, line 323
1469                             if (!r_mark_yDU())
1470                             {
1471                                 break lab21;
1472                             }
1473                             break lab20;
1474                         } while (false);
1475                         cursor = limit - v_6;
1476                         // call mark_ysA, line 323
1477                         if (!r_mark_ysA())
1478                         {
1479                             break lab19;
1480                         }
1481                     } while (false);
1482                     break lab0;
1483                 } while (false);
1484                 cursor = limit - v_1;
1485                 lab22: do {
1486                     // (, line 325
1487                     // (, line 325
1488                     // or, line 325
1489                     lab23: do {
1490                         v_7 = limit - cursor;
1491                         lab24: do {
1492                             // call mark_sUnUz, line 325
1493                             if (!r_mark_sUnUz())
1494                             {
1495                                 break lab24;
1496                             }
1497                             break lab23;
1498                         } while (false);
1499                         cursor = limit - v_7;
1500                         lab25: do {
1501                             // call mark_yUz, line 325
1502                             if (!r_mark_yUz())
1503                             {
1504                                 break lab25;
1505                             }
1506                             break lab23;
1507                         } while (false);
1508                         cursor = limit - v_7;
1509                         lab26: do {
1510                             // call mark_sUn, line 325
1511                             if (!r_mark_sUn())
1512                             {
1513                                 break lab26;
1514                             }
1515                             break lab23;
1516                         } while (false);
1517                         cursor = limit - v_7;
1518                         // call mark_yUm, line 325
1519                         if (!r_mark_yUm())
1520                         {
1521                             break lab22;
1522                         }
1523                     } while (false);
1524                     // ], line 325
1525                     bra = cursor;
1526                     // delete, line 325
1527                     slice_del();
1528                     // try, line 325
1529                     v_8 = limit - cursor;
1530                     lab27: do {
1531                         // (, line 325
1532                         // [, line 325
1533                         ket = cursor;
1534                         // call mark_ymUs_, line 325
1535                         if (!r_mark_ymUs_())
1536                         {
1537                             cursor = limit - v_8;
1538                             break lab27;
1539                         }
1540                     } while (false);
1541                     break lab0;
1542                 } while (false);
1543                 cursor = limit - v_1;
1544                 // (, line 327
1545                 // call mark_DUr, line 327
1546                 if (!r_mark_DUr())
1547                 {
1548                     return false;
1549                 }
1550                 // ], line 327
1551                 bra = cursor;
1552                 // delete, line 327
1553                 slice_del();
1554                 // try, line 327
1555                 v_9 = limit - cursor;
1556                 lab28: do {
1557                     // (, line 327
1558                     // [, line 327
1559                     ket = cursor;
1560                     // (, line 327
1561                     // or, line 327
1562                     lab29: do {
1563                         v_10 = limit - cursor;
1564                         lab30: do {
1565                             // call mark_sUnUz, line 327
1566                             if (!r_mark_sUnUz())
1567                             {
1568                                 break lab30;
1569                             }
1570                             break lab29;
1571                         } while (false);
1572                         cursor = limit - v_10;
1573                         lab31: do {
1574                             // call mark_lAr, line 327
1575                             if (!r_mark_lAr())
1576                             {
1577                                 break lab31;
1578                             }
1579                             break lab29;
1580                         } while (false);
1581                         cursor = limit - v_10;
1582                         lab32: do {
1583                             // call mark_yUm, line 327
1584                             if (!r_mark_yUm())
1585                             {
1586                                 break lab32;
1587                             }
1588                             break lab29;
1589                         } while (false);
1590                         cursor = limit - v_10;
1591                         lab33: do {
1592                             // call mark_sUn, line 327
1593                             if (!r_mark_sUn())
1594                             {
1595                                 break lab33;
1596                             }
1597                             break lab29;
1598                         } while (false);
1599                         cursor = limit - v_10;
1600                         lab34: do {
1601                             // call mark_yUz, line 327
1602                             if (!r_mark_yUz())
1603                             {
1604                                 break lab34;
1605                             }
1606                             break lab29;
1607                         } while (false);
1608                         cursor = limit - v_10;
1609                     } while (false);
1610                     // call mark_ymUs_, line 327
1611                     if (!r_mark_ymUs_())
1612                     {
1613                         cursor = limit - v_9;
1614                         break lab28;
1615                     }
1616                 } while (false);
1617             } while (false);
1618             // ], line 328
1619             bra = cursor;
1620             // delete, line 328
1621             slice_del();
1622             return true;
1623         }
1624
1625         private boolean r_stem_suffix_chain_before_ki() {
1626             int v_1;
1627             int v_2;
1628             int v_3;
1629             int v_4;
1630             int v_5;
1631             int v_6;
1632             int v_7;
1633             int v_8;
1634             int v_9;
1635             int v_10;
1636             int v_11;
1637             // (, line 332
1638             // [, line 333
1639             ket = cursor;
1640             // call mark_ki, line 334
1641             if (!r_mark_ki())
1642             {
1643                 return false;
1644             }
1645             // (, line 335
1646             // or, line 342
1647             lab0: do {
1648                 v_1 = limit - cursor;
1649                 lab1: do {
1650                     // (, line 336
1651                     // call mark_DA, line 336
1652                     if (!r_mark_DA())
1653                     {
1654                         break lab1;
1655                     }
1656                     // ], line 336
1657                     bra = cursor;
1658                     // delete, line 336
1659                     slice_del();
1660                     // try, line 336
1661                     v_2 = limit - cursor;
1662                     lab2: do {
1663                         // (, line 336
1664                         // [, line 336
1665                         ket = cursor;
1666                         // or, line 338
1667                         lab3: do {
1668                             v_3 = limit - cursor;
1669                             lab4: do {
1670                                 // (, line 337
1671                                 // call mark_lAr, line 337
1672                                 if (!r_mark_lAr())
1673                                 {
1674                                     break lab4;
1675                                 }
1676                                 // ], line 337
1677                                 bra = cursor;
1678                                 // delete, line 337
1679                                 slice_del();
1680                                 // try, line 337
1681                                 v_4 = limit - cursor;
1682                                 lab5: do {
1683                                     // (, line 337
1684                                     // call stem_suffix_chain_before_ki, line 337
1685                                     if (!r_stem_suffix_chain_before_ki())
1686                                     {
1687                                         cursor = limit - v_4;
1688                                         break lab5;
1689                                     }
1690                                 } while (false);
1691                                 break lab3;
1692                             } while (false);
1693                             cursor = limit - v_3;
1694                             // (, line 339
1695                             // call mark_possessives, line 339
1696                             if (!r_mark_possessives())
1697                             {
1698                                 cursor = limit - v_2;
1699                                 break lab2;
1700                             }
1701                             // ], line 339
1702                             bra = cursor;
1703                             // delete, line 339
1704                             slice_del();
1705                             // try, line 339
1706                             v_5 = limit - cursor;
1707                             lab6: do {
1708                                 // (, line 339
1709                                 // [, line 339
1710                                 ket = cursor;
1711                                 // call mark_lAr, line 339
1712                                 if (!r_mark_lAr())
1713                                 {
1714                                     cursor = limit - v_5;
1715                                     break lab6;
1716                                 }
1717                                 // ], line 339
1718                                 bra = cursor;
1719                                 // delete, line 339
1720                                 slice_del();
1721                                 // call stem_suffix_chain_before_ki, line 339
1722                                 if (!r_stem_suffix_chain_before_ki())
1723                                 {
1724                                     cursor = limit - v_5;
1725                                     break lab6;
1726                                 }
1727                             } while (false);
1728                         } while (false);
1729                     } while (false);
1730                     break lab0;
1731                 } while (false);
1732                 cursor = limit - v_1;
1733                 lab7: do {
1734                     // (, line 343
1735                     // call mark_nUn, line 343
1736                     if (!r_mark_nUn())
1737                     {
1738                         break lab7;
1739                     }
1740                     // ], line 343
1741                     bra = cursor;
1742                     // delete, line 343
1743                     slice_del();
1744                     // try, line 343
1745                     v_6 = limit - cursor;
1746                     lab8: do {
1747                         // (, line 343
1748                         // [, line 343
1749                         ket = cursor;
1750                         // or, line 345
1751                         lab9: do {
1752                             v_7 = limit - cursor;
1753                             lab10: do {
1754                                 // (, line 344
1755                                 // call mark_lArI, line 344
1756                                 if (!r_mark_lArI())
1757                                 {
1758                                     break lab10;
1759                                 }
1760                                 // ], line 344
1761                                 bra = cursor;
1762                                 // delete, line 344
1763                                 slice_del();
1764                                 break lab9;
1765                             } while (false);
1766                             cursor = limit - v_7;
1767                             lab11: do {
1768                                 // (, line 346
1769                                 // [, line 346
1770                                 ket = cursor;
1771                                 // or, line 346
1772                                 lab12: do {
1773                                     v_8 = limit - cursor;
1774                                     lab13: do {
1775                                         // call mark_possessives, line 346
1776                                         if (!r_mark_possessives())
1777                                         {
1778                                             break lab13;
1779                                         }
1780                                         break lab12;
1781                                     } while (false);
1782                                     cursor = limit - v_8;
1783                                     // call mark_sU, line 346
1784                                     if (!r_mark_sU())
1785                                     {
1786                                         break lab11;
1787                                     }
1788                                 } while (false);
1789                                 // ], line 346
1790                                 bra = cursor;
1791                                 // delete, line 346
1792                                 slice_del();
1793                                 // try, line 346
1794                                 v_9 = limit - cursor;
1795                                 lab14: do {
1796                                     // (, line 346
1797                                     // [, line 346
1798                                     ket = cursor;
1799                                     // call mark_lAr, line 346
1800                                     if (!r_mark_lAr())
1801                                     {
1802                                         cursor = limit - v_9;
1803                                         break lab14;
1804                                     }
1805                                     // ], line 346
1806                                     bra = cursor;
1807                                     // delete, line 346
1808                                     slice_del();
1809                                     // call stem_suffix_chain_before_ki, line 346
1810                                     if (!r_stem_suffix_chain_before_ki())
1811                                     {
1812                                         cursor = limit - v_9;
1813                                         break lab14;
1814                                     }
1815                                 } while (false);
1816                                 break lab9;
1817                             } while (false);
1818                             cursor = limit - v_7;
1819                             // (, line 348
1820                             // call stem_suffix_chain_before_ki, line 348
1821                             if (!r_stem_suffix_chain_before_ki())
1822                             {
1823                                 cursor = limit - v_6;
1824                                 break lab8;
1825                             }
1826                         } while (false);
1827                     } while (false);
1828                     break lab0;
1829                 } while (false);
1830                 cursor = limit - v_1;
1831                 // (, line 351
1832                 // call mark_ndA, line 351
1833                 if (!r_mark_ndA())
1834                 {
1835                     return false;
1836                 }
1837                 // (, line 351
1838                 // or, line 353
1839                 lab15: do {
1840                     v_10 = limit - cursor;
1841                     lab16: do {
1842                         // (, line 352
1843                         // call mark_lArI, line 352
1844                         if (!r_mark_lArI())
1845                         {
1846                             break lab16;
1847                         }
1848                         // ], line 352
1849                         bra = cursor;
1850                         // delete, line 352
1851                         slice_del();
1852                         break lab15;
1853                     } while (false);
1854                     cursor = limit - v_10;
1855                     lab17: do {
1856                         // (, line 354
1857                         // (, line 354
1858                         // call mark_sU, line 354
1859                         if (!r_mark_sU())
1860                         {
1861                             break lab17;
1862                         }
1863                         // ], line 354
1864                         bra = cursor;
1865                         // delete, line 354
1866                         slice_del();
1867                         // try, line 354
1868                         v_11 = limit - cursor;
1869                         lab18: do {
1870                             // (, line 354
1871                             // [, line 354
1872                             ket = cursor;
1873                             // call mark_lAr, line 354
1874                             if (!r_mark_lAr())
1875                             {
1876                                 cursor = limit - v_11;
1877                                 break lab18;
1878                             }
1879                             // ], line 354
1880                             bra = cursor;
1881                             // delete, line 354
1882                             slice_del();
1883                             // call stem_suffix_chain_before_ki, line 354
1884                             if (!r_stem_suffix_chain_before_ki())
1885                             {
1886                                 cursor = limit - v_11;
1887                                 break lab18;
1888                             }
1889                         } while (false);
1890                         break lab15;
1891                     } while (false);
1892                     cursor = limit - v_10;
1893                     // (, line 356
1894                     // call stem_suffix_chain_before_ki, line 356
1895                     if (!r_stem_suffix_chain_before_ki())
1896                     {
1897                         return false;
1898                     }
1899                 } while (false);
1900             } while (false);
1901             return true;
1902         }
1903
1904         private boolean r_stem_noun_suffixes() {
1905             int v_1;
1906             int v_2;
1907             int v_3;
1908             int v_4;
1909             int v_5;
1910             int v_6;
1911             int v_7;
1912             int v_8;
1913             int v_9;
1914             int v_10;
1915             int v_11;
1916             int v_12;
1917             int v_13;
1918             int v_14;
1919             int v_15;
1920             int v_16;
1921             int v_17;
1922             int v_18;
1923             int v_19;
1924             int v_20;
1925             int v_21;
1926             int v_22;
1927             int v_23;
1928             int v_24;
1929             int v_25;
1930             int v_26;
1931             int v_27;
1932             // (, line 361
1933             // or, line 363
1934             lab0: do {
1935                 v_1 = limit - cursor;
1936                 lab1: do {
1937                     // (, line 362
1938                     // [, line 362
1939                     ket = cursor;
1940                     // call mark_lAr, line 362
1941                     if (!r_mark_lAr())
1942                     {
1943                         break lab1;
1944                     }
1945                     // ], line 362
1946                     bra = cursor;
1947                     // delete, line 362
1948                     slice_del();
1949                     // try, line 362
1950                     v_2 = limit - cursor;
1951                     lab2: do {
1952                         // (, line 362
1953                         // call stem_suffix_chain_before_ki, line 362
1954                         if (!r_stem_suffix_chain_before_ki())
1955                         {
1956                             cursor = limit - v_2;
1957                             break lab2;
1958                         }
1959                     } while (false);
1960                     break lab0;
1961                 } while (false);
1962                 cursor = limit - v_1;
1963                 lab3: do {
1964                     // (, line 364
1965                     // [, line 364
1966                     ket = cursor;
1967                     // call mark_ncA, line 364
1968                     if (!r_mark_ncA())
1969                     {
1970                         break lab3;
1971                     }
1972                     // ], line 364
1973                     bra = cursor;
1974                     // delete, line 364
1975                     slice_del();
1976                     // try, line 365
1977                     v_3 = limit - cursor;
1978                     lab4: do {
1979                         // (, line 365
1980                         // or, line 367
1981                         lab5: do {
1982                             v_4 = limit - cursor;
1983                             lab6: do {
1984                                 // (, line 366
1985                                 // [, line 366
1986                                 ket = cursor;
1987                                 // call mark_lArI, line 366
1988                                 if (!r_mark_lArI())
1989                                 {
1990                                     break lab6;
1991                                 }
1992                                 // ], line 366
1993                                 bra = cursor;
1994                                 // delete, line 366
1995                                 slice_del();
1996                                 break lab5;
1997                             } while (false);
1998                             cursor = limit - v_4;
1999                             lab7: do {
2000                                 // (, line 368
2001                                 // [, line 368
2002                                 ket = cursor;
2003                                 // or, line 368
2004                                 lab8: do {
2005                                     v_5 = limit - cursor;
2006                                     lab9: do {
2007                                         // call mark_possessives, line 368
2008                                         if (!r_mark_possessives())
2009                                         {
2010                                             break lab9;
2011                                         }
2012                                         break lab8;
2013                                     } while (false);
2014                                     cursor = limit - v_5;
2015                                     // call mark_sU, line 368
2016                                     if (!r_mark_sU())
2017                                     {
2018                                         break lab7;
2019                                     }
2020                                 } while (false);
2021                                 // ], line 368
2022                                 bra = cursor;
2023                                 // delete, line 368
2024                                 slice_del();
2025                                 // try, line 368
2026                                 v_6 = limit - cursor;
2027                                 lab10: do {
2028                                     // (, line 368
2029                                     // [, line 368
2030                                     ket = cursor;
2031                                     // call mark_lAr, line 368
2032                                     if (!r_mark_lAr())
2033                                     {
2034                                         cursor = limit - v_6;
2035                                         break lab10;
2036                                     }
2037                                     // ], line 368
2038                                     bra = cursor;
2039                                     // delete, line 368
2040                                     slice_del();
2041                                     // call stem_suffix_chain_before_ki, line 368
2042                                     if (!r_stem_suffix_chain_before_ki())
2043                                     {
2044                                         cursor = limit - v_6;
2045                                         break lab10;
2046                                     }
2047                                 } while (false);
2048                                 break lab5;
2049                             } while (false);
2050                             cursor = limit - v_4;
2051                             // (, line 370
2052                             // [, line 370
2053                             ket = cursor;
2054                             // call mark_lAr, line 370
2055                             if (!r_mark_lAr())
2056                             {
2057                                 cursor = limit - v_3;
2058                                 break lab4;
2059                             }
2060                             // ], line 370
2061                             bra = cursor;
2062                             // delete, line 370
2063                             slice_del();
2064                             // call stem_suffix_chain_before_ki, line 370
2065                             if (!r_stem_suffix_chain_before_ki())
2066                             {
2067                                 cursor = limit - v_3;
2068                                 break lab4;
2069                             }
2070                         } while (false);
2071                     } while (false);
2072                     break lab0;
2073                 } while (false);
2074                 cursor = limit - v_1;
2075                 lab11: do {
2076                     // (, line 374
2077                     // [, line 374
2078                     ket = cursor;
2079                     // (, line 374
2080                     // or, line 374
2081                     lab12: do {
2082                         v_7 = limit - cursor;
2083                         lab13: do {
2084                             // call mark_ndA, line 374
2085                             if (!r_mark_ndA())
2086                             {
2087                                 break lab13;
2088                             }
2089                             break lab12;
2090                         } while (false);
2091                         cursor = limit - v_7;
2092                         // call mark_nA, line 374
2093                         if (!r_mark_nA())
2094                         {
2095                             break lab11;
2096                         }
2097                     } while (false);
2098                     // (, line 375
2099                     // or, line 377
2100                     lab14: do {
2101                         v_8 = limit - cursor;
2102                         lab15: do {
2103                             // (, line 376
2104                             // call mark_lArI, line 376
2105                             if (!r_mark_lArI())
2106                             {
2107                                 break lab15;
2108                             }
2109                             // ], line 376
2110                             bra = cursor;
2111                             // delete, line 376
2112                             slice_del();
2113                             break lab14;
2114                         } while (false);
2115                         cursor = limit - v_8;
2116                         lab16: do {
2117                             // (, line 378
2118                             // call mark_sU, line 378
2119                             if (!r_mark_sU())
2120                             {
2121                                 break lab16;
2122                             }
2123                             // ], line 378
2124                             bra = cursor;
2125                             // delete, line 378
2126                             slice_del();
2127                             // try, line 378
2128                             v_9 = limit - cursor;
2129                             lab17: do {
2130                                 // (, line 378
2131                                 // [, line 378
2132                                 ket = cursor;
2133                                 // call mark_lAr, line 378
2134                                 if (!r_mark_lAr())
2135                                 {
2136                                     cursor = limit - v_9;
2137                                     break lab17;
2138                                 }
2139                                 // ], line 378
2140                                 bra = cursor;
2141                                 // delete, line 378
2142                                 slice_del();
2143                                 // call stem_suffix_chain_before_ki, line 378
2144                                 if (!r_stem_suffix_chain_before_ki())
2145                                 {
2146                                     cursor = limit - v_9;
2147                                     break lab17;
2148                                 }
2149                             } while (false);
2150                             break lab14;
2151                         } while (false);
2152                         cursor = limit - v_8;
2153                         // (, line 380
2154                         // call stem_suffix_chain_before_ki, line 380
2155                         if (!r_stem_suffix_chain_before_ki())
2156                         {
2157                             break lab11;
2158                         }
2159                     } while (false);
2160                     break lab0;
2161                 } while (false);
2162                 cursor = limit - v_1;
2163                 lab18: do {
2164                     // (, line 384
2165                     // [, line 384
2166                     ket = cursor;
2167                     // (, line 384
2168                     // or, line 384
2169                     lab19: do {
2170                         v_10 = limit - cursor;
2171                         lab20: do {
2172                             // call mark_ndAn, line 384
2173                             if (!r_mark_ndAn())
2174                             {
2175                                 break lab20;
2176                             }
2177                             break lab19;
2178                         } while (false);
2179                         cursor = limit - v_10;
2180                         // call mark_nU, line 384
2181                         if (!r_mark_nU())
2182                         {
2183                             break lab18;
2184                         }
2185                     } while (false);
2186                     // (, line 384
2187                     // or, line 384
2188                     lab21: do {
2189                         v_11 = limit - cursor;
2190                         lab22: do {
2191                             // (, line 384
2192                             // call mark_sU, line 384
2193                             if (!r_mark_sU())
2194                             {
2195                                 break lab22;
2196                             }
2197                             // ], line 384
2198                             bra = cursor;
2199                             // delete, line 384
2200                             slice_del();
2201                             // try, line 384
2202                             v_12 = limit - cursor;
2203                             lab23: do {
2204                                 // (, line 384
2205                                 // [, line 384
2206                                 ket = cursor;
2207                                 // call mark_lAr, line 384
2208                                 if (!r_mark_lAr())
2209                                 {
2210                                     cursor = limit - v_12;
2211                                     break lab23;
2212                                 }
2213                                 // ], line 384
2214                                 bra = cursor;
2215                                 // delete, line 384
2216                                 slice_del();
2217                                 // call stem_suffix_chain_before_ki, line 384
2218                                 if (!r_stem_suffix_chain_before_ki())
2219                                 {
2220                                     cursor = limit - v_12;
2221                                     break lab23;
2222                                 }
2223                             } while (false);
2224                             break lab21;
2225                         } while (false);
2226                         cursor = limit - v_11;
2227                         // (, line 384
2228                         // call mark_lArI, line 384
2229                         if (!r_mark_lArI())
2230                         {
2231                             break lab18;
2232                         }
2233                     } while (false);
2234                     break lab0;
2235                 } while (false);
2236                 cursor = limit - v_1;
2237                 lab24: do {
2238                     // (, line 386
2239                     // [, line 386
2240                     ket = cursor;
2241                     // call mark_DAn, line 386
2242                     if (!r_mark_DAn())
2243                     {
2244                         break lab24;
2245                     }
2246                     // ], line 386
2247                     bra = cursor;
2248                     // delete, line 386
2249                     slice_del();
2250                     // try, line 386
2251                     v_13 = limit - cursor;
2252                     lab25: do {
2253                         // (, line 386
2254                         // [, line 386
2255                         ket = cursor;
2256                         // (, line 387
2257                         // or, line 389
2258                         lab26: do {
2259                             v_14 = limit - cursor;
2260                             lab27: do {
2261                                 // (, line 388
2262                                 // call mark_possessives, line 388
2263                                 if (!r_mark_possessives())
2264                                 {
2265                                     break lab27;
2266                                 }
2267                                 // ], line 388
2268                                 bra = cursor;
2269                                 // delete, line 388
2270                                 slice_del();
2271                                 // try, line 388
2272                                 v_15 = limit - cursor;
2273                                 lab28: do {
2274                                     // (, line 388
2275                                     // [, line 388
2276                                     ket = cursor;
2277                                     // call mark_lAr, line 388
2278                                     if (!r_mark_lAr())
2279                                     {
2280                                         cursor = limit - v_15;
2281                                         break lab28;
2282                                     }
2283                                     // ], line 388
2284                                     bra = cursor;
2285                                     // delete, line 388
2286                                     slice_del();
2287                                     // call stem_suffix_chain_before_ki, line 388
2288                                     if (!r_stem_suffix_chain_before_ki())
2289                                     {
2290                                         cursor = limit - v_15;
2291                                         break lab28;
2292                                     }
2293                                 } while (false);
2294                                 break lab26;
2295                             } while (false);
2296                             cursor = limit - v_14;
2297                             lab29: do {
2298                                 // (, line 390
2299                                 // call mark_lAr, line 390
2300                                 if (!r_mark_lAr())
2301                                 {
2302                                     break lab29;
2303                                 }
2304                                 // ], line 390
2305                                 bra = cursor;
2306                                 // delete, line 390
2307                                 slice_del();
2308                                 // try, line 390
2309                                 v_16 = limit - cursor;
2310                                 lab30: do {
2311                                     // (, line 390
2312                                     // call stem_suffix_chain_before_ki, line 390
2313                                     if (!r_stem_suffix_chain_before_ki())
2314                                     {
2315                                         cursor = limit - v_16;
2316                                         break lab30;
2317                                     }
2318                                 } while (false);
2319                                 break lab26;
2320                             } while (false);
2321                             cursor = limit - v_14;
2322                             // (, line 392
2323                             // call stem_suffix_chain_before_ki, line 392
2324                             if (!r_stem_suffix_chain_before_ki())
2325                             {
2326                                 cursor = limit - v_13;
2327                                 break lab25;
2328                             }
2329                         } while (false);
2330                     } while (false);
2331                     break lab0;
2332                 } while (false);
2333                 cursor = limit - v_1;
2334                 lab31: do {
2335                     // (, line 396
2336                     // [, line 396
2337                     ket = cursor;
2338                     // or, line 396
2339                     lab32: do {
2340                         v_17 = limit - cursor;
2341                         lab33: do {
2342                             // call mark_nUn, line 396
2343                             if (!r_mark_nUn())
2344                             {
2345                                 break lab33;
2346                             }
2347                             break lab32;
2348                         } while (false);
2349                         cursor = limit - v_17;
2350                         // call mark_ylA, line 396
2351                         if (!r_mark_ylA())
2352                         {
2353                             break lab31;
2354                         }
2355                     } while (false);
2356                     // ], line 396
2357                     bra = cursor;
2358                     // delete, line 396
2359                     slice_del();
2360                     // try, line 397
2361                     v_18 = limit - cursor;
2362                     lab34: do {
2363                         // (, line 397
2364                         // or, line 399
2365                         lab35: do {
2366                             v_19 = limit - cursor;
2367                             lab36: do {
2368                                 // (, line 398
2369                                 // [, line 398
2370                                 ket = cursor;
2371                                 // call mark_lAr, line 398
2372                                 if (!r_mark_lAr())
2373                                 {
2374                                     break lab36;
2375                                 }
2376                                 // ], line 398
2377                                 bra = cursor;
2378                                 // delete, line 398
2379                                 slice_del();
2380                                 // call stem_suffix_chain_before_ki, line 398
2381                                 if (!r_stem_suffix_chain_before_ki())
2382                                 {
2383                                     break lab36;
2384                                 }
2385                                 break lab35;
2386                             } while (false);
2387                             cursor = limit - v_19;
2388                             lab37: do {
2389                                 // (, line 400
2390                                 // [, line 400
2391                                 ket = cursor;
2392                                 // or, line 400
2393                                 lab38: do {
2394                                     v_20 = limit - cursor;
2395                                     lab39: do {
2396                                         // call mark_possessives, line 400
2397                                         if (!r_mark_possessives())
2398                                         {
2399                                             break lab39;
2400                                         }
2401                                         break lab38;
2402                                     } while (false);
2403                                     cursor = limit - v_20;
2404                                     // call mark_sU, line 400
2405                                     if (!r_mark_sU())
2406                                     {
2407                                         break lab37;
2408                                     }
2409                                 } while (false);
2410                                 // ], line 400
2411                                 bra = cursor;
2412                                 // delete, line 400
2413                                 slice_del();
2414                                 // try, line 400
2415                                 v_21 = limit - cursor;
2416                                 lab40: do {
2417                                     // (, line 400
2418                                     // [, line 400
2419                                     ket = cursor;
2420                                     // call mark_lAr, line 400
2421                                     if (!r_mark_lAr())
2422                                     {
2423                                         cursor = limit - v_21;
2424                                         break lab40;
2425                                     }
2426                                     // ], line 400
2427                                     bra = cursor;
2428                                     // delete, line 400
2429                                     slice_del();
2430                                     // call stem_suffix_chain_before_ki, line 400
2431                                     if (!r_stem_suffix_chain_before_ki())
2432                                     {
2433                                         cursor = limit - v_21;
2434                                         break lab40;
2435                                     }
2436                                 } while (false);
2437                                 break lab35;
2438                             } while (false);
2439                             cursor = limit - v_19;
2440                             // call stem_suffix_chain_before_ki, line 402
2441                             if (!r_stem_suffix_chain_before_ki())
2442                             {
2443                                 cursor = limit - v_18;
2444                                 break lab34;
2445                             }
2446                         } while (false);
2447                     } while (false);
2448                     break lab0;
2449                 } while (false);
2450                 cursor = limit - v_1;
2451                 lab41: do {
2452                     // (, line 406
2453                     // [, line 406
2454                     ket = cursor;
2455                     // call mark_lArI, line 406
2456                     if (!r_mark_lArI())
2457                     {
2458                         break lab41;
2459                     }
2460                     // ], line 406
2461                     bra = cursor;
2462                     // delete, line 406
2463                     slice_del();
2464                     break lab0;
2465                 } while (false);
2466                 cursor = limit - v_1;
2467                 lab42: do {
2468                     // (, line 408
2469                     // call stem_suffix_chain_before_ki, line 408
2470                     if (!r_stem_suffix_chain_before_ki())
2471                     {
2472                         break lab42;
2473                     }
2474                     break lab0;
2475                 } while (false);
2476                 cursor = limit - v_1;
2477                 lab43: do {
2478                     // (, line 410
2479                     // [, line 410
2480                     ket = cursor;
2481                     // or, line 410
2482                     lab44: do {
2483                         v_22 = limit - cursor;
2484                         lab45: do {
2485                             // call mark_DA, line 410
2486                             if (!r_mark_DA())
2487                             {
2488                                 break lab45;
2489                             }
2490                             break lab44;
2491                         } while (false);
2492                         cursor = limit - v_22;
2493                         lab46: do {
2494                             // call mark_yU, line 410
2495                             if (!r_mark_yU())
2496                             {
2497                                 break lab46;
2498                             }
2499                             break lab44;
2500                         } while (false);
2501                         cursor = limit - v_22;
2502                         // call mark_yA, line 410
2503                         if (!r_mark_yA())
2504                         {
2505                             break lab43;
2506                         }
2507                     } while (false);
2508                     // ], line 410
2509                     bra = cursor;
2510                     // delete, line 410
2511                     slice_del();
2512                     // try, line 410
2513                     v_23 = limit - cursor;
2514                     lab47: do {
2515                         // (, line 410
2516                         // [, line 410
2517                         ket = cursor;
2518                         // (, line 410
2519                         // or, line 410
2520                         lab48: do {
2521                             v_24 = limit - cursor;
2522                             lab49: do {
2523                                 // (, line 410
2524                                 // call mark_possessives, line 410
2525                                 if (!r_mark_possessives())
2526                                 {
2527                                     break lab49;
2528                                 }
2529                                 // ], line 410
2530                                 bra = cursor;
2531                                 // delete, line 410
2532                                 slice_del();
2533                                 // try, line 410
2534                                 v_25 = limit - cursor;
2535                                 lab50: do {
2536                                     // (, line 410
2537                                     // [, line 410
2538                                     ket = cursor;
2539                                     // call mark_lAr, line 410
2540                                     if (!r_mark_lAr())
2541                                     {
2542                                         cursor = limit - v_25;
2543                                         break lab50;
2544                                     }
2545                                 } while (false);
2546                                 break lab48;
2547                             } while (false);
2548                             cursor = limit - v_24;
2549                             // call mark_lAr, line 410
2550                             if (!r_mark_lAr())
2551                             {
2552                                 cursor = limit - v_23;
2553                                 break lab47;
2554                             }
2555                         } while (false);
2556                         // ], line 410
2557                         bra = cursor;
2558                         // delete, line 410
2559                         slice_del();
2560                         // [, line 410
2561                         ket = cursor;
2562                         // call stem_suffix_chain_before_ki, line 410
2563                         if (!r_stem_suffix_chain_before_ki())
2564                         {
2565                             cursor = limit - v_23;
2566                             break lab47;
2567                         }
2568                     } while (false);
2569                     break lab0;
2570                 } while (false);
2571                 cursor = limit - v_1;
2572                 // (, line 412
2573                 // [, line 412
2574                 ket = cursor;
2575                 // or, line 412
2576                 lab51: do {
2577                     v_26 = limit - cursor;
2578                     lab52: do {
2579                         // call mark_possessives, line 412
2580                         if (!r_mark_possessives())
2581                         {
2582                             break lab52;
2583                         }
2584                         break lab51;
2585                     } while (false);
2586                     cursor = limit - v_26;
2587                     // call mark_sU, line 412
2588                     if (!r_mark_sU())
2589                     {
2590                         return false;
2591                     }
2592                 } while (false);
2593                 // ], line 412
2594                 bra = cursor;
2595                 // delete, line 412
2596                 slice_del();
2597                 // try, line 412
2598                 v_27 = limit - cursor;
2599                 lab53: do {
2600                     // (, line 412
2601                     // [, line 412
2602                     ket = cursor;
2603                     // call mark_lAr, line 412
2604                     if (!r_mark_lAr())
2605                     {
2606                         cursor = limit - v_27;
2607                         break lab53;
2608                     }
2609                     // ], line 412
2610                     bra = cursor;
2611                     // delete, line 412
2612                     slice_del();
2613                     // call stem_suffix_chain_before_ki, line 412
2614                     if (!r_stem_suffix_chain_before_ki())
2615                     {
2616                         cursor = limit - v_27;
2617                         break lab53;
2618                     }
2619                 } while (false);
2620             } while (false);
2621             return true;
2622         }
2623
2624         private boolean r_post_process_last_consonants() {
2625             int among_var;
2626             // (, line 415
2627             // [, line 416
2628             ket = cursor;
2629             // substring, line 416
2630             among_var = find_among_b(a_23, 4);
2631             if (among_var == 0)
2632             {
2633                 return false;
2634             }
2635             // ], line 416
2636             bra = cursor;
2637             switch(among_var) {
2638                 case 0:
2639                     return false;
2640                 case 1:
2641                     // (, line 417
2642                     // <-, line 417
2643                     slice_from("p");
2644                     break;
2645                 case 2:
2646                     // (, line 418
2647                     // <-, line 418
2648                     slice_from("\u00E7");
2649                     break;
2650                 case 3:
2651                     // (, line 419
2652                     // <-, line 419
2653                     slice_from("t");
2654                     break;
2655                 case 4:
2656                     // (, line 420
2657                     // <-, line 420
2658                     slice_from("k");
2659                     break;
2660             }
2661             return true;
2662         }
2663
2664         private boolean r_append_U_to_stems_ending_with_d_or_g() {
2665             int v_1;
2666             int v_2;
2667             int v_3;
2668             int v_4;
2669             int v_5;
2670             int v_6;
2671             int v_7;
2672             int v_8;
2673             int v_9;
2674             int v_10;
2675             int v_11;
2676             int v_12;
2677             int v_13;
2678             int v_14;
2679             int v_15;
2680             // (, line 430
2681             // test, line 431
2682             v_1 = limit - cursor;
2683             // (, line 431
2684             // or, line 431
2685             lab0: do {
2686                 v_2 = limit - cursor;
2687                 lab1: do {
2688                     // literal, line 431
2689                     if (!(eq_s_b(1, "d")))
2690                     {
2691                         break lab1;
2692                     }
2693                     break lab0;
2694                 } while (false);
2695                 cursor = limit - v_2;
2696                 // literal, line 431
2697                 if (!(eq_s_b(1, "g")))
2698                 {
2699                     return false;
2700                 }
2701             } while (false);
2702             cursor = limit - v_1;
2703             // or, line 433
2704             lab2: do {
2705                 v_3 = limit - cursor;
2706                 lab3: do {
2707                     // (, line 432
2708                     // test, line 432
2709                     v_4 = limit - cursor;
2710                     // (, line 432
2711                     // (, line 432
2712                     // goto, line 432
2713                     golab4: while(true)
2714                     {
2715                         v_5 = limit - cursor;
2716                         lab5: do {
2717                             if (!(in_grouping_b(g_vowel, 97, 305)))
2718                             {
2719                                 break lab5;
2720                             }
2721                             cursor = limit - v_5;
2722                             break golab4;
2723                         } while (false);
2724                         cursor = limit - v_5;
2725                         if (cursor <= limit_backward)
2726                         {
2727                             break lab3;
2728                         }
2729                         cursor--;
2730                     }
2731                     // or, line 432
2732                     lab6: do {
2733                         v_6 = limit - cursor;
2734                         lab7: do {
2735                             // literal, line 432
2736                             if (!(eq_s_b(1, "a")))
2737                             {
2738                                 break lab7;
2739                             }
2740                             break lab6;
2741                         } while (false);
2742                         cursor = limit - v_6;
2743                         // literal, line 432
2744                         if (!(eq_s_b(1, "\u0131")))
2745                         {
2746                             break lab3;
2747                         }
2748                     } while (false);
2749                     cursor = limit - v_4;
2750                     // <+, line 432
2751                     {
2752                         int c = cursor;
2753                         insert(cursor, cursor, "\u0131");
2754                         cursor = c;
2755                     }
2756                     break lab2;
2757                 } while (false);
2758                 cursor = limit - v_3;
2759                 lab8: do {
2760                     // (, line 434
2761                     // test, line 434
2762                     v_7 = limit - cursor;
2763                     // (, line 434
2764                     // (, line 434
2765                     // goto, line 434
2766                     golab9: while(true)
2767                     {
2768                         v_8 = limit - cursor;
2769                         lab10: do {
2770                             if (!(in_grouping_b(g_vowel, 97, 305)))
2771                             {
2772                                 break lab10;
2773                             }
2774                             cursor = limit - v_8;
2775                             break golab9;
2776                         } while (false);
2777                         cursor = limit - v_8;
2778                         if (cursor <= limit_backward)
2779                         {
2780                             break lab8;
2781                         }
2782                         cursor--;
2783                     }
2784                     // or, line 434
2785                     lab11: do {
2786                         v_9 = limit - cursor;
2787                         lab12: do {
2788                             // literal, line 434
2789                             if (!(eq_s_b(1, "e")))
2790                             {
2791                                 break lab12;
2792                             }
2793                             break lab11;
2794                         } while (false);
2795                         cursor = limit - v_9;
2796                         // literal, line 434
2797                         if (!(eq_s_b(1, "i")))
2798                         {
2799                             break lab8;
2800                         }
2801                     } while (false);
2802                     cursor = limit - v_7;
2803                     // <+, line 434
2804                     {
2805                         int c = cursor;
2806                         insert(cursor, cursor, "i");
2807                         cursor = c;
2808                     }
2809                     break lab2;
2810                 } while (false);
2811                 cursor = limit - v_3;
2812                 lab13: do {
2813                     // (, line 436
2814                     // test, line 436
2815                     v_10 = limit - cursor;
2816                     // (, line 436
2817                     // (, line 436
2818                     // goto, line 436
2819                     golab14: while(true)
2820                     {
2821                         v_11 = limit - cursor;
2822                         lab15: do {
2823                             if (!(in_grouping_b(g_vowel, 97, 305)))
2824                             {
2825                                 break lab15;
2826                             }
2827                             cursor = limit - v_11;
2828                             break golab14;
2829                         } while (false);
2830                         cursor = limit - v_11;
2831                         if (cursor <= limit_backward)
2832                         {
2833                             break lab13;
2834                         }
2835                         cursor--;
2836                     }
2837                     // or, line 436
2838                     lab16: do {
2839                         v_12 = limit - cursor;
2840                         lab17: do {
2841                             // literal, line 436
2842                             if (!(eq_s_b(1, "o")))
2843                             {
2844                                 break lab17;
2845                             }
2846                             break lab16;
2847                         } while (false);
2848                         cursor = limit - v_12;
2849                         // literal, line 436
2850                         if (!(eq_s_b(1, "u")))
2851                         {
2852                             break lab13;
2853                         }
2854                     } while (false);
2855                     cursor = limit - v_10;
2856                     // <+, line 436
2857                     {
2858                         int c = cursor;
2859                         insert(cursor, cursor, "u");
2860                         cursor = c;
2861                     }
2862                     break lab2;
2863                 } while (false);
2864                 cursor = limit - v_3;
2865                 // (, line 438
2866                 // test, line 438
2867                 v_13 = limit - cursor;
2868                 // (, line 438
2869                 // (, line 438
2870                 // goto, line 438
2871                 golab18: while(true)
2872                 {
2873                     v_14 = limit - cursor;
2874                     lab19: do {
2875                         if (!(in_grouping_b(g_vowel, 97, 305)))
2876                         {
2877                             break lab19;
2878                         }
2879                         cursor = limit - v_14;
2880                         break golab18;
2881                     } while (false);
2882                     cursor = limit - v_14;
2883                     if (cursor <= limit_backward)
2884                     {
2885                         return false;
2886                     }
2887                     cursor--;
2888                 }
2889                 // or, line 438
2890                 lab20: do {
2891                     v_15 = limit - cursor;
2892                     lab21: do {
2893                         // literal, line 438
2894                         if (!(eq_s_b(1, "\u00F6")))
2895                         {
2896                             break lab21;
2897                         }
2898                         break lab20;
2899                     } while (false);
2900                     cursor = limit - v_15;
2901                     // literal, line 438
2902                     if (!(eq_s_b(1, "\u00FC")))
2903                     {
2904                         return false;
2905                     }
2906                 } while (false);
2907                 cursor = limit - v_13;
2908                 // <+, line 438
2909                 {
2910                     int c = cursor;
2911                     insert(cursor, cursor, "\u00FC");
2912                     cursor = c;
2913                 }
2914             } while (false);
2915             return true;
2916         }
2917
2918         private boolean r_more_than_one_syllable_word() {
2919             int v_1;
2920             int v_3;
2921             // (, line 445
2922             // test, line 446
2923             v_1 = cursor;
2924             // (, line 446
2925             // atleast, line 446
2926             {
2927                 int v_2 = 2;
2928                 // atleast, line 446
2929                 replab0: while(true)
2930                 {
2931                     v_3 = cursor;
2932                     lab1: do {
2933                         // (, line 446
2934                         // gopast, line 446
2935                         golab2: while(true)
2936                         {
2937                             lab3: do {
2938                                 if (!(in_grouping(g_vowel, 97, 305)))
2939                                 {
2940                                     break lab3;
2941                                 }
2942                                 break golab2;
2943                             } while (false);
2944                             if (cursor >= limit)
2945                             {
2946                                 break lab1;
2947                             }
2948                             cursor++;
2949                         }
2950                         v_2--;
2951                         continue replab0;
2952                     } while (false);
2953                     cursor = v_3;
2954                     break replab0;
2955                 }
2956                 if (v_2 > 0)
2957                 {
2958                     return false;
2959                 }
2960             }
2961             cursor = v_1;
2962             return true;
2963         }
2964
2965         private boolean r_is_reserved_word() {
2966             int v_1;
2967             int v_2;
2968             int v_4;
2969             // (, line 449
2970             // or, line 451
2971             lab0: do {
2972                 v_1 = cursor;
2973                 lab1: do {
2974                     // test, line 450
2975                     v_2 = cursor;
2976                     // (, line 450
2977                     // gopast, line 450
2978                     golab2: while(true)
2979                     {
2980                         lab3: do {
2981                             // literal, line 450
2982                             if (!(eq_s(2, "ad")))
2983                             {
2984                                 break lab3;
2985                             }
2986                             break golab2;
2987                         } while (false);
2988                         if (cursor >= limit)
2989                         {
2990                             break lab1;
2991                         }
2992                         cursor++;
2993                     }
2994                     // (, line 450
2995                     I_strlen = 2;
2996                     // (, line 450
2997                     if (!(I_strlen == limit))
2998                     {
2999                         break lab1;
3000                     }
3001                     cursor = v_2;
3002                     break lab0;
3003                 } while (false);
3004                 cursor = v_1;
3005                 // test, line 452
3006                 v_4 = cursor;
3007                 // (, line 452
3008                 // gopast, line 452
3009                 golab4: while(true)
3010                 {
3011                     lab5: do {
3012                         // literal, line 452
3013                         if (!(eq_s(5, "soyad")))
3014                         {
3015                             break lab5;
3016                         }
3017                         break golab4;
3018                     } while (false);
3019                     if (cursor >= limit)
3020                     {
3021                         return false;
3022                     }
3023                     cursor++;
3024                 }
3025                 // (, line 452
3026                 I_strlen = 5;
3027                 // (, line 452
3028                 if (!(I_strlen == limit))
3029                 {
3030                     return false;
3031                 }
3032                 cursor = v_4;
3033             } while (false);
3034             return true;
3035         }
3036
3037         private boolean r_postlude() {
3038             int v_1;
3039             int v_2;
3040             int v_3;
3041             // (, line 455
3042             // not, line 456
3043             {
3044                 v_1 = cursor;
3045                 lab0: do {
3046                     // (, line 456
3047                     // call is_reserved_word, line 456
3048                     if (!r_is_reserved_word())
3049                     {
3050                         break lab0;
3051                     }
3052                     return false;
3053                 } while (false);
3054                 cursor = v_1;
3055             }
3056             // backwards, line 457
3057             limit_backward = cursor; cursor = limit;
3058             // (, line 457
3059             // do, line 458
3060             v_2 = limit - cursor;
3061             lab1: do {
3062                 // call append_U_to_stems_ending_with_d_or_g, line 458
3063                 if (!r_append_U_to_stems_ending_with_d_or_g())
3064                 {
3065                     break lab1;
3066                 }
3067             } while (false);
3068             cursor = limit - v_2;
3069             // do, line 459
3070             v_3 = limit - cursor;
3071             lab2: do {
3072                 // call post_process_last_consonants, line 459
3073                 if (!r_post_process_last_consonants())
3074                 {
3075                     break lab2;
3076                 }
3077             } while (false);
3078             cursor = limit - v_3;
3079             cursor = limit_backward;            return true;
3080         }
3081
3082         public boolean stem() {
3083             int v_1;
3084             int v_2;
3085             // (, line 464
3086             // (, line 465
3087             // call more_than_one_syllable_word, line 465
3088             if (!r_more_than_one_syllable_word())
3089             {
3090                 return false;
3091             }
3092             // (, line 466
3093             // backwards, line 467
3094             limit_backward = cursor; cursor = limit;
3095             // (, line 467
3096             // do, line 468
3097             v_1 = limit - cursor;
3098             lab0: do {
3099                 // call stem_nominal_verb_suffixes, line 468
3100                 if (!r_stem_nominal_verb_suffixes())
3101                 {
3102                     break lab0;
3103                 }
3104             } while (false);
3105             cursor = limit - v_1;
3106             // Boolean test continue_stemming_noun_suffixes, line 469
3107             if (!(B_continue_stemming_noun_suffixes))
3108             {
3109                 return false;
3110             }
3111             // do, line 470
3112             v_2 = limit - cursor;
3113             lab1: do {
3114                 // call stem_noun_suffixes, line 470
3115                 if (!r_stem_noun_suffixes())
3116                 {
3117                     break lab1;
3118                 }
3119             } while (false);
3120             cursor = limit - v_2;
3121             cursor = limit_backward;            // call postlude, line 473
3122             if (!r_postlude())
3123             {
3124                 return false;
3125             }
3126             return true;
3127         }
3128
3129 }
3130