java/galago/src/org/tartarus/snowball/ext/frenchStemmer.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 frenchStemmer extends SnowballProgram {
  11
  12         private Among a_0[] = {
  13             new Among ( "col", -1, -1, "", this),
  14             new Among ( "par", -1, -1, "", this),
  15             new Among ( "tap", -1, -1, "", this)
  16         };
  17
  18         private Among a_1[] = {
  19             new Among ( "", -1, 4, "", this),
  20             new Among ( "I", 0, 1, "", this),
  21             new Among ( "U", 0, 2, "", this),
  22             new Among ( "Y", 0, 3, "", this)
  23         };
  24
  25         private Among a_2[] = {
  26             new Among ( "iqU", -1, 3, "", this),
  27             new Among ( "abl", -1, 3, "", this),
  28             new Among ( "I\u00E8r", -1, 4, "", this),
  29             new Among ( "i\u00E8r", -1, 4, "", this),
  30             new Among ( "eus", -1, 2, "", this),
  31             new Among ( "iv", -1, 1, "", this)
  32         };
  33
  34         private Among a_3[] = {
  35             new Among ( "ic", -1, 2, "", this),
  36             new Among ( "abil", -1, 1, "", this),
  37             new Among ( "iv", -1, 3, "", this)
  38         };
  39
  40         private Among a_4[] = {
  41             new Among ( "iqUe", -1, 1, "", this),
  42             new Among ( "atrice", -1, 2, "", this),
  43             new Among ( "ance", -1, 1, "", this),
  44             new Among ( "ence", -1, 5, "", this),
  45             new Among ( "logie", -1, 3, "", this),
  46             new Among ( "able", -1, 1, "", this),
  47             new Among ( "isme", -1, 1, "", this),
  48             new Among ( "euse", -1, 11, "", this),
  49             new Among ( "iste", -1, 1, "", this),
  50             new Among ( "ive", -1, 8, "", this),
  51             new Among ( "if", -1, 8, "", this),
  52             new Among ( "usion", -1, 4, "", this),
  53             new Among ( "ation", -1, 2, "", this),
  54             new Among ( "ution", -1, 4, "", this),
  55             new Among ( "ateur", -1, 2, "", this),
  56             new Among ( "iqUes", -1, 1, "", this),
  57             new Among ( "atrices", -1, 2, "", this),
  58             new Among ( "ances", -1, 1, "", this),
  59             new Among ( "ences", -1, 5, "", this),
  60             new Among ( "logies", -1, 3, "", this),
  61             new Among ( "ables", -1, 1, "", this),
  62             new Among ( "ismes", -1, 1, "", this),
  63             new Among ( "euses", -1, 11, "", this),
  64             new Among ( "istes", -1, 1, "", this),
  65             new Among ( "ives", -1, 8, "", this),
  66             new Among ( "ifs", -1, 8, "", this),
  67             new Among ( "usions", -1, 4, "", this),
  68             new Among ( "ations", -1, 2, "", this),
  69             new Among ( "utions", -1, 4, "", this),
  70             new Among ( "ateurs", -1, 2, "", this),
  71             new Among ( "ments", -1, 15, "", this),
  72             new Among ( "ements", 30, 6, "", this),
  73             new Among ( "issements", 31, 12, "", this),
  74             new Among ( "it\u00E9s", -1, 7, "", this),
  75             new Among ( "ment", -1, 15, "", this),
  76             new Among ( "ement", 34, 6, "", this),
  77             new Among ( "issement", 35, 12, "", this),
  78             new Among ( "amment", 34, 13, "", this),
  79             new Among ( "emment", 34, 14, "", this),
  80             new Among ( "aux", -1, 10, "", this),
  81             new Among ( "eaux", 39, 9, "", this),
  82             new Among ( "eux", -1, 1, "", this),
  83             new Among ( "it\u00E9", -1, 7, "", this)
  84         };
  85
  86         private Among a_5[] = {
  87             new Among ( "ira", -1, 1, "", this),
  88             new Among ( "ie", -1, 1, "", this),
  89             new Among ( "isse", -1, 1, "", this),
  90             new Among ( "issante", -1, 1, "", this),
  91             new Among ( "i", -1, 1, "", this),
  92             new Among ( "irai", 4, 1, "", this),
  93             new Among ( "ir", -1, 1, "", this),
  94             new Among ( "iras", -1, 1, "", this),
  95             new Among ( "ies", -1, 1, "", this),
  96             new Among ( "\u00EEmes", -1, 1, "", this),
  97             new Among ( "isses", -1, 1, "", this),
  98             new Among ( "issantes", -1, 1, "", this),
  99             new Among ( "\u00EEtes", -1, 1, "", this),
 100             new Among ( "is", -1, 1, "", this),
 101             new Among ( "irais", 13, 1, "", this),
 102             new Among ( "issais", 13, 1, "", this),
 103             new Among ( "irions", -1, 1, "", this),
 104             new Among ( "issions", -1, 1, "", this),
 105             new Among ( "irons", -1, 1, "", this),
 106             new Among ( "issons", -1, 1, "", this),
 107             new Among ( "issants", -1, 1, "", this),
 108             new Among ( "it", -1, 1, "", this),
 109             new Among ( "irait", 21, 1, "", this),
 110             new Among ( "issait", 21, 1, "", this),
 111             new Among ( "issant", -1, 1, "", this),
 112             new Among ( "iraIent", -1, 1, "", this),
 113             new Among ( "issaIent", -1, 1, "", this),
 114             new Among ( "irent", -1, 1, "", this),
 115             new Among ( "issent", -1, 1, "", this),
 116             new Among ( "iront", -1, 1, "", this),
 117             new Among ( "\u00EEt", -1, 1, "", this),
 118             new Among ( "iriez", -1, 1, "", this),
 119             new Among ( "issiez", -1, 1, "", this),
 120             new Among ( "irez", -1, 1, "", this),
 121             new Among ( "issez", -1, 1, "", this)
 122         };
 123
 124         private Among a_6[] = {
 125             new Among ( "a", -1, 3, "", this),
 126             new Among ( "era", 0, 2, "", this),
 127             new Among ( "asse", -1, 3, "", this),
 128             new Among ( "ante", -1, 3, "", this),
 129             new Among ( "\u00E9e", -1, 2, "", this),
 130             new Among ( "ai", -1, 3, "", this),
 131             new Among ( "erai", 5, 2, "", this),
 132             new Among ( "er", -1, 2, "", this),
 133             new Among ( "as", -1, 3, "", this),
 134             new Among ( "eras", 8, 2, "", this),
 135             new Among ( "\u00E2mes", -1, 3, "", this),
 136             new Among ( "asses", -1, 3, "", this),
 137             new Among ( "antes", -1, 3, "", this),
 138             new Among ( "\u00E2tes", -1, 3, "", this),
 139             new Among ( "\u00E9es", -1, 2, "", this),
 140             new Among ( "ais", -1, 3, "", this),
 141             new Among ( "erais", 15, 2, "", this),
 142             new Among ( "ions", -1, 1, "", this),
 143             new Among ( "erions", 17, 2, "", this),
 144             new Among ( "assions", 17, 3, "", this),
 145             new Among ( "erons", -1, 2, "", this),
 146             new Among ( "ants", -1, 3, "", this),
 147             new Among ( "\u00E9s", -1, 2, "", this),
 148             new Among ( "ait", -1, 3, "", this),
 149             new Among ( "erait", 23, 2, "", this),
 150             new Among ( "ant", -1, 3, "", this),
 151             new Among ( "aIent", -1, 3, "", this),
 152             new Among ( "eraIent", 26, 2, "", this),
 153             new Among ( "\u00E8rent", -1, 2, "", this),
 154             new Among ( "assent", -1, 3, "", this),
 155             new Among ( "eront", -1, 2, "", this),
 156             new Among ( "\u00E2t", -1, 3, "", this),
 157             new Among ( "ez", -1, 2, "", this),
 158             new Among ( "iez", 32, 2, "", this),
 159             new Among ( "eriez", 33, 2, "", this),
 160             new Among ( "assiez", 33, 3, "", this),
 161             new Among ( "erez", 32, 2, "", this),
 162             new Among ( "\u00E9", -1, 2, "", this)
 163         };
 164
 165         private Among a_7[] = {
 166             new Among ( "e", -1, 3, "", this),
 167             new Among ( "I\u00E8re", 0, 2, "", this),
 168             new Among ( "i\u00E8re", 0, 2, "", this),
 169             new Among ( "ion", -1, 1, "", this),
 170             new Among ( "Ier", -1, 2, "", this),
 171             new Among ( "ier", -1, 2, "", this),
 172             new Among ( "\u00EB", -1, 4, "", this)
 173         };
 174
 175         private Among a_8[] = {
 176             new Among ( "ell", -1, -1, "", this),
 177             new Among ( "eill", -1, -1, "", this),
 178             new Among ( "enn", -1, -1, "", this),
 179             new Among ( "onn", -1, -1, "", this),
 180             new Among ( "ett", -1, -1, "", this)
 181         };
 182
 183         private static final char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 130, 103, 8, 5 };
 184
 185         private static final char g_keep_with_s[] = {1, 65, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };
 186
 187         private int I_p2;
 188         private int I_p1;
 189         private int I_pV;
 190
 191         private void copy_from(frenchStemmer other) {
 192             I_p2 = other.I_p2;
 193             I_p1 = other.I_p1;
 194             I_pV = other.I_pV;
 195             super.copy_from(other);
 196         }
 197
 198         private boolean r_prelude() {
 199             int v_1;
 200             int v_2;
 201             int v_3;
 202             int v_4;
 203             // repeat, line 38
 204             replab0: while(true)
 205             {
 206                 v_1 = cursor;
 207                 lab1: do {
 208                     // goto, line 38
 209                     golab2: while(true)
 210                     {
 211                         v_2 = cursor;
 212                         lab3: do {
 213                             // (, line 38
 214                             // or, line 44
 215                             lab4: do {
 216                                 v_3 = cursor;
 217                                 lab5: do {
 218                                     // (, line 40
 219                                     if (!(in_grouping(g_v, 97, 251)))
 220                                     {
 221                                         break lab5;
 222                                     }
 223                                     // [, line 40
 224                                     bra = cursor;
 225                                     // or, line 40
 226                                     lab6: do {
 227                                         v_4 = cursor;
 228                                         lab7: do {
 229                                             // (, line 40
 230                                             // literal, line 40
 231                                             if (!(eq_s(1, "u")))
 232                                             {
 233                                                 break lab7;
 234                                             }
 235                                             // ], line 40
 236                                             ket = cursor;
 237                                             if (!(in_grouping(g_v, 97, 251)))
 238                                             {
 239                                                 break lab7;
 240                                             }
 241                                             // <-, line 40
 242                                             slice_from("U");
 243                                             break lab6;
 244                                         } while (false);
 245                                         cursor = v_4;
 246                                         lab8: do {
 247                                             // (, line 41
 248                                             // literal, line 41
 249                                             if (!(eq_s(1, "i")))
 250                                             {
 251                                                 break lab8;
 252                                             }
 253                                             // ], line 41
 254                                             ket = cursor;
 255                                             if (!(in_grouping(g_v, 97, 251)))
 256                                             {
 257                                                 break lab8;
 258                                             }
 259                                             // <-, line 41
 260                                             slice_from("I");
 261                                             break lab6;
 262                                         } while (false);
 263                                         cursor = v_4;
 264                                         // (, line 42
 265                                         // literal, line 42
 266                                         if (!(eq_s(1, "y")))
 267                                         {
 268                                             break lab5;
 269                                         }
 270                                         // ], line 42
 271                                         ket = cursor;
 272                                         // <-, line 42
 273                                         slice_from("Y");
 274                                     } while (false);
 275                                     break lab4;
 276                                 } while (false);
 277                                 cursor = v_3;
 278                                 lab9: do {
 279                                     // (, line 45
 280                                     // [, line 45
 281                                     bra = cursor;
 282                                     // literal, line 45
 283                                     if (!(eq_s(1, "y")))
 284                                     {
 285                                         break lab9;
 286                                     }
 287                                     // ], line 45
 288                                     ket = cursor;
 289                                     if (!(in_grouping(g_v, 97, 251)))
 290                                     {
 291                                         break lab9;
 292                                     }
 293                                     // <-, line 45
 294                                     slice_from("Y");
 295                                     break lab4;
 296                                 } while (false);
 297                                 cursor = v_3;
 298                                 // (, line 47
 299                                 // literal, line 47
 300                                 if (!(eq_s(1, "q")))
 301                                 {
 302                                     break lab3;
 303                                 }
 304                                 // [, line 47
 305                                 bra = cursor;
 306                                 // literal, line 47
 307                                 if (!(eq_s(1, "u")))
 308                                 {
 309                                     break lab3;
 310                                 }
 311                                 // ], line 47
 312                                 ket = cursor;
 313                                 // <-, line 47
 314                                 slice_from("U");
 315                             } while (false);
 316                             cursor = v_2;
 317                             break golab2;
 318                         } while (false);
 319                         cursor = v_2;
 320                         if (cursor >= limit)
 321                         {
 322                             break lab1;
 323                         }
 324                         cursor++;
 325                     }
 326                     continue replab0;
 327                 } while (false);
 328                 cursor = v_1;
 329                 break replab0;
 330             }
 331             return true;
 332         }
 333
 334         private boolean r_mark_regions() {
 335             int v_1;
 336             int v_2;
 337             int v_4;
 338             // (, line 50
 339             I_pV = limit;
 340             I_p1 = limit;
 341             I_p2 = limit;
 342             // do, line 56
 343             v_1 = cursor;
 344             lab0: do {
 345                 // (, line 56
 346                 // or, line 58
 347                 lab1: do {
 348                     v_2 = cursor;
 349                     lab2: do {
 350                         // (, line 57
 351                         if (!(in_grouping(g_v, 97, 251)))
 352                         {
 353                             break lab2;
 354                         }
 355                         if (!(in_grouping(g_v, 97, 251)))
 356                         {
 357                             break lab2;
 358                         }
 359                         // next, line 57
 360                         if (cursor >= limit)
 361                         {
 362                             break lab2;
 363                         }
 364                         cursor++;
 365                         break lab1;
 366                     } while (false);
 367                     cursor = v_2;
 368                     lab3: do {
 369                         // among, line 59
 370                         if (find_among(a_0, 3) == 0)
 371                         {
 372                             break lab3;
 373                         }
 374                         break lab1;
 375                     } while (false);
 376                     cursor = v_2;
 377                     // (, line 66
 378                     // next, line 66
 379                     if (cursor >= limit)
 380                     {
 381                         break lab0;
 382                     }
 383                     cursor++;
 384                     // gopast, line 66
 385                     golab4: while(true)
 386                     {
 387                         lab5: do {
 388                             if (!(in_grouping(g_v, 97, 251)))
 389                             {
 390                                 break lab5;
 391                             }
 392                             break golab4;
 393                         } while (false);
 394                         if (cursor >= limit)
 395                         {
 396                             break lab0;
 397                         }
 398                         cursor++;
 399                     }
 400                 } while (false);
 401                 // setmark pV, line 67
 402                 I_pV = cursor;
 403             } while (false);
 404             cursor = v_1;
 405             // do, line 69
 406             v_4 = cursor;
 407             lab6: do {
 408                 // (, line 69
 409                 // gopast, line 70
 410                 golab7: while(true)
 411                 {
 412                     lab8: do {
 413                         if (!(in_grouping(g_v, 97, 251)))
 414                         {
 415                             break lab8;
 416                         }
 417                         break golab7;
 418                     } while (false);
 419                     if (cursor >= limit)
 420                     {
 421                         break lab6;
 422                     }
 423                     cursor++;
 424                 }
 425                 // gopast, line 70
 426                 golab9: while(true)
 427                 {
 428                     lab10: do {
 429                         if (!(out_grouping(g_v, 97, 251)))
 430                         {
 431                             break lab10;
 432                         }
 433                         break golab9;
 434                     } while (false);
 435                     if (cursor >= limit)
 436                     {
 437                         break lab6;
 438                     }
 439                     cursor++;
 440                 }
 441                 // setmark p1, line 70
 442                 I_p1 = cursor;
 443                 // gopast, line 71
 444                 golab11: while(true)
 445                 {
 446                     lab12: do {
 447                         if (!(in_grouping(g_v, 97, 251)))
 448                         {
 449                             break lab12;
 450                         }
 451                         break golab11;
 452                     } while (false);
 453                     if (cursor >= limit)
 454                     {
 455                         break lab6;
 456                     }
 457                     cursor++;
 458                 }
 459                 // gopast, line 71
 460                 golab13: while(true)
 461                 {
 462                     lab14: do {
 463                         if (!(out_grouping(g_v, 97, 251)))
 464                         {
 465                             break lab14;
 466                         }
 467                         break golab13;
 468                     } while (false);
 469                     if (cursor >= limit)
 470                     {
 471                         break lab6;
 472                     }
 473                     cursor++;
 474                 }
 475                 // setmark p2, line 71
 476                 I_p2 = cursor;
 477             } while (false);
 478             cursor = v_4;
 479             return true;
 480         }
 481
 482         private boolean r_postlude() {
 483             int among_var;
 484             int v_1;
 485             // repeat, line 75
 486             replab0: while(true)
 487             {
 488                 v_1 = cursor;
 489                 lab1: do {
 490                     // (, line 75
 491                     // [, line 77
 492                     bra = cursor;
 493                     // substring, line 77
 494                     among_var = find_among(a_1, 4);
 495                     if (among_var == 0)
 496                     {
 497                         break lab1;
 498                     }
 499                     // ], line 77
 500                     ket = cursor;
 501                     switch(among_var) {
 502                         case 0:
 503                             break lab1;
 504                         case 1:
 505                             // (, line 78
 506                             // <-, line 78
 507                             slice_from("i");
 508                             break;
 509                         case 2:
 510                             // (, line 79
 511                             // <-, line 79
 512                             slice_from("u");
 513                             break;
 514                         case 3:
 515                             // (, line 80
 516                             // <-, line 80
 517                             slice_from("y");
 518                             break;
 519                         case 4:
 520                             // (, line 81
 521                             // next, line 81
 522                             if (cursor >= limit)
 523                             {
 524                                 break lab1;
 525                             }
 526                             cursor++;
 527                             break;
 528                     }
 529                     continue replab0;
 530                 } while (false);
 531                 cursor = v_1;
 532                 break replab0;
 533             }
 534             return true;
 535         }
 536
 537         private boolean r_RV() {
 538             if (!(I_pV <= cursor))
 539             {
 540                 return false;
 541             }
 542             return true;
 543         }
 544
 545         private boolean r_R1() {
 546             if (!(I_p1 <= cursor))
 547             {
 548                 return false;
 549             }
 550             return true;
 551         }
 552
 553         private boolean r_R2() {
 554             if (!(I_p2 <= cursor))
 555             {
 556                 return false;
 557             }
 558             return true;
 559         }
 560
 561         private boolean r_standard_suffix() {
 562             int among_var;
 563             int v_1;
 564             int v_2;
 565             int v_3;
 566             int v_4;
 567             int v_5;
 568             int v_6;
 569             int v_7;
 570             int v_8;
 571             int v_9;
 572             int v_10;
 573             int v_11;
 574             // (, line 91
 575             // [, line 92
 576             ket = cursor;
 577             // substring, line 92
 578             among_var = find_among_b(a_4, 43);
 579             if (among_var == 0)
 580             {
 581                 return false;
 582             }
 583             // ], line 92
 584             bra = cursor;
 585             switch(among_var) {
 586                 case 0:
 587                     return false;
 588                 case 1:
 589                     // (, line 96
 590                     // call R2, line 96
 591                     if (!r_R2())
 592                     {
 593                         return false;
 594                     }
 595                     // delete, line 96
 596                     slice_del();
 597                     break;
 598                 case 2:
 599                     // (, line 99
 600                     // call R2, line 99
 601                     if (!r_R2())
 602                     {
 603                         return false;
 604                     }
 605                     // delete, line 99
 606                     slice_del();
 607                     // try, line 100
 608                     v_1 = limit - cursor;
 609                     lab0: do {
 610                         // (, line 100
 611                         // [, line 100
 612                         ket = cursor;
 613                         // literal, line 100
 614                         if (!(eq_s_b(2, "ic")))
 615                         {
 616                             cursor = limit - v_1;
 617                             break lab0;
 618                         }
 619                         // ], line 100
 620                         bra = cursor;
 621                         // or, line 100
 622                         lab1: do {
 623                             v_2 = limit - cursor;
 624                             lab2: do {
 625                                 // (, line 100
 626                                 // call R2, line 100
 627                                 if (!r_R2())
 628                                 {
 629                                     break lab2;
 630                                 }
 631                                 // delete, line 100
 632                                 slice_del();
 633                                 break lab1;
 634                             } while (false);
 635                             cursor = limit - v_2;
 636                             // <-, line 100
 637                             slice_from("iqU");
 638                         } while (false);
 639                     } while (false);
 640                     break;
 641                 case 3:
 642                     // (, line 104
 643                     // call R2, line 104
 644                     if (!r_R2())
 645                     {
 646                         return false;
 647                     }
 648                     // <-, line 104
 649                     slice_from("log");
 650                     break;
 651                 case 4:
 652                     // (, line 107
 653                     // call R2, line 107
 654                     if (!r_R2())
 655                     {
 656                         return false;
 657                     }
 658                     // <-, line 107
 659                     slice_from("u");
 660                     break;
 661                 case 5:
 662                     // (, line 110
 663                     // call R2, line 110
 664                     if (!r_R2())
 665                     {
 666                         return false;
 667                     }
 668                     // <-, line 110
 669                     slice_from("ent");
 670                     break;
 671                 case 6:
 672                     // (, line 113
 673                     // call RV, line 114
 674                     if (!r_RV())
 675                     {
 676                         return false;
 677                     }
 678                     // delete, line 114
 679                     slice_del();
 680                     // try, line 115
 681                     v_3 = limit - cursor;
 682                     lab3: do {
 683                         // (, line 115
 684                         // [, line 116
 685                         ket = cursor;
 686                         // substring, line 116
 687                         among_var = find_among_b(a_2, 6);
 688                         if (among_var == 0)
 689                         {
 690                             cursor = limit - v_3;
 691                             break lab3;
 692                         }
 693                         // ], line 116
 694                         bra = cursor;
 695                         switch(among_var) {
 696                             case 0:
 697                                 cursor = limit - v_3;
 698                                 break lab3;
 699                             case 1:
 700                                 // (, line 117
 701                                 // call R2, line 117
 702                                 if (!r_R2())
 703                                 {
 704                                     cursor = limit - v_3;
 705                                     break lab3;
 706                                 }
 707                                 // delete, line 117
 708                                 slice_del();
 709                                 // [, line 117
 710                                 ket = cursor;
 711                                 // literal, line 117
 712                                 if (!(eq_s_b(2, "at")))
 713                                 {
 714                                     cursor = limit - v_3;
 715                                     break lab3;
 716                                 }
 717                                 // ], line 117
 718                                 bra = cursor;
 719                                 // call R2, line 117
 720                                 if (!r_R2())
 721                                 {
 722                                     cursor = limit - v_3;
 723                                     break lab3;
 724                                 }
 725                                 // delete, line 117
 726                                 slice_del();
 727                                 break;
 728                             case 2:
 729                                 // (, line 118
 730                                 // or, line 118
 731                                 lab4: do {
 732                                     v_4 = limit - cursor;
 733                                     lab5: do {
 734                                         // (, line 118
 735                                         // call R2, line 118
 736                                         if (!r_R2())
 737                                         {
 738                                             break lab5;
 739                                         }
 740                                         // delete, line 118
 741                                         slice_del();
 742                                         break lab4;
 743                                     } while (false);
 744                                     cursor = limit - v_4;
 745                                     // (, line 118
 746                                     // call R1, line 118
 747                                     if (!r_R1())
 748                                     {
 749                                         cursor = limit - v_3;
 750                                         break lab3;
 751                                     }
 752                                     // <-, line 118
 753                                     slice_from("eux");
 754                                 } while (false);
 755                                 break;
 756                             case 3:
 757                                 // (, line 120
 758                                 // call R2, line 120
 759                                 if (!r_R2())
 760                                 {
 761                                     cursor = limit - v_3;
 762                                     break lab3;
 763                                 }
 764                                 // delete, line 120
 765                                 slice_del();
 766                                 break;
 767                             case 4:
 768                                 // (, line 122
 769                                 // call RV, line 122
 770                                 if (!r_RV())
 771                                 {
 772                                     cursor = limit - v_3;
 773                                     break lab3;
 774                                 }
 775                                 // <-, line 122
 776                                 slice_from("i");
 777                                 break;
 778                         }
 779                     } while (false);
 780                     break;
 781                 case 7:
 782                     // (, line 128
 783                     // call R2, line 129
 784                     if (!r_R2())
 785                     {
 786                         return false;
 787                     }
 788                     // delete, line 129
 789                     slice_del();
 790                     // try, line 130
 791                     v_5 = limit - cursor;
 792                     lab6: do {
 793                         // (, line 130
 794                         // [, line 131
 795                         ket = cursor;
 796                         // substring, line 131
 797                         among_var = find_among_b(a_3, 3);
 798                         if (among_var == 0)
 799                         {
 800                             cursor = limit - v_5;
 801                             break lab6;
 802                         }
 803                         // ], line 131
 804                         bra = cursor;
 805                         switch(among_var) {
 806                             case 0:
 807                                 cursor = limit - v_5;
 808                                 break lab6;
 809                             case 1:
 810                                 // (, line 132
 811                                 // or, line 132
 812                                 lab7: do {
 813                                     v_6 = limit - cursor;
 814                                     lab8: do {
 815                                         // (, line 132
 816                                         // call R2, line 132
 817                                         if (!r_R2())
 818                                         {
 819                                             break lab8;
 820                                         }
 821                                         // delete, line 132
 822                                         slice_del();
 823                                         break lab7;
 824                                     } while (false);
 825                                     cursor = limit - v_6;
 826                                     // <-, line 132
 827                                     slice_from("abl");
 828                                 } while (false);
 829                                 break;
 830                             case 2:
 831                                 // (, line 133
 832                                 // or, line 133
 833                                 lab9: do {
 834                                     v_7 = limit - cursor;
 835                                     lab10: do {
 836                                         // (, line 133
 837                                         // call R2, line 133
 838                                         if (!r_R2())
 839                                         {
 840                                             break lab10;
 841                                         }
 842                                         // delete, line 133
 843                                         slice_del();
 844                                         break lab9;
 845                                     } while (false);
 846                                     cursor = limit - v_7;
 847                                     // <-, line 133
 848                                     slice_from("iqU");
 849                                 } while (false);
 850                                 break;
 851                             case 3:
 852                                 // (, line 134
 853                                 // call R2, line 134
 854                                 if (!r_R2())
 855                                 {
 856                                     cursor = limit - v_5;
 857                                     break lab6;
 858                                 }
 859                                 // delete, line 134
 860                                 slice_del();
 861                                 break;
 862                         }
 863                     } while (false);
 864                     break;
 865                 case 8:
 866                     // (, line 140
 867                     // call R2, line 141
 868                     if (!r_R2())
 869                     {
 870                         return false;
 871                     }
 872                     // delete, line 141
 873                     slice_del();
 874                     // try, line 142
 875                     v_8 = limit - cursor;
 876                     lab11: do {
 877                         // (, line 142
 878                         // [, line 142
 879                         ket = cursor;
 880                         // literal, line 142
 881                         if (!(eq_s_b(2, "at")))
 882                         {
 883                             cursor = limit - v_8;
 884                             break lab11;
 885                         }
 886                         // ], line 142
 887                         bra = cursor;
 888                         // call R2, line 142
 889                         if (!r_R2())
 890                         {
 891                             cursor = limit - v_8;
 892                             break lab11;
 893                         }
 894                         // delete, line 142
 895                         slice_del();
 896                         // [, line 142
 897                         ket = cursor;
 898                         // literal, line 142
 899                         if (!(eq_s_b(2, "ic")))
 900                         {
 901                             cursor = limit - v_8;
 902                             break lab11;
 903                         }
 904                         // ], line 142
 905                         bra = cursor;
 906                         // or, line 142
 907                         lab12: do {
 908                             v_9 = limit - cursor;
 909                             lab13: do {
 910                                 // (, line 142
 911                                 // call R2, line 142
 912                                 if (!r_R2())
 913                                 {
 914                                     break lab13;
 915                                 }
 916                                 // delete, line 142
 917                                 slice_del();
 918                                 break lab12;
 919                             } while (false);
 920                             cursor = limit - v_9;
 921                             // <-, line 142
 922                             slice_from("iqU");
 923                         } while (false);
 924                     } while (false);
 925                     break;
 926                 case 9:
 927                     // (, line 144
 928                     // <-, line 144
 929                     slice_from("eau");
 930                     break;
 931                 case 10:
 932                     // (, line 145
 933                     // call R1, line 145
 934                     if (!r_R1())
 935                     {
 936                         return false;
 937                     }
 938                     // <-, line 145
 939                     slice_from("al");
 940                     break;
 941                 case 11:
 942                     // (, line 147
 943                     // or, line 147
 944                     lab14: do {
 945                         v_10 = limit - cursor;
 946                         lab15: do {
 947                             // (, line 147
 948                             // call R2, line 147
 949                             if (!r_R2())
 950                             {
 951                                 break lab15;
 952                             }
 953                             // delete, line 147
 954                             slice_del();
 955                             break lab14;
 956                         } while (false);
 957                         cursor = limit - v_10;
 958                         // (, line 147
 959                         // call R1, line 147
 960                         if (!r_R1())
 961                         {
 962                             return false;
 963                         }
 964                         // <-, line 147
 965                         slice_from("eux");
 966                     } while (false);
 967                     break;
 968                 case 12:
 969                     // (, line 150
 970                     // call R1, line 150
 971                     if (!r_R1())
 972                     {
 973                         return false;
 974                     }
 975                     if (!(out_grouping_b(g_v, 97, 251)))
 976                     {
 977                         return false;
 978                     }
 979                     // delete, line 150
 980                     slice_del();
 981                     break;
 982                 case 13:
 983                     // (, line 155
 984                     // call RV, line 155
 985                     if (!r_RV())
 986                     {
 987                         return false;
 988                     }
 989                     // fail, line 155
 990                     // (, line 155
 991                     // <-, line 155
 992                     slice_from("ant");
 993                     return false;
 994                 case 14:
 995                     // (, line 156
 996                     // call RV, line 156
 997                     if (!r_RV())
 998                     {
 999                         return false;
1000                     }
1001                     // fail, line 156
1002                     // (, line 156
1003                     // <-, line 156
1004                     slice_from("ent");
1005                     return false;
1006                 case 15:
1007                     // (, line 158
1008                     // test, line 158
1009                     v_11 = limit - cursor;
1010                     // (, line 158
1011                     if (!(in_grouping_b(g_v, 97, 251)))
1012                     {
1013                         return false;
1014                     }
1015                     // call RV, line 158
1016                     if (!r_RV())
1017                     {
1018                         return false;
1019                     }
1020                     cursor = limit - v_11;
1021                     // fail, line 158
1022                     // (, line 158
1023                     // delete, line 158
1024                     slice_del();
1025                     return false;
1026             }
1027             return true;
1028         }
1029
1030         private boolean r_i_verb_suffix() {
1031             int among_var;
1032             int v_1;
1033             int v_2;
1034             // setlimit, line 163
1035             v_1 = limit - cursor;
1036             // tomark, line 163
1037             if (cursor < I_pV)
1038             {
1039                 return false;
1040             }
1041             cursor = I_pV;
1042             v_2 = limit_backward;
1043             limit_backward = cursor;
1044             cursor = limit - v_1;
1045             // (, line 163
1046             // [, line 164
1047             ket = cursor;
1048             // substring, line 164
1049             among_var = find_among_b(a_5, 35);
1050             if (among_var == 0)
1051             {
1052                 limit_backward = v_2;
1053                 return false;
1054             }
1055             // ], line 164
1056             bra = cursor;
1057             switch(among_var) {
1058                 case 0:
1059                     limit_backward = v_2;
1060                     return false;
1061                 case 1:
1062                     // (, line 170
1063                     if (!(out_grouping_b(g_v, 97, 251)))
1064                     {
1065                         limit_backward = v_2;
1066                         return false;
1067                     }
1068                     // delete, line 170
1069                     slice_del();
1070                     break;
1071             }
1072             limit_backward = v_2;
1073             return true;
1074         }
1075
1076         private boolean r_verb_suffix() {
1077             int among_var;
1078             int v_1;
1079             int v_2;
1080             int v_3;
1081             // setlimit, line 174
1082             v_1 = limit - cursor;
1083             // tomark, line 174
1084             if (cursor < I_pV)
1085             {
1086                 return false;
1087             }
1088             cursor = I_pV;
1089             v_2 = limit_backward;
1090             limit_backward = cursor;
1091             cursor = limit - v_1;
1092             // (, line 174
1093             // [, line 175
1094             ket = cursor;
1095             // substring, line 175
1096             among_var = find_among_b(a_6, 38);
1097             if (among_var == 0)
1098             {
1099                 limit_backward = v_2;
1100                 return false;
1101             }
1102             // ], line 175
1103             bra = cursor;
1104             switch(among_var) {
1105                 case 0:
1106                     limit_backward = v_2;
1107                     return false;
1108                 case 1:
1109                     // (, line 177
1110                     // call R2, line 177
1111                     if (!r_R2())
1112                     {
1113                         limit_backward = v_2;
1114                         return false;
1115                     }
1116                     // delete, line 177
1117                     slice_del();
1118                     break;
1119                 case 2:
1120                     // (, line 185
1121                     // delete, line 185
1122                     slice_del();
1123                     break;
1124                 case 3:
1125                     // (, line 190
1126                     // delete, line 190
1127                     slice_del();
1128                     // try, line 191
1129                     v_3 = limit - cursor;
1130                     lab0: do {
1131                         // (, line 191
1132                         // [, line 191
1133                         ket = cursor;
1134                         // literal, line 191
1135                         if (!(eq_s_b(1, "e")))
1136                         {
1137                             cursor = limit - v_3;
1138                             break lab0;
1139                         }
1140                         // ], line 191
1141                         bra = cursor;
1142                         // delete, line 191
1143                         slice_del();
1144                     } while (false);
1145                     break;
1146             }
1147             limit_backward = v_2;
1148             return true;
1149         }
1150
1151         private boolean r_residual_suffix() {
1152             int among_var;
1153             int v_1;
1154             int v_2;
1155             int v_3;
1156             int v_4;
1157             int v_5;
1158             // (, line 198
1159             // try, line 199
1160             v_1 = limit - cursor;
1161             lab0: do {
1162                 // (, line 199
1163                 // [, line 199
1164                 ket = cursor;
1165                 // literal, line 199
1166                 if (!(eq_s_b(1, "s")))
1167                 {
1168                     cursor = limit - v_1;
1169                     break lab0;
1170                 }
1171                 // ], line 199
1172                 bra = cursor;
1173                 // test, line 199
1174                 v_2 = limit - cursor;
1175                 if (!(out_grouping_b(g_keep_with_s, 97, 232)))
1176                 {
1177                     cursor = limit - v_1;
1178                     break lab0;
1179                 }
1180                 cursor = limit - v_2;
1181                 // delete, line 199
1182                 slice_del();
1183             } while (false);
1184             // setlimit, line 200
1185             v_3 = limit - cursor;
1186             // tomark, line 200
1187             if (cursor < I_pV)
1188             {
1189                 return false;
1190             }
1191             cursor = I_pV;
1192             v_4 = limit_backward;
1193             limit_backward = cursor;
1194             cursor = limit - v_3;
1195             // (, line 200
1196             // [, line 201
1197             ket = cursor;
1198             // substring, line 201
1199             among_var = find_among_b(a_7, 7);
1200             if (among_var == 0)
1201             {
1202                 limit_backward = v_4;
1203                 return false;
1204             }
1205             // ], line 201
1206             bra = cursor;
1207             switch(among_var) {
1208                 case 0:
1209                     limit_backward = v_4;
1210                     return false;
1211                 case 1:
1212                     // (, line 202
1213                     // call R2, line 202
1214                     if (!r_R2())
1215                     {
1216                         limit_backward = v_4;
1217                         return false;
1218                     }
1219                     // or, line 202
1220                     lab1: do {
1221                         v_5 = limit - cursor;
1222                         lab2: do {
1223                             // literal, line 202
1224                             if (!(eq_s_b(1, "s")))
1225                             {
1226                                 break lab2;
1227                             }
1228                             break lab1;
1229                         } while (false);
1230                         cursor = limit - v_5;
1231                         // literal, line 202
1232                         if (!(eq_s_b(1, "t")))
1233                         {
1234                             limit_backward = v_4;
1235                             return false;
1236                         }
1237                     } while (false);
1238                     // delete, line 202
1239                     slice_del();
1240                     break;
1241                 case 2:
1242                     // (, line 204
1243                     // <-, line 204
1244                     slice_from("i");
1245                     break;
1246                 case 3:
1247                     // (, line 205
1248                     // delete, line 205
1249                     slice_del();
1250                     break;
1251                 case 4:
1252                     // (, line 206
1253                     // literal, line 206
1254                     if (!(eq_s_b(2, "gu")))
1255                     {
1256                         limit_backward = v_4;
1257                         return false;
1258                     }
1259                     // delete, line 206
1260                     slice_del();
1261                     break;
1262             }
1263             limit_backward = v_4;
1264             return true;
1265         }
1266
1267         private boolean r_un_double() {
1268             int v_1;
1269             // (, line 211
1270             // test, line 212
1271             v_1 = limit - cursor;
1272             // among, line 212
1273             if (find_among_b(a_8, 5) == 0)
1274             {
1275                 return false;
1276             }
1277             cursor = limit - v_1;
1278             // [, line 212
1279             ket = cursor;
1280             // next, line 212
1281             if (cursor <= limit_backward)
1282             {
1283                 return false;
1284             }
1285             cursor--;
1286             // ], line 212
1287             bra = cursor;
1288             // delete, line 212
1289             slice_del();
1290             return true;
1291         }
1292
1293         private boolean r_un_accent() {
1294             int v_3;
1295             // (, line 215
1296             // atleast, line 216
1297             {
1298                 int v_1 = 1;
1299                 // atleast, line 216
1300                 replab0: while(true)
1301                 {
1302                     lab1: do {
1303                         if (!(out_grouping_b(g_v, 97, 251)))
1304                         {
1305                             break lab1;
1306                         }
1307                         v_1--;
1308                         continue replab0;
1309                     } while (false);
1310                     break replab0;
1311                 }
1312                 if (v_1 > 0)
1313                 {
1314                     return false;
1315                 }
1316             }
1317             // [, line 217
1318             ket = cursor;
1319             // or, line 217
1320             lab2: do {
1321                 v_3 = limit - cursor;
1322                 lab3: do {
1323                     // literal, line 217
1324                     if (!(eq_s_b(1, "\u00E9")))
1325                     {
1326                         break lab3;
1327                     }
1328                     break lab2;
1329                 } while (false);
1330                 cursor = limit - v_3;
1331                 // literal, line 217
1332                 if (!(eq_s_b(1, "\u00E8")))
1333                 {
1334                     return false;
1335                 }
1336             } while (false);
1337             // ], line 217
1338             bra = cursor;
1339             // <-, line 217
1340             slice_from("e");
1341             return true;
1342         }
1343
1344         public boolean stem() {
1345             int v_1;
1346             int v_2;
1347             int v_3;
1348             int v_4;
1349             int v_5;
1350             int v_6;
1351             int v_7;
1352             int v_8;
1353             int v_9;
1354             int v_10;
1355             int v_11;
1356             // (, line 221
1357             // do, line 223
1358             v_1 = cursor;
1359             lab0: do {
1360                 // call prelude, line 223
1361                 if (!r_prelude())
1362                 {
1363                     break lab0;
1364                 }
1365             } while (false);
1366             cursor = v_1;
1367             // do, line 224
1368             v_2 = cursor;
1369             lab1: do {
1370                 // call mark_regions, line 224
1371                 if (!r_mark_regions())
1372                 {
1373                     break lab1;
1374                 }
1375             } while (false);
1376             cursor = v_2;
1377             // backwards, line 225
1378             limit_backward = cursor; cursor = limit;
1379             // (, line 225
1380             // do, line 227
1381             v_3 = limit - cursor;
1382             lab2: do {
1383                 // (, line 227
1384                 // or, line 237
1385                 lab3: do {
1386                     v_4 = limit - cursor;
1387                     lab4: do {
1388                         // (, line 228
1389                         // and, line 233
1390                         v_5 = limit - cursor;
1391                         // (, line 229
1392                         // or, line 229
1393                         lab5: do {
1394                             v_6 = limit - cursor;
1395                             lab6: do {
1396                                 // call standard_suffix, line 229
1397                                 if (!r_standard_suffix())
1398                                 {
1399                                     break lab6;
1400                                 }
1401                                 break lab5;
1402                             } while (false);
1403                             cursor = limit - v_6;
1404                             lab7: do {
1405                                 // call i_verb_suffix, line 230
1406                                 if (!r_i_verb_suffix())
1407                                 {
1408                                     break lab7;
1409                                 }
1410                                 break lab5;
1411                             } while (false);
1412                             cursor = limit - v_6;
1413                             // call verb_suffix, line 231
1414                             if (!r_verb_suffix())
1415                             {
1416                                 break lab4;
1417                             }
1418                         } while (false);
1419                         cursor = limit - v_5;
1420                         // try, line 234
1421                         v_7 = limit - cursor;
1422                         lab8: do {
1423                             // (, line 234
1424                             // [, line 234
1425                             ket = cursor;
1426                             // or, line 234
1427                             lab9: do {
1428                                 v_8 = limit - cursor;
1429                                 lab10: do {
1430                                     // (, line 234
1431                                     // literal, line 234
1432                                     if (!(eq_s_b(1, "Y")))
1433                                     {
1434                                         break lab10;
1435                                     }
1436                                     // ], line 234
1437                                     bra = cursor;
1438                                     // <-, line 234
1439                                     slice_from("i");
1440                                     break lab9;
1441                                 } while (false);
1442                                 cursor = limit - v_8;
1443                                 // (, line 235
1444                                 // literal, line 235
1445                                 if (!(eq_s_b(1, "\u00E7")))
1446                                 {
1447                                     cursor = limit - v_7;
1448                                     break lab8;
1449                                 }
1450                                 // ], line 235
1451                                 bra = cursor;
1452                                 // <-, line 235
1453                                 slice_from("c");
1454                             } while (false);
1455                         } while (false);
1456                         break lab3;
1457                     } while (false);
1458                     cursor = limit - v_4;
1459                     // call residual_suffix, line 238
1460                     if (!r_residual_suffix())
1461                     {
1462                         break lab2;
1463                     }
1464                 } while (false);
1465             } while (false);
1466             cursor = limit - v_3;
1467             // do, line 243
1468             v_9 = limit - cursor;
1469             lab11: do {
1470                 // call un_double, line 243
1471                 if (!r_un_double())
1472                 {
1473                     break lab11;
1474                 }
1475             } while (false);
1476             cursor = limit - v_9;
1477             // do, line 244
1478             v_10 = limit - cursor;
1479             lab12: do {
1480                 // call un_accent, line 244
1481                 if (!r_un_accent())
1482                 {
1483                     break lab12;
1484                 }
1485             } while (false);
1486             cursor = limit - v_10;
1487             cursor = limit_backward;            // do, line 246
1488             v_11 = cursor;
1489             lab13: do {
1490                 // call postlude, line 246
1491                 if (!r_postlude())
1492                 {
1493                     break lab13;
1494                 }
1495             } while (false);
1496             cursor = v_11;
1497             return true;
1498         }
1499
1500 }
1501