java/galago/src/org/tartarus/snowball/ext/porterStemmer.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 porterStemmer extends SnowballProgram {
  11
  12         private Among a_0[] = {
  13             new Among ( "s", -1, 3, "", this),
  14             new Among ( "ies", 0, 2, "", this),
  15             new Among ( "sses", 0, 1, "", this),
  16             new Among ( "ss", 0, -1, "", this)
  17         };
  18
  19         private Among a_1[] = {
  20             new Among ( "", -1, 3, "", this),
  21             new Among ( "bb", 0, 2, "", this),
  22             new Among ( "dd", 0, 2, "", this),
  23             new Among ( "ff", 0, 2, "", this),
  24             new Among ( "gg", 0, 2, "", this),
  25             new Among ( "bl", 0, 1, "", this),
  26             new Among ( "mm", 0, 2, "", this),
  27             new Among ( "nn", 0, 2, "", this),
  28             new Among ( "pp", 0, 2, "", this),
  29             new Among ( "rr", 0, 2, "", this),
  30             new Among ( "at", 0, 1, "", this),
  31             new Among ( "tt", 0, 2, "", this),
  32             new Among ( "iz", 0, 1, "", this)
  33         };
  34
  35         private Among a_2[] = {
  36             new Among ( "ed", -1, 2, "", this),
  37             new Among ( "eed", 0, 1, "", this),
  38             new Among ( "ing", -1, 2, "", this)
  39         };
  40
  41         private Among a_3[] = {
  42             new Among ( "anci", -1, 3, "", this),
  43             new Among ( "enci", -1, 2, "", this),
  44             new Among ( "abli", -1, 4, "", this),
  45             new Among ( "eli", -1, 6, "", this),
  46             new Among ( "alli", -1, 9, "", this),
  47             new Among ( "ousli", -1, 12, "", this),
  48             new Among ( "entli", -1, 5, "", this),
  49             new Among ( "aliti", -1, 10, "", this),
  50             new Among ( "biliti", -1, 14, "", this),
  51             new Among ( "iviti", -1, 13, "", this),
  52             new Among ( "tional", -1, 1, "", this),
  53             new Among ( "ational", 10, 8, "", this),
  54             new Among ( "alism", -1, 10, "", this),
  55             new Among ( "ation", -1, 8, "", this),
  56             new Among ( "ization", 13, 7, "", this),
  57             new Among ( "izer", -1, 7, "", this),
  58             new Among ( "ator", -1, 8, "", this),
  59             new Among ( "iveness", -1, 13, "", this),
  60             new Among ( "fulness", -1, 11, "", this),
  61             new Among ( "ousness", -1, 12, "", this)
  62         };
  63
  64         private Among a_4[] = {
  65             new Among ( "icate", -1, 2, "", this),
  66             new Among ( "ative", -1, 3, "", this),
  67             new Among ( "alize", -1, 1, "", this),
  68             new Among ( "iciti", -1, 2, "", this),
  69             new Among ( "ical", -1, 2, "", this),
  70             new Among ( "ful", -1, 3, "", this),
  71             new Among ( "ness", -1, 3, "", this)
  72         };
  73
  74         private Among a_5[] = {
  75             new Among ( "ic", -1, 1, "", this),
  76             new Among ( "ance", -1, 1, "", this),
  77             new Among ( "ence", -1, 1, "", this),
  78             new Among ( "able", -1, 1, "", this),
  79             new Among ( "ible", -1, 1, "", this),
  80             new Among ( "ate", -1, 1, "", this),
  81             new Among ( "ive", -1, 1, "", this),
  82             new Among ( "ize", -1, 1, "", this),
  83             new Among ( "iti", -1, 1, "", this),
  84             new Among ( "al", -1, 1, "", this),
  85             new Among ( "ism", -1, 1, "", this),
  86             new Among ( "ion", -1, 2, "", this),
  87             new Among ( "er", -1, 1, "", this),
  88             new Among ( "ous", -1, 1, "", this),
  89             new Among ( "ant", -1, 1, "", this),
  90             new Among ( "ent", -1, 1, "", this),
  91             new Among ( "ment", 15, 1, "", this),
  92             new Among ( "ement", 16, 1, "", this),
  93             new Among ( "ou", -1, 1, "", this)
  94         };
  95
  96         private static final char g_v[] = {17, 65, 16, 1 };
  97
  98         private static final char g_v_WXY[] = {1, 17, 65, 208, 1 };
  99
 100         private boolean B_Y_found;
 101         private int I_p2;
 102         private int I_p1;
 103
 104         private void copy_from(porterStemmer other) {
 105             B_Y_found = other.B_Y_found;
 106             I_p2 = other.I_p2;
 107             I_p1 = other.I_p1;
 108             super.copy_from(other);
 109         }
 110
 111         private boolean r_shortv() {
 112             // (, line 19
 113             if (!(out_grouping_b(g_v_WXY, 89, 121)))
 114             {
 115                 return false;
 116             }
 117             if (!(in_grouping_b(g_v, 97, 121)))
 118             {
 119                 return false;
 120             }
 121             if (!(out_grouping_b(g_v, 97, 121)))
 122             {
 123                 return false;
 124             }
 125             return true;
 126         }
 127
 128         private boolean r_R1() {
 129             if (!(I_p1 <= cursor))
 130             {
 131                 return false;
 132             }
 133             return true;
 134         }
 135
 136         private boolean r_R2() {
 137             if (!(I_p2 <= cursor))
 138             {
 139                 return false;
 140             }
 141             return true;
 142         }
 143
 144         private boolean r_Step_1a() {
 145             int among_var;
 146             // (, line 24
 147             // [, line 25
 148             ket = cursor;
 149             // substring, line 25
 150             among_var = find_among_b(a_0, 4);
 151             if (among_var == 0)
 152             {
 153                 return false;
 154             }
 155             // ], line 25
 156             bra = cursor;
 157             switch(among_var) {
 158                 case 0:
 159                     return false;
 160                 case 1:
 161                     // (, line 26
 162                     // <-, line 26
 163                     slice_from("ss");
 164                     break;
 165                 case 2:
 166                     // (, line 27
 167                     // <-, line 27
 168                     slice_from("i");
 169                     break;
 170                 case 3:
 171                     // (, line 29
 172                     // delete, line 29
 173                     slice_del();
 174                     break;
 175             }
 176             return true;
 177         }
 178
 179         private boolean r_Step_1b() {
 180             int among_var;
 181             int v_1;
 182             int v_3;
 183             int v_4;
 184             // (, line 33
 185             // [, line 34
 186             ket = cursor;
 187             // substring, line 34
 188             among_var = find_among_b(a_2, 3);
 189             if (among_var == 0)
 190             {
 191                 return false;
 192             }
 193             // ], line 34
 194             bra = cursor;
 195             switch(among_var) {
 196                 case 0:
 197                     return false;
 198                 case 1:
 199                     // (, line 35
 200                     // call R1, line 35
 201                     if (!r_R1())
 202                     {
 203                         return false;
 204                     }
 205                     // <-, line 35
 206                     slice_from("ee");
 207                     break;
 208                 case 2:
 209                     // (, line 37
 210                     // test, line 38
 211                     v_1 = limit - cursor;
 212                     // gopast, line 38
 213                     golab0: while(true)
 214                     {
 215                         lab1: do {
 216                             if (!(in_grouping_b(g_v, 97, 121)))
 217                             {
 218                                 break lab1;
 219                             }
 220                             break golab0;
 221                         } while (false);
 222                         if (cursor <= limit_backward)
 223                         {
 224                             return false;
 225                         }
 226                         cursor--;
 227                     }
 228                     cursor = limit - v_1;
 229                     // delete, line 38
 230                     slice_del();
 231                     // test, line 39
 232                     v_3 = limit - cursor;
 233                     // substring, line 39
 234                     among_var = find_among_b(a_1, 13);
 235                     if (among_var == 0)
 236                     {
 237                         return false;
 238                     }
 239                     cursor = limit - v_3;
 240                     switch(among_var) {
 241                         case 0:
 242                             return false;
 243                         case 1:
 244                             // (, line 41
 245                             // <+, line 41
 246                             {
 247                                 int c = cursor;
 248                                 insert(cursor, cursor, "e");
 249                                 cursor = c;
 250                             }
 251                             break;
 252                         case 2:
 253                             // (, line 44
 254                             // [, line 44
 255                             ket = cursor;
 256                             // next, line 44
 257                             if (cursor <= limit_backward)
 258                             {
 259                                 return false;
 260                             }
 261                             cursor--;
 262                             // ], line 44
 263                             bra = cursor;
 264                             // delete, line 44
 265                             slice_del();
 266                             break;
 267                         case 3:
 268                             // (, line 45
 269                             // atmark, line 45
 270                             if (cursor != I_p1)
 271                             {
 272                                 return false;
 273                             }
 274                             // test, line 45
 275                             v_4 = limit - cursor;
 276                             // call shortv, line 45
 277                             if (!r_shortv())
 278                             {
 279                                 return false;
 280                             }
 281                             cursor = limit - v_4;
 282                             // <+, line 45
 283                             {
 284                                 int c = cursor;
 285                                 insert(cursor, cursor, "e");
 286                                 cursor = c;
 287                             }
 288                             break;
 289                     }
 290                     break;
 291             }
 292             return true;
 293         }
 294
 295         private boolean r_Step_1c() {
 296             int v_1;
 297             // (, line 51
 298             // [, line 52
 299             ket = cursor;
 300             // or, line 52
 301             lab0: do {
 302                 v_1 = limit - cursor;
 303                 lab1: do {
 304                     // literal, line 52
 305                     if (!(eq_s_b(1, "y")))
 306                     {
 307                         break lab1;
 308                     }
 309                     break lab0;
 310                 } while (false);
 311                 cursor = limit - v_1;
 312                 // literal, line 52
 313                 if (!(eq_s_b(1, "Y")))
 314                 {
 315                     return false;
 316                 }
 317             } while (false);
 318             // ], line 52
 319             bra = cursor;
 320             // gopast, line 53
 321             golab2: while(true)
 322             {
 323                 lab3: do {
 324                     if (!(in_grouping_b(g_v, 97, 121)))
 325                     {
 326                         break lab3;
 327                     }
 328                     break golab2;
 329                 } while (false);
 330                 if (cursor <= limit_backward)
 331                 {
 332                     return false;
 333                 }
 334                 cursor--;
 335             }
 336             // <-, line 54
 337             slice_from("i");
 338             return true;
 339         }
 340
 341         private boolean r_Step_2() {
 342             int among_var;
 343             // (, line 57
 344             // [, line 58
 345             ket = cursor;
 346             // substring, line 58
 347             among_var = find_among_b(a_3, 20);
 348             if (among_var == 0)
 349             {
 350                 return false;
 351             }
 352             // ], line 58
 353             bra = cursor;
 354             // call R1, line 58
 355             if (!r_R1())
 356             {
 357                 return false;
 358             }
 359             switch(among_var) {
 360                 case 0:
 361                     return false;
 362                 case 1:
 363                     // (, line 59
 364                     // <-, line 59
 365                     slice_from("tion");
 366                     break;
 367                 case 2:
 368                     // (, line 60
 369                     // <-, line 60
 370                     slice_from("ence");
 371                     break;
 372                 case 3:
 373                     // (, line 61
 374                     // <-, line 61
 375                     slice_from("ance");
 376                     break;
 377                 case 4:
 378                     // (, line 62
 379                     // <-, line 62
 380                     slice_from("able");
 381                     break;
 382                 case 5:
 383                     // (, line 63
 384                     // <-, line 63
 385                     slice_from("ent");
 386                     break;
 387                 case 6:
 388                     // (, line 64
 389                     // <-, line 64
 390                     slice_from("e");
 391                     break;
 392                 case 7:
 393                     // (, line 66
 394                     // <-, line 66
 395                     slice_from("ize");
 396                     break;
 397                 case 8:
 398                     // (, line 68
 399                     // <-, line 68
 400                     slice_from("ate");
 401                     break;
 402                 case 9:
 403                     // (, line 69
 404                     // <-, line 69
 405                     slice_from("al");
 406                     break;
 407                 case 10:
 408                     // (, line 71
 409                     // <-, line 71
 410                     slice_from("al");
 411                     break;
 412                 case 11:
 413                     // (, line 72
 414                     // <-, line 72
 415                     slice_from("ful");
 416                     break;
 417                 case 12:
 418                     // (, line 74
 419                     // <-, line 74
 420                     slice_from("ous");
 421                     break;
 422                 case 13:
 423                     // (, line 76
 424                     // <-, line 76
 425                     slice_from("ive");
 426                     break;
 427                 case 14:
 428                     // (, line 77
 429                     // <-, line 77
 430                     slice_from("ble");
 431                     break;
 432             }
 433             return true;
 434         }
 435
 436         private boolean r_Step_3() {
 437             int among_var;
 438             // (, line 81
 439             // [, line 82
 440             ket = cursor;
 441             // substring, line 82
 442             among_var = find_among_b(a_4, 7);
 443             if (among_var == 0)
 444             {
 445                 return false;
 446             }
 447             // ], line 82
 448             bra = cursor;
 449             // call R1, line 82
 450             if (!r_R1())
 451             {
 452                 return false;
 453             }
 454             switch(among_var) {
 455                 case 0:
 456                     return false;
 457                 case 1:
 458                     // (, line 83
 459                     // <-, line 83
 460                     slice_from("al");
 461                     break;
 462                 case 2:
 463                     // (, line 85
 464                     // <-, line 85
 465                     slice_from("ic");
 466                     break;
 467                 case 3:
 468                     // (, line 87
 469                     // delete, line 87
 470                     slice_del();
 471                     break;
 472             }
 473             return true;
 474         }
 475
 476         private boolean r_Step_4() {
 477             int among_var;
 478             int v_1;
 479             // (, line 91
 480             // [, line 92
 481             ket = cursor;
 482             // substring, line 92
 483             among_var = find_among_b(a_5, 19);
 484             if (among_var == 0)
 485             {
 486                 return false;
 487             }
 488             // ], line 92
 489             bra = cursor;
 490             // call R2, line 92
 491             if (!r_R2())
 492             {
 493                 return false;
 494             }
 495             switch(among_var) {
 496                 case 0:
 497                     return false;
 498                 case 1:
 499                     // (, line 95
 500                     // delete, line 95
 501                     slice_del();
 502                     break;
 503                 case 2:
 504                     // (, line 96
 505                     // or, line 96
 506                     lab0: do {
 507                         v_1 = limit - cursor;
 508                         lab1: do {
 509                             // literal, line 96
 510                             if (!(eq_s_b(1, "s")))
 511                             {
 512                                 break lab1;
 513                             }
 514                             break lab0;
 515                         } while (false);
 516                         cursor = limit - v_1;
 517                         // literal, line 96
 518                         if (!(eq_s_b(1, "t")))
 519                         {
 520                             return false;
 521                         }
 522                     } while (false);
 523                     // delete, line 96
 524                     slice_del();
 525                     break;
 526             }
 527             return true;
 528         }
 529
 530         private boolean r_Step_5a() {
 531             int v_1;
 532             int v_2;
 533             // (, line 100
 534             // [, line 101
 535             ket = cursor;
 536             // literal, line 101
 537             if (!(eq_s_b(1, "e")))
 538             {
 539                 return false;
 540             }
 541             // ], line 101
 542             bra = cursor;
 543             // or, line 102
 544             lab0: do {
 545                 v_1 = limit - cursor;
 546                 lab1: do {
 547                     // call R2, line 102
 548                     if (!r_R2())
 549                     {
 550                         break lab1;
 551                     }
 552                     break lab0;
 553                 } while (false);
 554                 cursor = limit - v_1;
 555                 // (, line 102
 556                 // call R1, line 102
 557                 if (!r_R1())
 558                 {
 559                     return false;
 560                 }
 561                 // not, line 102
 562                 {
 563                     v_2 = limit - cursor;
 564                     lab2: do {
 565                         // call shortv, line 102
 566                         if (!r_shortv())
 567                         {
 568                             break lab2;
 569                         }
 570                         return false;
 571                     } while (false);
 572                     cursor = limit - v_2;
 573                 }
 574             } while (false);
 575             // delete, line 103
 576             slice_del();
 577             return true;
 578         }
 579
 580         private boolean r_Step_5b() {
 581             // (, line 106
 582             // [, line 107
 583             ket = cursor;
 584             // literal, line 107
 585             if (!(eq_s_b(1, "l")))
 586             {
 587                 return false;
 588             }
 589             // ], line 107
 590             bra = cursor;
 591             // call R2, line 108
 592             if (!r_R2())
 593             {
 594                 return false;
 595             }
 596             // literal, line 108
 597             if (!(eq_s_b(1, "l")))
 598             {
 599                 return false;
 600             }
 601             // delete, line 109
 602             slice_del();
 603             return true;
 604         }
 605
 606         public boolean stem() {
 607             int v_1;
 608             int v_2;
 609             int v_3;
 610             int v_4;
 611             int v_5;
 612             int v_10;
 613             int v_11;
 614             int v_12;
 615             int v_13;
 616             int v_14;
 617             int v_15;
 618             int v_16;
 619             int v_17;
 620             int v_18;
 621             int v_19;
 622             int v_20;
 623             // (, line 113
 624             // unset Y_found, line 115
 625             B_Y_found = false;
 626             // do, line 116
 627             v_1 = cursor;
 628             lab0: do {
 629                 // (, line 116
 630                 // [, line 116
 631                 bra = cursor;
 632                 // literal, line 116
 633                 if (!(eq_s(1, "y")))
 634                 {
 635                     break lab0;
 636                 }
 637                 // ], line 116
 638                 ket = cursor;
 639                 // <-, line 116
 640                 slice_from("Y");
 641                 // set Y_found, line 116
 642                 B_Y_found = true;
 643             } while (false);
 644             cursor = v_1;
 645             // do, line 117
 646             v_2 = cursor;
 647             lab1: do {
 648                 // repeat, line 117
 649                 replab2: while(true)
 650                 {
 651                     v_3 = cursor;
 652                     lab3: do {
 653                         // (, line 117
 654                         // goto, line 117
 655                         golab4: while(true)
 656                         {
 657                             v_4 = cursor;
 658                             lab5: do {
 659                                 // (, line 117
 660                                 if (!(in_grouping(g_v, 97, 121)))
 661                                 {
 662                                     break lab5;
 663                                 }
 664                                 // [, line 117
 665                                 bra = cursor;
 666                                 // literal, line 117
 667                                 if (!(eq_s(1, "y")))
 668                                 {
 669                                     break lab5;
 670                                 }
 671                                 // ], line 117
 672                                 ket = cursor;
 673                                 cursor = v_4;
 674                                 break golab4;
 675                             } while (false);
 676                             cursor = v_4;
 677                             if (cursor >= limit)
 678                             {
 679                                 break lab3;
 680                             }
 681                             cursor++;
 682                         }
 683                         // <-, line 117
 684                         slice_from("Y");
 685                         // set Y_found, line 117
 686                         B_Y_found = true;
 687                         continue replab2;
 688                     } while (false);
 689                     cursor = v_3;
 690                     break replab2;
 691                 }
 692             } while (false);
 693             cursor = v_2;
 694             I_p1 = limit;
 695             I_p2 = limit;
 696             // do, line 121
 697             v_5 = cursor;
 698             lab6: do {
 699                 // (, line 121
 700                 // gopast, line 122
 701                 golab7: while(true)
 702                 {
 703                     lab8: do {
 704                         if (!(in_grouping(g_v, 97, 121)))
 705                         {
 706                             break lab8;
 707                         }
 708                         break golab7;
 709                     } while (false);
 710                     if (cursor >= limit)
 711                     {
 712                         break lab6;
 713                     }
 714                     cursor++;
 715                 }
 716                 // gopast, line 122
 717                 golab9: while(true)
 718                 {
 719                     lab10: do {
 720                         if (!(out_grouping(g_v, 97, 121)))
 721                         {
 722                             break lab10;
 723                         }
 724                         break golab9;
 725                     } while (false);
 726                     if (cursor >= limit)
 727                     {
 728                         break lab6;
 729                     }
 730                     cursor++;
 731                 }
 732                 // setmark p1, line 122
 733                 I_p1 = cursor;
 734                 // gopast, line 123
 735                 golab11: while(true)
 736                 {
 737                     lab12: do {
 738                         if (!(in_grouping(g_v, 97, 121)))
 739                         {
 740                             break lab12;
 741                         }
 742                         break golab11;
 743                     } while (false);
 744                     if (cursor >= limit)
 745                     {
 746                         break lab6;
 747                     }
 748                     cursor++;
 749                 }
 750                 // gopast, line 123
 751                 golab13: while(true)
 752                 {
 753                     lab14: do {
 754                         if (!(out_grouping(g_v, 97, 121)))
 755                         {
 756                             break lab14;
 757                         }
 758                         break golab13;
 759                     } while (false);
 760                     if (cursor >= limit)
 761                     {
 762                         break lab6;
 763                     }
 764                     cursor++;
 765                 }
 766                 // setmark p2, line 123
 767                 I_p2 = cursor;
 768             } while (false);
 769             cursor = v_5;
 770             // backwards, line 126
 771             limit_backward = cursor; cursor = limit;
 772             // (, line 126
 773             // do, line 127
 774             v_10 = limit - cursor;
 775             lab15: do {
 776                 // call Step_1a, line 127
 777                 if (!r_Step_1a())
 778                 {
 779                     break lab15;
 780                 }
 781             } while (false);
 782             cursor = limit - v_10;
 783             // do, line 128
 784             v_11 = limit - cursor;
 785             lab16: do {
 786                 // call Step_1b, line 128
 787                 if (!r_Step_1b())
 788                 {
 789                     break lab16;
 790                 }
 791             } while (false);
 792             cursor = limit - v_11;
 793             // do, line 129
 794             v_12 = limit - cursor;
 795             lab17: do {
 796                 // call Step_1c, line 129
 797                 if (!r_Step_1c())
 798                 {
 799                     break lab17;
 800                 }
 801             } while (false);
 802             cursor = limit - v_12;
 803             // do, line 130
 804             v_13 = limit - cursor;
 805             lab18: do {
 806                 // call Step_2, line 130
 807                 if (!r_Step_2())
 808                 {
 809                     break lab18;
 810                 }
 811             } while (false);
 812             cursor = limit - v_13;
 813             // do, line 131
 814             v_14 = limit - cursor;
 815             lab19: do {
 816                 // call Step_3, line 131
 817                 if (!r_Step_3())
 818                 {
 819                     break lab19;
 820                 }
 821             } while (false);
 822             cursor = limit - v_14;
 823             // do, line 132
 824             v_15 = limit - cursor;
 825             lab20: do {
 826                 // call Step_4, line 132
 827                 if (!r_Step_4())
 828                 {
 829                     break lab20;
 830                 }
 831             } while (false);
 832             cursor = limit - v_15;
 833             // do, line 133
 834             v_16 = limit - cursor;
 835             lab21: do {
 836                 // call Step_5a, line 133
 837                 if (!r_Step_5a())
 838                 {
 839                     break lab21;
 840                 }
 841             } while (false);
 842             cursor = limit - v_16;
 843             // do, line 134
 844             v_17 = limit - cursor;
 845             lab22: do {
 846                 // call Step_5b, line 134
 847                 if (!r_Step_5b())
 848                 {
 849                     break lab22;
 850                 }
 851             } while (false);
 852             cursor = limit - v_17;
 853             cursor = limit_backward;            // do, line 137
 854             v_18 = cursor;
 855             lab23: do {
 856                 // (, line 137
 857                 // Boolean test Y_found, line 137
 858                 if (!(B_Y_found))
 859                 {
 860                     break lab23;
 861                 }
 862                 // repeat, line 137
 863                 replab24: while(true)
 864                 {
 865                     v_19 = cursor;
 866                     lab25: do {
 867                         // (, line 137
 868                         // goto, line 137
 869                         golab26: while(true)
 870                         {
 871                             v_20 = cursor;
 872                             lab27: do {
 873                                 // (, line 137
 874                                 // [, line 137
 875                                 bra = cursor;
 876                                 // literal, line 137
 877                                 if (!(eq_s(1, "Y")))
 878                                 {
 879                                     break lab27;
 880                                 }
 881                                 // ], line 137
 882                                 ket = cursor;
 883                                 cursor = v_20;
 884                                 break golab26;
 885                             } while (false);
 886                             cursor = v_20;
 887                             if (cursor >= limit)
 888                             {
 889                                 break lab25;
 890                             }
 891                             cursor++;
 892                         }
 893                         // <-, line 137
 894                         slice_from("y");
 895                         continue replab24;
 896                     } while (false);
 897                     cursor = v_19;
 898                     break replab24;
 899                 }
 900             } while (false);
 901             cursor = v_18;
 902             return true;
 903         }
 904
 905 }
 906