lucene-java-3.5.0/lucene/contrib/analyzers/common/src/java/org/tartarus/snowball/ext/LovinsStemmer.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 LovinsStemmer extends SnowballProgram {
  11
  12         private Among a_0[] = {
  13             new Among ( "d", -1, -1, "", this),
  14             new Among ( "f", -1, -1, "", this),
  15             new Among ( "ph", -1, -1, "", this),
  16             new Among ( "th", -1, -1, "", this),
  17             new Among ( "l", -1, -1, "", this),
  18             new Among ( "er", -1, -1, "", this),
  19             new Among ( "or", -1, -1, "", this),
  20             new Among ( "es", -1, -1, "", this),
  21             new Among ( "t", -1, -1, "", this)
  22         };
  23
  24         private Among a_1[] = {
  25             new Among ( "s'", -1, 1, "r_A", this),
  26             new Among ( "a", -1, 1, "r_A", this),
  27             new Among ( "ia", 1, 1, "r_A", this),
  28             new Among ( "ata", 1, 1, "r_A", this),
  29             new Among ( "ic", -1, 1, "r_A", this),
  30             new Among ( "aic", 4, 1, "r_A", this),
  31             new Among ( "allic", 4, 1, "r_BB", this),
  32             new Among ( "aric", 4, 1, "r_A", this),
  33             new Among ( "atic", 4, 1, "r_B", this),
  34             new Among ( "itic", 4, 1, "r_H", this),
  35             new Among ( "antic", 4, 1, "r_C", this),
  36             new Among ( "istic", 4, 1, "r_A", this),
  37             new Among ( "alistic", 11, 1, "r_B", this),
  38             new Among ( "aristic", 11, 1, "r_A", this),
  39             new Among ( "ivistic", 11, 1, "r_A", this),
  40             new Among ( "ed", -1, 1, "r_E", this),
  41             new Among ( "anced", 15, 1, "r_B", this),
  42             new Among ( "enced", 15, 1, "r_A", this),
  43             new Among ( "ished", 15, 1, "r_A", this),
  44             new Among ( "ied", 15, 1, "r_A", this),
  45             new Among ( "ened", 15, 1, "r_E", this),
  46             new Among ( "ioned", 15, 1, "r_A", this),
  47             new Among ( "ated", 15, 1, "r_I", this),
  48             new Among ( "ented", 15, 1, "r_C", this),
  49             new Among ( "ized", 15, 1, "r_F", this),
  50             new Among ( "arized", 24, 1, "r_A", this),
  51             new Among ( "oid", -1, 1, "r_A", this),
  52             new Among ( "aroid", 26, 1, "r_A", this),
  53             new Among ( "hood", -1, 1, "r_A", this),
  54             new Among ( "ehood", 28, 1, "r_A", this),
  55             new Among ( "ihood", 28, 1, "r_A", this),
  56             new Among ( "elihood", 30, 1, "r_E", this),
  57             new Among ( "ward", -1, 1, "r_A", this),
  58             new Among ( "e", -1, 1, "r_A", this),
  59             new Among ( "ae", 33, 1, "r_A", this),
  60             new Among ( "ance", 33, 1, "r_B", this),
  61             new Among ( "icance", 35, 1, "r_A", this),
  62             new Among ( "ence", 33, 1, "r_A", this),
  63             new Among ( "ide", 33, 1, "r_L", this),
  64             new Among ( "icide", 38, 1, "r_A", this),
  65             new Among ( "otide", 38, 1, "r_A", this),
  66             new Among ( "age", 33, 1, "r_B", this),
  67             new Among ( "able", 33, 1, "r_A", this),
  68             new Among ( "atable", 42, 1, "r_A", this),
  69             new Among ( "izable", 42, 1, "r_E", this),
  70             new Among ( "arizable", 44, 1, "r_A", this),
  71             new Among ( "ible", 33, 1, "r_A", this),
  72             new Among ( "encible", 46, 1, "r_A", this),
  73             new Among ( "ene", 33, 1, "r_E", this),
  74             new Among ( "ine", 33, 1, "r_M", this),
  75             new Among ( "idine", 49, 1, "r_I", this),
  76             new Among ( "one", 33, 1, "r_R", this),
  77             new Among ( "ature", 33, 1, "r_E", this),
  78             new Among ( "eature", 52, 1, "r_Z", this),
  79             new Among ( "ese", 33, 1, "r_A", this),
  80             new Among ( "wise", 33, 1, "r_A", this),
  81             new Among ( "ate", 33, 1, "r_A", this),
  82             new Among ( "entiate", 56, 1, "r_A", this),
  83             new Among ( "inate", 56, 1, "r_A", this),
  84             new Among ( "ionate", 56, 1, "r_D", this),
  85             new Among ( "ite", 33, 1, "r_AA", this),
  86             new Among ( "ive", 33, 1, "r_A", this),
  87             new Among ( "ative", 61, 1, "r_A", this),
  88             new Among ( "ize", 33, 1, "r_F", this),
  89             new Among ( "alize", 63, 1, "r_A", this),
  90             new Among ( "icalize", 64, 1, "r_A", this),
  91             new Among ( "ialize", 64, 1, "r_A", this),
  92             new Among ( "entialize", 66, 1, "r_A", this),
  93             new Among ( "ionalize", 64, 1, "r_A", this),
  94             new Among ( "arize", 63, 1, "r_A", this),
  95             new Among ( "ing", -1, 1, "r_N", this),
  96             new Among ( "ancing", 70, 1, "r_B", this),
  97             new Among ( "encing", 70, 1, "r_A", this),
  98             new Among ( "aging", 70, 1, "r_B", this),
  99             new Among ( "ening", 70, 1, "r_E", this),
 100             new Among ( "ioning", 70, 1, "r_A", this),
 101             new Among ( "ating", 70, 1, "r_I", this),
 102             new Among ( "enting", 70, 1, "r_C", this),
 103             new Among ( "ying", 70, 1, "r_B", this),
 104             new Among ( "izing", 70, 1, "r_F", this),
 105             new Among ( "arizing", 79, 1, "r_A", this),
 106             new Among ( "ish", -1, 1, "r_C", this),
 107             new Among ( "yish", 81, 1, "r_A", this),
 108             new Among ( "i", -1, 1, "r_A", this),
 109             new Among ( "al", -1, 1, "r_BB", this),
 110             new Among ( "ical", 84, 1, "r_A", this),
 111             new Among ( "aical", 85, 1, "r_A", this),
 112             new Among ( "istical", 85, 1, "r_A", this),
 113             new Among ( "oidal", 84, 1, "r_A", this),
 114             new Among ( "eal", 84, 1, "r_Y", this),
 115             new Among ( "ial", 84, 1, "r_A", this),
 116             new Among ( "ancial", 90, 1, "r_A", this),
 117             new Among ( "arial", 90, 1, "r_A", this),
 118             new Among ( "ential", 90, 1, "r_A", this),
 119             new Among ( "ional", 84, 1, "r_A", this),
 120             new Among ( "ational", 94, 1, "r_B", this),
 121             new Among ( "izational", 95, 1, "r_A", this),
 122             new Among ( "ental", 84, 1, "r_A", this),
 123             new Among ( "ful", -1, 1, "r_A", this),
 124             new Among ( "eful", 98, 1, "r_A", this),
 125             new Among ( "iful", 98, 1, "r_A", this),
 126             new Among ( "yl", -1, 1, "r_R", this),
 127             new Among ( "ism", -1, 1, "r_B", this),
 128             new Among ( "icism", 102, 1, "r_A", this),
 129             new Among ( "oidism", 102, 1, "r_A", this),
 130             new Among ( "alism", 102, 1, "r_B", this),
 131             new Among ( "icalism", 105, 1, "r_A", this),
 132             new Among ( "ionalism", 105, 1, "r_A", this),
 133             new Among ( "inism", 102, 1, "r_J", this),
 134             new Among ( "ativism", 102, 1, "r_A", this),
 135             new Among ( "um", -1, 1, "r_U", this),
 136             new Among ( "ium", 110, 1, "r_A", this),
 137             new Among ( "ian", -1, 1, "r_A", this),
 138             new Among ( "ician", 112, 1, "r_A", this),
 139             new Among ( "en", -1, 1, "r_F", this),
 140             new Among ( "ogen", 114, 1, "r_A", this),
 141             new Among ( "on", -1, 1, "r_S", this),
 142             new Among ( "ion", 116, 1, "r_Q", this),
 143             new Among ( "ation", 117, 1, "r_B", this),
 144             new Among ( "ication", 118, 1, "r_G", this),
 145             new Among ( "entiation", 118, 1, "r_A", this),
 146             new Among ( "ination", 118, 1, "r_A", this),
 147             new Among ( "isation", 118, 1, "r_A", this),
 148             new Among ( "arisation", 122, 1, "r_A", this),
 149             new Among ( "entation", 118, 1, "r_A", this),
 150             new Among ( "ization", 118, 1, "r_F", this),
 151             new Among ( "arization", 125, 1, "r_A", this),
 152             new Among ( "action", 117, 1, "r_G", this),
 153             new Among ( "o", -1, 1, "r_A", this),
 154             new Among ( "ar", -1, 1, "r_X", this),
 155             new Among ( "ear", 129, 1, "r_Y", this),
 156             new Among ( "ier", -1, 1, "r_A", this),
 157             new Among ( "ariser", -1, 1, "r_A", this),
 158             new Among ( "izer", -1, 1, "r_F", this),
 159             new Among ( "arizer", 133, 1, "r_A", this),
 160             new Among ( "or", -1, 1, "r_T", this),
 161             new Among ( "ator", 135, 1, "r_A", this),
 162             new Among ( "s", -1, 1, "r_W", this),
 163             new Among ( "'s", 137, 1, "r_A", this),
 164             new Among ( "as", 137, 1, "r_B", this),
 165             new Among ( "ics", 137, 1, "r_A", this),
 166             new Among ( "istics", 140, 1, "r_A", this),
 167             new Among ( "es", 137, 1, "r_E", this),
 168             new Among ( "ances", 142, 1, "r_B", this),
 169             new Among ( "ences", 142, 1, "r_A", this),
 170             new Among ( "ides", 142, 1, "r_L", this),
 171             new Among ( "oides", 145, 1, "r_A", this),
 172             new Among ( "ages", 142, 1, "r_B", this),
 173             new Among ( "ies", 142, 1, "r_P", this),
 174             new Among ( "acies", 148, 1, "r_A", this),
 175             new Among ( "ancies", 148, 1, "r_A", this),
 176             new Among ( "encies", 148, 1, "r_A", this),
 177             new Among ( "aries", 148, 1, "r_A", this),
 178             new Among ( "ities", 148, 1, "r_A", this),
 179             new Among ( "alities", 153, 1, "r_A", this),
 180             new Among ( "ivities", 153, 1, "r_A", this),
 181             new Among ( "ines", 142, 1, "r_M", this),
 182             new Among ( "nesses", 142, 1, "r_A", this),
 183             new Among ( "ates", 142, 1, "r_A", this),
 184             new Among ( "atives", 142, 1, "r_A", this),
 185             new Among ( "ings", 137, 1, "r_N", this),
 186             new Among ( "is", 137, 1, "r_A", this),
 187             new Among ( "als", 137, 1, "r_BB", this),
 188             new Among ( "ials", 162, 1, "r_A", this),
 189             new Among ( "entials", 163, 1, "r_A", this),
 190             new Among ( "ionals", 162, 1, "r_A", this),
 191             new Among ( "isms", 137, 1, "r_B", this),
 192             new Among ( "ians", 137, 1, "r_A", this),
 193             new Among ( "icians", 167, 1, "r_A", this),
 194             new Among ( "ions", 137, 1, "r_B", this),
 195             new Among ( "ations", 169, 1, "r_B", this),
 196             new Among ( "arisations", 170, 1, "r_A", this),
 197             new Among ( "entations", 170, 1, "r_A", this),
 198             new Among ( "izations", 170, 1, "r_A", this),
 199             new Among ( "arizations", 173, 1, "r_A", this),
 200             new Among ( "ars", 137, 1, "r_O", this),
 201             new Among ( "iers", 137, 1, "r_A", this),
 202             new Among ( "izers", 137, 1, "r_F", this),
 203             new Among ( "ators", 137, 1, "r_A", this),
 204             new Among ( "less", 137, 1, "r_A", this),
 205             new Among ( "eless", 179, 1, "r_A", this),
 206             new Among ( "ness", 137, 1, "r_A", this),
 207             new Among ( "eness", 181, 1, "r_E", this),
 208             new Among ( "ableness", 182, 1, "r_A", this),
 209             new Among ( "eableness", 183, 1, "r_E", this),
 210             new Among ( "ibleness", 182, 1, "r_A", this),
 211             new Among ( "ateness", 182, 1, "r_A", this),
 212             new Among ( "iteness", 182, 1, "r_A", this),
 213             new Among ( "iveness", 182, 1, "r_A", this),
 214             new Among ( "ativeness", 188, 1, "r_A", this),
 215             new Among ( "ingness", 181, 1, "r_A", this),
 216             new Among ( "ishness", 181, 1, "r_A", this),
 217             new Among ( "iness", 181, 1, "r_A", this),
 218             new Among ( "ariness", 192, 1, "r_E", this),
 219             new Among ( "alness", 181, 1, "r_A", this),
 220             new Among ( "icalness", 194, 1, "r_A", this),
 221             new Among ( "antialness", 194, 1, "r_A", this),
 222             new Among ( "entialness", 194, 1, "r_A", this),
 223             new Among ( "ionalness", 194, 1, "r_A", this),
 224             new Among ( "fulness", 181, 1, "r_A", this),
 225             new Among ( "lessness", 181, 1, "r_A", this),
 226             new Among ( "ousness", 181, 1, "r_A", this),
 227             new Among ( "eousness", 201, 1, "r_A", this),
 228             new Among ( "iousness", 201, 1, "r_A", this),
 229             new Among ( "itousness", 201, 1, "r_A", this),
 230             new Among ( "entness", 181, 1, "r_A", this),
 231             new Among ( "ants", 137, 1, "r_B", this),
 232             new Among ( "ists", 137, 1, "r_A", this),
 233             new Among ( "icists", 207, 1, "r_A", this),
 234             new Among ( "us", 137, 1, "r_V", this),
 235             new Among ( "ous", 209, 1, "r_A", this),
 236             new Among ( "eous", 210, 1, "r_A", this),
 237             new Among ( "aceous", 211, 1, "r_A", this),
 238             new Among ( "antaneous", 211, 1, "r_A", this),
 239             new Among ( "ious", 210, 1, "r_A", this),
 240             new Among ( "acious", 214, 1, "r_B", this),
 241             new Among ( "itous", 210, 1, "r_A", this),
 242             new Among ( "ant", -1, 1, "r_B", this),
 243             new Among ( "icant", 217, 1, "r_A", this),
 244             new Among ( "ent", -1, 1, "r_C", this),
 245             new Among ( "ement", 219, 1, "r_A", this),
 246             new Among ( "izement", 220, 1, "r_A", this),
 247             new Among ( "ist", -1, 1, "r_A", this),
 248             new Among ( "icist", 222, 1, "r_A", this),
 249             new Among ( "alist", 222, 1, "r_A", this),
 250             new Among ( "icalist", 224, 1, "r_A", this),
 251             new Among ( "ialist", 224, 1, "r_A", this),
 252             new Among ( "ionist", 222, 1, "r_A", this),
 253             new Among ( "entist", 222, 1, "r_A", this),
 254             new Among ( "y", -1, 1, "r_B", this),
 255             new Among ( "acy", 229, 1, "r_A", this),
 256             new Among ( "ancy", 229, 1, "r_B", this),
 257             new Among ( "ency", 229, 1, "r_A", this),
 258             new Among ( "ly", 229, 1, "r_B", this),
 259             new Among ( "ealy", 233, 1, "r_Y", this),
 260             new Among ( "ably", 233, 1, "r_A", this),
 261             new Among ( "ibly", 233, 1, "r_A", this),
 262             new Among ( "edly", 233, 1, "r_E", this),
 263             new Among ( "iedly", 237, 1, "r_A", this),
 264             new Among ( "ely", 233, 1, "r_E", this),
 265             new Among ( "ately", 239, 1, "r_A", this),
 266             new Among ( "ively", 239, 1, "r_A", this),
 267             new Among ( "atively", 241, 1, "r_A", this),
 268             new Among ( "ingly", 233, 1, "r_B", this),
 269             new Among ( "atingly", 243, 1, "r_A", this),
 270             new Among ( "ily", 233, 1, "r_A", this),
 271             new Among ( "lily", 245, 1, "r_A", this),
 272             new Among ( "arily", 245, 1, "r_A", this),
 273             new Among ( "ally", 233, 1, "r_B", this),
 274             new Among ( "ically", 248, 1, "r_A", this),
 275             new Among ( "aically", 249, 1, "r_A", this),
 276             new Among ( "allically", 249, 1, "r_C", this),
 277             new Among ( "istically", 249, 1, "r_A", this),
 278             new Among ( "alistically", 252, 1, "r_B", this),
 279             new Among ( "oidally", 248, 1, "r_A", this),
 280             new Among ( "ially", 248, 1, "r_A", this),
 281             new Among ( "entially", 255, 1, "r_A", this),
 282             new Among ( "ionally", 248, 1, "r_A", this),
 283             new Among ( "ationally", 257, 1, "r_B", this),
 284             new Among ( "izationally", 258, 1, "r_B", this),
 285             new Among ( "entally", 248, 1, "r_A", this),
 286             new Among ( "fully", 233, 1, "r_A", this),
 287             new Among ( "efully", 261, 1, "r_A", this),
 288             new Among ( "ifully", 261, 1, "r_A", this),
 289             new Among ( "enly", 233, 1, "r_E", this),
 290             new Among ( "arly", 233, 1, "r_K", this),
 291             new Among ( "early", 265, 1, "r_Y", this),
 292             new Among ( "lessly", 233, 1, "r_A", this),
 293             new Among ( "ously", 233, 1, "r_A", this),
 294             new Among ( "eously", 268, 1, "r_A", this),
 295             new Among ( "iously", 268, 1, "r_A", this),
 296             new Among ( "ently", 233, 1, "r_A", this),
 297             new Among ( "ary", 229, 1, "r_F", this),
 298             new Among ( "ery", 229, 1, "r_E", this),
 299             new Among ( "icianry", 229, 1, "r_A", this),
 300             new Among ( "atory", 229, 1, "r_A", this),
 301             new Among ( "ity", 229, 1, "r_A", this),
 302             new Among ( "acity", 276, 1, "r_A", this),
 303             new Among ( "icity", 276, 1, "r_A", this),
 304             new Among ( "eity", 276, 1, "r_A", this),
 305             new Among ( "ality", 276, 1, "r_A", this),
 306             new Among ( "icality", 280, 1, "r_A", this),
 307             new Among ( "iality", 280, 1, "r_A", this),
 308             new Among ( "antiality", 282, 1, "r_A", this),
 309             new Among ( "entiality", 282, 1, "r_A", this),
 310             new Among ( "ionality", 280, 1, "r_A", this),
 311             new Among ( "elity", 276, 1, "r_A", this),
 312             new Among ( "ability", 276, 1, "r_A", this),
 313             new Among ( "izability", 287, 1, "r_A", this),
 314             new Among ( "arizability", 288, 1, "r_A", this),
 315             new Among ( "ibility", 276, 1, "r_A", this),
 316             new Among ( "inity", 276, 1, "r_CC", this),
 317             new Among ( "arity", 276, 1, "r_B", this),
 318             new Among ( "ivity", 276, 1, "r_A", this)
 319         };
 320
 321         private Among a_2[] = {
 322             new Among ( "bb", -1, -1, "", this),
 323             new Among ( "dd", -1, -1, "", this),
 324             new Among ( "gg", -1, -1, "", this),
 325             new Among ( "ll", -1, -1, "", this),
 326             new Among ( "mm", -1, -1, "", this),
 327             new Among ( "nn", -1, -1, "", this),
 328             new Among ( "pp", -1, -1, "", this),
 329             new Among ( "rr", -1, -1, "", this),
 330             new Among ( "ss", -1, -1, "", this),
 331             new Among ( "tt", -1, -1, "", this)
 332         };
 333
 334         private Among a_3[] = {
 335             new Among ( "uad", -1, 18, "", this),
 336             new Among ( "vad", -1, 19, "", this),
 337             new Among ( "cid", -1, 20, "", this),
 338             new Among ( "lid", -1, 21, "", this),
 339             new Among ( "erid", -1, 22, "", this),
 340             new Among ( "pand", -1, 23, "", this),
 341             new Among ( "end", -1, 24, "", this),
 342             new Among ( "ond", -1, 25, "", this),
 343             new Among ( "lud", -1, 26, "", this),
 344             new Among ( "rud", -1, 27, "", this),
 345             new Among ( "ul", -1, 9, "", this),
 346             new Among ( "her", -1, 28, "", this),
 347             new Among ( "metr", -1, 7, "", this),
 348             new Among ( "istr", -1, 6, "", this),
 349             new Among ( "urs", -1, 5, "", this),
 350             new Among ( "uct", -1, 2, "", this),
 351             new Among ( "et", -1, 32, "", this),
 352             new Among ( "mit", -1, 29, "", this),
 353             new Among ( "ent", -1, 30, "", this),
 354             new Among ( "umpt", -1, 3, "", this),
 355             new Among ( "rpt", -1, 4, "", this),
 356             new Among ( "ert", -1, 31, "", this),
 357             new Among ( "yt", -1, 33, "", this),
 358             new Among ( "iev", -1, 1, "", this),
 359             new Among ( "olv", -1, 8, "", this),
 360             new Among ( "ax", -1, 14, "", this),
 361             new Among ( "ex", -1, 15, "", this),
 362             new Among ( "bex", 26, 10, "", this),
 363             new Among ( "dex", 26, 11, "", this),
 364             new Among ( "pex", 26, 12, "", this),
 365             new Among ( "tex", 26, 13, "", this),
 366             new Among ( "ix", -1, 16, "", this),
 367             new Among ( "lux", -1, 17, "", this),
 368             new Among ( "yz", -1, 34, "", this)
 369         };
 370
 371
 372         private void copy_from(LovinsStemmer other) {
 373             super.copy_from(other);
 374         }
 375
 376         private boolean r_A() {
 377             // (, line 21
 378             // hop, line 21
 379             {
 380                 int c = cursor - 2;
 381                 if (limit_backward > c || c > limit)
 382                 {
 383                     return false;
 384                 }
 385                 cursor = c;
 386             }
 387             return true;
 388         }
 389
 390         private boolean r_B() {
 391             // (, line 22
 392             // hop, line 22
 393             {
 394                 int c = cursor - 3;
 395                 if (limit_backward > c || c > limit)
 396                 {
 397                     return false;
 398                 }
 399                 cursor = c;
 400             }
 401             return true;
 402         }
 403
 404         private boolean r_C() {
 405             // (, line 23
 406             // hop, line 23
 407             {
 408                 int c = cursor - 4;
 409                 if (limit_backward > c || c > limit)
 410                 {
 411                     return false;
 412                 }
 413                 cursor = c;
 414             }
 415             return true;
 416         }
 417
 418         private boolean r_D() {
 419             // (, line 24
 420             // hop, line 24
 421             {
 422                 int c = cursor - 5;
 423                 if (limit_backward > c || c > limit)
 424                 {
 425                     return false;
 426                 }
 427                 cursor = c;
 428             }
 429             return true;
 430         }
 431
 432         private boolean r_E() {
 433             int v_1;
 434             int v_2;
 435             // (, line 25
 436             // test, line 25
 437             v_1 = limit - cursor;
 438             // hop, line 25
 439             {
 440                 int c = cursor - 2;
 441                 if (limit_backward > c || c > limit)
 442                 {
 443                     return false;
 444                 }
 445                 cursor = c;
 446             }
 447             cursor = limit - v_1;
 448             // not, line 25
 449             {
 450                 v_2 = limit - cursor;
 451                 lab0: do {
 452                     // literal, line 25
 453                     if (!(eq_s_b(1, "e")))
 454                     {
 455                         break lab0;
 456                     }
 457                     return false;
 458                 } while (false);
 459                 cursor = limit - v_2;
 460             }
 461             return true;
 462         }
 463
 464         private boolean r_F() {
 465             int v_1;
 466             int v_2;
 467             // (, line 26
 468             // test, line 26
 469             v_1 = limit - cursor;
 470             // hop, line 26
 471             {
 472                 int c = cursor - 3;
 473                 if (limit_backward > c || c > limit)
 474                 {
 475                     return false;
 476                 }
 477                 cursor = c;
 478             }
 479             cursor = limit - v_1;
 480             // not, line 26
 481             {
 482                 v_2 = limit - cursor;
 483                 lab0: do {
 484                     // literal, line 26
 485                     if (!(eq_s_b(1, "e")))
 486                     {
 487                         break lab0;
 488                     }
 489                     return false;
 490                 } while (false);
 491                 cursor = limit - v_2;
 492             }
 493             return true;
 494         }
 495
 496         private boolean r_G() {
 497             int v_1;
 498             // (, line 27
 499             // test, line 27
 500             v_1 = limit - cursor;
 501             // hop, line 27
 502             {
 503                 int c = cursor - 3;
 504                 if (limit_backward > c || c > limit)
 505                 {
 506                     return false;
 507                 }
 508                 cursor = c;
 509             }
 510             cursor = limit - v_1;
 511             // literal, line 27
 512             if (!(eq_s_b(1, "f")))
 513             {
 514                 return false;
 515             }
 516             return true;
 517         }
 518
 519         private boolean r_H() {
 520             int v_1;
 521             int v_2;
 522             // (, line 28
 523             // test, line 28
 524             v_1 = limit - cursor;
 525             // hop, line 28
 526             {
 527                 int c = cursor - 2;
 528                 if (limit_backward > c || c > limit)
 529                 {
 530                     return false;
 531                 }
 532                 cursor = c;
 533             }
 534             cursor = limit - v_1;
 535             // or, line 28
 536             lab0: do {
 537                 v_2 = limit - cursor;
 538                 lab1: do {
 539                     // literal, line 28
 540                     if (!(eq_s_b(1, "t")))
 541                     {
 542                         break lab1;
 543                     }
 544                     break lab0;
 545                 } while (false);
 546                 cursor = limit - v_2;
 547                 // literal, line 28
 548                 if (!(eq_s_b(2, "ll")))
 549                 {
 550                     return false;
 551                 }
 552             } while (false);
 553             return true;
 554         }
 555
 556         private boolean r_I() {
 557             int v_1;
 558             int v_2;
 559             int v_3;
 560             // (, line 29
 561             // test, line 29
 562             v_1 = limit - cursor;
 563             // hop, line 29
 564             {
 565                 int c = cursor - 2;
 566                 if (limit_backward > c || c > limit)
 567                 {
 568                     return false;
 569                 }
 570                 cursor = c;
 571             }
 572             cursor = limit - v_1;
 573             // not, line 29
 574             {
 575                 v_2 = limit - cursor;
 576                 lab0: do {
 577                     // literal, line 29
 578                     if (!(eq_s_b(1, "o")))
 579                     {
 580                         break lab0;
 581                     }
 582                     return false;
 583                 } while (false);
 584                 cursor = limit - v_2;
 585             }
 586             // not, line 29
 587             {
 588                 v_3 = limit - cursor;
 589                 lab1: do {
 590                     // literal, line 29
 591                     if (!(eq_s_b(1, "e")))
 592                     {
 593                         break lab1;
 594                     }
 595                     return false;
 596                 } while (false);
 597                 cursor = limit - v_3;
 598             }
 599             return true;
 600         }
 601
 602         private boolean r_J() {
 603             int v_1;
 604             int v_2;
 605             int v_3;
 606             // (, line 30
 607             // test, line 30
 608             v_1 = limit - cursor;
 609             // hop, line 30
 610             {
 611                 int c = cursor - 2;
 612                 if (limit_backward > c || c > limit)
 613                 {
 614                     return false;
 615                 }
 616                 cursor = c;
 617             }
 618             cursor = limit - v_1;
 619             // not, line 30
 620             {
 621                 v_2 = limit - cursor;
 622                 lab0: do {
 623                     // literal, line 30
 624                     if (!(eq_s_b(1, "a")))
 625                     {
 626                         break lab0;
 627                     }
 628                     return false;
 629                 } while (false);
 630                 cursor = limit - v_2;
 631             }
 632             // not, line 30
 633             {
 634                 v_3 = limit - cursor;
 635                 lab1: do {
 636                     // literal, line 30
 637                     if (!(eq_s_b(1, "e")))
 638                     {
 639                         break lab1;
 640                     }
 641                     return false;
 642                 } while (false);
 643                 cursor = limit - v_3;
 644             }
 645             return true;
 646         }
 647
 648         private boolean r_K() {
 649             int v_1;
 650             int v_2;
 651             // (, line 31
 652             // test, line 31
 653             v_1 = limit - cursor;
 654             // hop, line 31
 655             {
 656                 int c = cursor - 3;
 657                 if (limit_backward > c || c > limit)
 658                 {
 659                     return false;
 660                 }
 661                 cursor = c;
 662             }
 663             cursor = limit - v_1;
 664             // or, line 31
 665             lab0: do {
 666                 v_2 = limit - cursor;
 667                 lab1: do {
 668                     // literal, line 31
 669                     if (!(eq_s_b(1, "l")))
 670                     {
 671                         break lab1;
 672                     }
 673                     break lab0;
 674                 } while (false);
 675                 cursor = limit - v_2;
 676                 lab2: do {
 677                     // literal, line 31
 678                     if (!(eq_s_b(1, "i")))
 679                     {
 680                         break lab2;
 681                     }
 682                     break lab0;
 683                 } while (false);
 684                 cursor = limit - v_2;
 685                 // (, line 31
 686                 // literal, line 31
 687                 if (!(eq_s_b(1, "e")))
 688                 {
 689                     return false;
 690                 }
 691                 // next, line 31
 692                 if (cursor <= limit_backward)
 693                 {
 694                     return false;
 695                 }
 696                 cursor--;
 697                 // literal, line 31
 698                 if (!(eq_s_b(1, "u")))
 699                 {
 700                     return false;
 701                 }
 702             } while (false);
 703             return true;
 704         }
 705
 706         private boolean r_L() {
 707             int v_1;
 708             int v_2;
 709             int v_3;
 710             int v_4;
 711             int v_5;
 712             // (, line 32
 713             // test, line 32
 714             v_1 = limit - cursor;
 715             // hop, line 32
 716             {
 717                 int c = cursor - 2;
 718                 if (limit_backward > c || c > limit)
 719                 {
 720                     return false;
 721                 }
 722                 cursor = c;
 723             }
 724             cursor = limit - v_1;
 725             // not, line 32
 726             {
 727                 v_2 = limit - cursor;
 728                 lab0: do {
 729                     // literal, line 32
 730                     if (!(eq_s_b(1, "u")))
 731                     {
 732                         break lab0;
 733                     }
 734                     return false;
 735                 } while (false);
 736                 cursor = limit - v_2;
 737             }
 738             // not, line 32
 739             {
 740                 v_3 = limit - cursor;
 741                 lab1: do {
 742                     // literal, line 32
 743                     if (!(eq_s_b(1, "x")))
 744                     {
 745                         break lab1;
 746                     }
 747                     return false;
 748                 } while (false);
 749                 cursor = limit - v_3;
 750             }
 751             // not, line 32
 752             {
 753                 v_4 = limit - cursor;
 754                 lab2: do {
 755                     // (, line 32
 756                     // literal, line 32
 757                     if (!(eq_s_b(1, "s")))
 758                     {
 759                         break lab2;
 760                     }
 761                     // not, line 32
 762                     {
 763                         v_5 = limit - cursor;
 764                         lab3: do {
 765                             // literal, line 32
 766                             if (!(eq_s_b(1, "o")))
 767                             {
 768                                 break lab3;
 769                             }
 770                             break lab2;
 771                         } while (false);
 772                         cursor = limit - v_5;
 773                     }
 774                     return false;
 775                 } while (false);
 776                 cursor = limit - v_4;
 777             }
 778             return true;
 779         }
 780
 781         private boolean r_M() {
 782             int v_1;
 783             int v_2;
 784             int v_3;
 785             int v_4;
 786             int v_5;
 787             // (, line 33
 788             // test, line 33
 789             v_1 = limit - cursor;
 790             // hop, line 33
 791             {
 792                 int c = cursor - 2;
 793                 if (limit_backward > c || c > limit)
 794                 {
 795                     return false;
 796                 }
 797                 cursor = c;
 798             }
 799             cursor = limit - v_1;
 800             // not, line 33
 801             {
 802                 v_2 = limit - cursor;
 803                 lab0: do {
 804                     // literal, line 33
 805                     if (!(eq_s_b(1, "a")))
 806                     {
 807                         break lab0;
 808                     }
 809                     return false;
 810                 } while (false);
 811                 cursor = limit - v_2;
 812             }
 813             // not, line 33
 814             {
 815                 v_3 = limit - cursor;
 816                 lab1: do {
 817                     // literal, line 33
 818                     if (!(eq_s_b(1, "c")))
 819                     {
 820                         break lab1;
 821                     }
 822                     return false;
 823                 } while (false);
 824                 cursor = limit - v_3;
 825             }
 826             // not, line 33
 827             {
 828                 v_4 = limit - cursor;
 829                 lab2: do {
 830                     // literal, line 33
 831                     if (!(eq_s_b(1, "e")))
 832                     {
 833                         break lab2;
 834                     }
 835                     return false;
 836                 } while (false);
 837                 cursor = limit - v_4;
 838             }
 839             // not, line 33
 840             {
 841                 v_5 = limit - cursor;
 842                 lab3: do {
 843                     // literal, line 33
 844                     if (!(eq_s_b(1, "m")))
 845                     {
 846                         break lab3;
 847                     }
 848                     return false;
 849                 } while (false);
 850                 cursor = limit - v_5;
 851             }
 852             return true;
 853         }
 854
 855         private boolean r_N() {
 856             int v_1;
 857             int v_2;
 858             int v_3;
 859             // (, line 34
 860             // test, line 34
 861             v_1 = limit - cursor;
 862             // hop, line 34
 863             {
 864                 int c = cursor - 3;
 865                 if (limit_backward > c || c > limit)
 866                 {
 867                     return false;
 868                 }
 869                 cursor = c;
 870             }
 871             cursor = limit - v_1;
 872             // (, line 34
 873             // hop, line 34
 874             {
 875                 int c = cursor - 2;
 876                 if (limit_backward > c || c > limit)
 877                 {
 878                     return false;
 879                 }
 880                 cursor = c;
 881             }
 882             // or, line 34
 883             lab0: do {
 884                 v_2 = limit - cursor;
 885                 lab1: do {
 886                     // not, line 34
 887                     {
 888                         v_3 = limit - cursor;
 889                         lab2: do {
 890                             // literal, line 34
 891                             if (!(eq_s_b(1, "s")))
 892                             {
 893                                 break lab2;
 894                             }
 895                             break lab1;
 896                         } while (false);
 897                         cursor = limit - v_3;
 898                     }
 899                     break lab0;
 900                 } while (false);
 901                 cursor = limit - v_2;
 902                 // hop, line 34
 903                 {
 904                     int c = cursor - 2;
 905                     if (limit_backward > c || c > limit)
 906                     {
 907                         return false;
 908                     }
 909                     cursor = c;
 910                 }
 911             } while (false);
 912             return true;
 913         }
 914
 915         private boolean r_O() {
 916             int v_1;
 917             int v_2;
 918             // (, line 35
 919             // test, line 35
 920             v_1 = limit - cursor;
 921             // hop, line 35
 922             {
 923                 int c = cursor - 2;
 924                 if (limit_backward > c || c > limit)
 925                 {
 926                     return false;
 927                 }
 928                 cursor = c;
 929             }
 930             cursor = limit - v_1;
 931             // or, line 35
 932             lab0: do {
 933                 v_2 = limit - cursor;
 934                 lab1: do {
 935                     // literal, line 35
 936                     if (!(eq_s_b(1, "l")))
 937                     {
 938                         break lab1;
 939                     }
 940                     break lab0;
 941                 } while (false);
 942                 cursor = limit - v_2;
 943                 // literal, line 35
 944                 if (!(eq_s_b(1, "i")))
 945                 {
 946                     return false;
 947                 }
 948             } while (false);
 949             return true;
 950         }
 951
 952         private boolean r_P() {
 953             int v_1;
 954             int v_2;
 955             // (, line 36
 956             // test, line 36
 957             v_1 = limit - cursor;
 958             // hop, line 36
 959             {
 960                 int c = cursor - 2;
 961                 if (limit_backward > c || c > limit)
 962                 {
 963                     return false;
 964                 }
 965                 cursor = c;
 966             }
 967             cursor = limit - v_1;
 968             // not, line 36
 969             {
 970                 v_2 = limit - cursor;
 971                 lab0: do {
 972                     // literal, line 36
 973                     if (!(eq_s_b(1, "c")))
 974                     {
 975                         break lab0;
 976                     }
 977                     return false;
 978                 } while (false);
 979                 cursor = limit - v_2;
 980             }
 981             return true;
 982         }
 983
 984         private boolean r_Q() {
 985             int v_1;
 986             int v_2;
 987             int v_3;
 988             int v_4;
 989             // (, line 37
 990             // test, line 37
 991             v_1 = limit - cursor;
 992             // hop, line 37
 993             {
 994                 int c = cursor - 2;
 995                 if (limit_backward > c || c > limit)
 996                 {
 997                     return false;
 998                 }
 999                 cursor = c;
1000             }
1001             cursor = limit - v_1;
1002             // test, line 37
1003             v_2 = limit - cursor;
1004             // hop, line 37
1005             {
1006                 int c = cursor - 3;
1007                 if (limit_backward > c || c > limit)
1008                 {
1009                     return false;
1010                 }
1011                 cursor = c;
1012             }
1013             cursor = limit - v_2;
1014             // not, line 37
1015             {
1016                 v_3 = limit - cursor;
1017                 lab0: do {
1018                     // literal, line 37
1019                     if (!(eq_s_b(1, "l")))
1020                     {
1021                         break lab0;
1022                     }
1023                     return false;
1024                 } while (false);
1025                 cursor = limit - v_3;
1026             }
1027             // not, line 37
1028             {
1029                 v_4 = limit - cursor;
1030                 lab1: do {
1031                     // literal, line 37
1032                     if (!(eq_s_b(1, "n")))
1033                     {
1034                         break lab1;
1035                     }
1036                     return false;
1037                 } while (false);
1038                 cursor = limit - v_4;
1039             }
1040             return true;
1041         }
1042
1043         private boolean r_R() {
1044             int v_1;
1045             int v_2;
1046             // (, line 38
1047             // test, line 38
1048             v_1 = limit - cursor;
1049             // hop, line 38
1050             {
1051                 int c = cursor - 2;
1052                 if (limit_backward > c || c > limit)
1053                 {
1054                     return false;
1055                 }
1056                 cursor = c;
1057             }
1058             cursor = limit - v_1;
1059             // or, line 38
1060             lab0: do {
1061                 v_2 = limit - cursor;
1062                 lab1: do {
1063                     // literal, line 38
1064                     if (!(eq_s_b(1, "n")))
1065                     {
1066                         break lab1;
1067                     }
1068                     break lab0;
1069                 } while (false);
1070                 cursor = limit - v_2;
1071                 // literal, line 38
1072                 if (!(eq_s_b(1, "r")))
1073                 {
1074                     return false;
1075                 }
1076             } while (false);
1077             return true;
1078         }
1079
1080         private boolean r_S() {
1081             int v_1;
1082             int v_2;
1083             int v_3;
1084             // (, line 39
1085             // test, line 39
1086             v_1 = limit - cursor;
1087             // hop, line 39
1088             {
1089                 int c = cursor - 2;
1090                 if (limit_backward > c || c > limit)
1091                 {
1092                     return false;
1093                 }
1094                 cursor = c;
1095             }
1096             cursor = limit - v_1;
1097             // or, line 39
1098             lab0: do {
1099                 v_2 = limit - cursor;
1100                 lab1: do {
1101                     // literal, line 39
1102                     if (!(eq_s_b(2, "dr")))
1103                     {
1104                         break lab1;
1105                     }
1106                     break lab0;
1107                 } while (false);
1108                 cursor = limit - v_2;
1109                 // (, line 39
1110                 // literal, line 39
1111                 if (!(eq_s_b(1, "t")))
1112                 {
1113                     return false;
1114                 }
1115                 // not, line 39
1116                 {
1117                     v_3 = limit - cursor;
1118                     lab2: do {
1119                         // literal, line 39
1120                         if (!(eq_s_b(1, "t")))
1121                         {
1122                             break lab2;
1123                         }
1124                         return false;
1125                     } while (false);
1126                     cursor = limit - v_3;
1127                 }
1128             } while (false);
1129             return true;
1130         }
1131
1132         private boolean r_T() {
1133             int v_1;
1134             int v_2;
1135             int v_3;
1136             // (, line 40
1137             // test, line 40
1138             v_1 = limit - cursor;
1139             // hop, line 40
1140             {
1141                 int c = cursor - 2;
1142                 if (limit_backward > c || c > limit)
1143                 {
1144                     return false;
1145                 }
1146                 cursor = c;
1147             }
1148             cursor = limit - v_1;
1149             // or, line 40
1150             lab0: do {
1151                 v_2 = limit - cursor;
1152                 lab1: do {
1153                     // literal, line 40
1154                     if (!(eq_s_b(1, "s")))
1155                     {
1156                         break lab1;
1157                     }
1158                     break lab0;
1159                 } while (false);
1160                 cursor = limit - v_2;
1161                 // (, line 40
1162                 // literal, line 40
1163                 if (!(eq_s_b(1, "t")))
1164                 {
1165                     return false;
1166                 }
1167                 // not, line 40
1168                 {
1169                     v_3 = limit - cursor;
1170                     lab2: do {
1171                         // literal, line 40
1172                         if (!(eq_s_b(1, "o")))
1173                         {
1174                             break lab2;
1175                         }
1176                         return false;
1177                     } while (false);
1178                     cursor = limit - v_3;
1179                 }
1180             } while (false);
1181             return true;
1182         }
1183
1184         private boolean r_U() {
1185             int v_1;
1186             int v_2;
1187             // (, line 41
1188             // test, line 41
1189             v_1 = limit - cursor;
1190             // hop, line 41
1191             {
1192                 int c = cursor - 2;
1193                 if (limit_backward > c || c > limit)
1194                 {
1195                     return false;
1196                 }
1197                 cursor = c;
1198             }
1199             cursor = limit - v_1;
1200             // or, line 41
1201             lab0: do {
1202                 v_2 = limit - cursor;
1203                 lab1: do {
1204                     // literal, line 41
1205                     if (!(eq_s_b(1, "l")))
1206                     {
1207                         break lab1;
1208                     }
1209                     break lab0;
1210                 } while (false);
1211                 cursor = limit - v_2;
1212                 lab2: do {
1213                     // literal, line 41
1214                     if (!(eq_s_b(1, "m")))
1215                     {
1216                         break lab2;
1217                     }
1218                     break lab0;
1219                 } while (false);
1220                 cursor = limit - v_2;
1221                 lab3: do {
1222                     // literal, line 41
1223                     if (!(eq_s_b(1, "n")))
1224                     {
1225                         break lab3;
1226                     }
1227                     break lab0;
1228                 } while (false);
1229                 cursor = limit - v_2;
1230                 // literal, line 41
1231                 if (!(eq_s_b(1, "r")))
1232                 {
1233                     return false;
1234                 }
1235             } while (false);
1236             return true;
1237         }
1238
1239         private boolean r_V() {
1240             int v_1;
1241             // (, line 42
1242             // test, line 42
1243             v_1 = limit - cursor;
1244             // hop, line 42
1245             {
1246                 int c = cursor - 2;
1247                 if (limit_backward > c || c > limit)
1248                 {
1249                     return false;
1250                 }
1251                 cursor = c;
1252             }
1253             cursor = limit - v_1;
1254             // literal, line 42
1255             if (!(eq_s_b(1, "c")))
1256             {
1257                 return false;
1258             }
1259             return true;
1260         }
1261
1262         private boolean r_W() {
1263             int v_1;
1264             int v_2;
1265             int v_3;
1266             // (, line 43
1267             // test, line 43
1268             v_1 = limit - cursor;
1269             // hop, line 43
1270             {
1271                 int c = cursor - 2;
1272                 if (limit_backward > c || c > limit)
1273                 {
1274                     return false;
1275                 }
1276                 cursor = c;
1277             }
1278             cursor = limit - v_1;
1279             // not, line 43
1280             {
1281                 v_2 = limit - cursor;
1282                 lab0: do {
1283                     // literal, line 43
1284                     if (!(eq_s_b(1, "s")))
1285                     {
1286                         break lab0;
1287                     }
1288                     return false;
1289                 } while (false);
1290                 cursor = limit - v_2;
1291             }
1292             // not, line 43
1293             {
1294                 v_3 = limit - cursor;
1295                 lab1: do {
1296                     // literal, line 43
1297                     if (!(eq_s_b(1, "u")))
1298                     {
1299                         break lab1;
1300                     }
1301                     return false;
1302                 } while (false);
1303                 cursor = limit - v_3;
1304             }
1305             return true;
1306         }
1307
1308         private boolean r_X() {
1309             int v_1;
1310             int v_2;
1311             // (, line 44
1312             // test, line 44
1313             v_1 = limit - cursor;
1314             // hop, line 44
1315             {
1316                 int c = cursor - 2;
1317                 if (limit_backward > c || c > limit)
1318                 {
1319                     return false;
1320                 }
1321                 cursor = c;
1322             }
1323             cursor = limit - v_1;
1324             // or, line 44
1325             lab0: do {
1326                 v_2 = limit - cursor;
1327                 lab1: do {
1328                     // literal, line 44
1329                     if (!(eq_s_b(1, "l")))
1330                     {
1331                         break lab1;
1332                     }
1333                     break lab0;
1334                 } while (false);
1335                 cursor = limit - v_2;
1336                 lab2: do {
1337                     // literal, line 44
1338                     if (!(eq_s_b(1, "i")))
1339                     {
1340                         break lab2;
1341                     }
1342                     break lab0;
1343                 } while (false);
1344                 cursor = limit - v_2;
1345                 // (, line 44
1346                 // literal, line 44
1347                 if (!(eq_s_b(1, "e")))
1348                 {
1349                     return false;
1350                 }
1351                 // next, line 44
1352                 if (cursor <= limit_backward)
1353                 {
1354                     return false;
1355                 }
1356                 cursor--;
1357                 // literal, line 44
1358                 if (!(eq_s_b(1, "u")))
1359                 {
1360                     return false;
1361                 }
1362             } while (false);
1363             return true;
1364         }
1365
1366         private boolean r_Y() {
1367             int v_1;
1368             // (, line 45
1369             // test, line 45
1370             v_1 = limit - cursor;
1371             // hop, line 45
1372             {
1373                 int c = cursor - 2;
1374                 if (limit_backward > c || c > limit)
1375                 {
1376                     return false;
1377                 }
1378                 cursor = c;
1379             }
1380             cursor = limit - v_1;
1381             // literal, line 45
1382             if (!(eq_s_b(2, "in")))
1383             {
1384                 return false;
1385             }
1386             return true;
1387         }
1388
1389         private boolean r_Z() {
1390             int v_1;
1391             int v_2;
1392             // (, line 46
1393             // test, line 46
1394             v_1 = limit - cursor;
1395             // hop, line 46
1396             {
1397                 int c = cursor - 2;
1398                 if (limit_backward > c || c > limit)
1399                 {
1400                     return false;
1401                 }
1402                 cursor = c;
1403             }
1404             cursor = limit - v_1;
1405             // not, line 46
1406             {
1407                 v_2 = limit - cursor;
1408                 lab0: do {
1409                     // literal, line 46
1410                     if (!(eq_s_b(1, "f")))
1411                     {
1412                         break lab0;
1413                     }
1414                     return false;
1415                 } while (false);
1416                 cursor = limit - v_2;
1417             }
1418             return true;
1419         }
1420
1421         private boolean r_AA() {
1422             int v_1;
1423             // (, line 47
1424             // test, line 47
1425             v_1 = limit - cursor;
1426             // hop, line 47
1427             {
1428                 int c = cursor - 2;
1429                 if (limit_backward > c || c > limit)
1430                 {
1431                     return false;
1432                 }
1433                 cursor = c;
1434             }
1435             cursor = limit - v_1;
1436             // among, line 47
1437             if (find_among_b(a_0, 9) == 0)
1438             {
1439                 return false;
1440             }
1441             return true;
1442         }
1443
1444         private boolean r_BB() {
1445             int v_1;
1446             int v_2;
1447             int v_3;
1448             // (, line 49
1449             // test, line 49
1450             v_1 = limit - cursor;
1451             // hop, line 49
1452             {
1453                 int c = cursor - 3;
1454                 if (limit_backward > c || c > limit)
1455                 {
1456                     return false;
1457                 }
1458                 cursor = c;
1459             }
1460             cursor = limit - v_1;
1461             // not, line 49
1462             {
1463                 v_2 = limit - cursor;
1464                 lab0: do {
1465                     // literal, line 49
1466                     if (!(eq_s_b(3, "met")))
1467                     {
1468                         break lab0;
1469                     }
1470                     return false;
1471                 } while (false);
1472                 cursor = limit - v_2;
1473             }
1474             // not, line 49
1475             {
1476                 v_3 = limit - cursor;
1477                 lab1: do {
1478                     // literal, line 49
1479                     if (!(eq_s_b(4, "ryst")))
1480                     {
1481                         break lab1;
1482                     }
1483                     return false;
1484                 } while (false);
1485                 cursor = limit - v_3;
1486             }
1487             return true;
1488         }
1489
1490         private boolean r_CC() {
1491             int v_1;
1492             // (, line 50
1493             // test, line 50
1494             v_1 = limit - cursor;
1495             // hop, line 50
1496             {
1497                 int c = cursor - 2;
1498                 if (limit_backward > c || c > limit)
1499                 {
1500                     return false;
1501                 }
1502                 cursor = c;
1503             }
1504             cursor = limit - v_1;
1505             // literal, line 50
1506             if (!(eq_s_b(1, "l")))
1507             {
1508                 return false;
1509             }
1510             return true;
1511         }
1512
1513         private boolean r_endings() {
1514             int among_var;
1515             // (, line 55
1516             // [, line 56
1517             ket = cursor;
1518             // substring, line 56
1519             among_var = find_among_b(a_1, 294);
1520             if (among_var == 0)
1521             {
1522                 return false;
1523             }
1524             // ], line 56
1525             bra = cursor;
1526             switch(among_var) {
1527                 case 0:
1528                     return false;
1529                 case 1:
1530                     // (, line 145
1531                     // delete, line 145
1532                     slice_del();
1533                     break;
1534             }
1535             return true;
1536         }
1537
1538         private boolean r_undouble() {
1539             int v_1;
1540             // (, line 151
1541             // test, line 152
1542             v_1 = limit - cursor;
1543             // substring, line 152
1544             if (find_among_b(a_2, 10) == 0)
1545             {
1546                 return false;
1547             }
1548             cursor = limit - v_1;
1549             // [, line 154
1550             ket = cursor;
1551             // next, line 154
1552             if (cursor <= limit_backward)
1553             {
1554                 return false;
1555             }
1556             cursor--;
1557             // ], line 154
1558             bra = cursor;
1559             // delete, line 154
1560             slice_del();
1561             return true;
1562         }
1563
1564         private boolean r_respell() {
1565             int among_var;
1566             int v_1;
1567             int v_2;
1568             int v_3;
1569             int v_4;
1570             int v_5;
1571             int v_6;
1572             int v_7;
1573             int v_8;
1574             // (, line 159
1575             // [, line 160
1576             ket = cursor;
1577             // substring, line 160
1578             among_var = find_among_b(a_3, 34);
1579             if (among_var == 0)
1580             {
1581                 return false;
1582             }
1583             // ], line 160
1584             bra = cursor;
1585             switch(among_var) {
1586                 case 0:
1587                     return false;
1588                 case 1:
1589                     // (, line 161
1590                     // <-, line 161
1591                     slice_from("ief");
1592                     break;
1593                 case 2:
1594                     // (, line 162
1595                     // <-, line 162
1596                     slice_from("uc");
1597                     break;
1598                 case 3:
1599                     // (, line 163
1600                     // <-, line 163
1601                     slice_from("um");
1602                     break;
1603                 case 4:
1604                     // (, line 164
1605                     // <-, line 164
1606                     slice_from("rb");
1607                     break;
1608                 case 5:
1609                     // (, line 165
1610                     // <-, line 165
1611                     slice_from("ur");
1612                     break;
1613                 case 6:
1614                     // (, line 166
1615                     // <-, line 166
1616                     slice_from("ister");
1617                     break;
1618                 case 7:
1619                     // (, line 167
1620                     // <-, line 167
1621                     slice_from("meter");
1622                     break;
1623                 case 8:
1624                     // (, line 168
1625                     // <-, line 168
1626                     slice_from("olut");
1627                     break;
1628                 case 9:
1629                     // (, line 169
1630                     // not, line 169
1631                     {
1632                         v_1 = limit - cursor;
1633                         lab0: do {
1634                             // literal, line 169
1635                             if (!(eq_s_b(1, "a")))
1636                             {
1637                                 break lab0;
1638                             }
1639                             return false;
1640                         } while (false);
1641                         cursor = limit - v_1;
1642                     }
1643                     // not, line 169
1644                     {
1645                         v_2 = limit - cursor;
1646                         lab1: do {
1647                             // literal, line 169
1648                             if (!(eq_s_b(1, "i")))
1649                             {
1650                                 break lab1;
1651                             }
1652                             return false;
1653                         } while (false);
1654                         cursor = limit - v_2;
1655                     }
1656                     // not, line 169
1657                     {
1658                         v_3 = limit - cursor;
1659                         lab2: do {
1660                             // literal, line 169
1661                             if (!(eq_s_b(1, "o")))
1662                             {
1663                                 break lab2;
1664                             }
1665                             return false;
1666                         } while (false);
1667                         cursor = limit - v_3;
1668                     }
1669                     // <-, line 169
1670                     slice_from("l");
1671                     break;
1672                 case 10:
1673                     // (, line 170
1674                     // <-, line 170
1675                     slice_from("bic");
1676                     break;
1677                 case 11:
1678                     // (, line 171
1679                     // <-, line 171
1680                     slice_from("dic");
1681                     break;
1682                 case 12:
1683                     // (, line 172
1684                     // <-, line 172
1685                     slice_from("pic");
1686                     break;
1687                 case 13:
1688                     // (, line 173
1689                     // <-, line 173
1690                     slice_from("tic");
1691                     break;
1692                 case 14:
1693                     // (, line 174
1694                     // <-, line 174
1695                     slice_from("ac");
1696                     break;
1697                 case 15:
1698                     // (, line 175
1699                     // <-, line 175
1700                     slice_from("ec");
1701                     break;
1702                 case 16:
1703                     // (, line 176
1704                     // <-, line 176
1705                     slice_from("ic");
1706                     break;
1707                 case 17:
1708                     // (, line 177
1709                     // <-, line 177
1710                     slice_from("luc");
1711                     break;
1712                 case 18:
1713                     // (, line 178
1714                     // <-, line 178
1715                     slice_from("uas");
1716                     break;
1717                 case 19:
1718                     // (, line 179
1719                     // <-, line 179
1720                     slice_from("vas");
1721                     break;
1722                 case 20:
1723                     // (, line 180
1724                     // <-, line 180
1725                     slice_from("cis");
1726                     break;
1727                 case 21:
1728                     // (, line 181
1729                     // <-, line 181
1730                     slice_from("lis");
1731                     break;
1732                 case 22:
1733                     // (, line 182
1734                     // <-, line 182
1735                     slice_from("eris");
1736                     break;
1737                 case 23:
1738                     // (, line 183
1739                     // <-, line 183
1740                     slice_from("pans");
1741                     break;
1742                 case 24:
1743                     // (, line 184
1744                     // not, line 184
1745                     {
1746                         v_4 = limit - cursor;
1747                         lab3: do {
1748                             // literal, line 184
1749                             if (!(eq_s_b(1, "s")))
1750                             {
1751                                 break lab3;
1752                             }
1753                             return false;
1754                         } while (false);
1755                         cursor = limit - v_4;
1756                     }
1757                     // <-, line 184
1758                     slice_from("ens");
1759                     break;
1760                 case 25:
1761                     // (, line 185
1762                     // <-, line 185
1763                     slice_from("ons");
1764                     break;
1765                 case 26:
1766                     // (, line 186
1767                     // <-, line 186
1768                     slice_from("lus");
1769                     break;
1770                 case 27:
1771                     // (, line 187
1772                     // <-, line 187
1773                     slice_from("rus");
1774                     break;
1775                 case 28:
1776                     // (, line 188
1777                     // not, line 188
1778                     {
1779                         v_5 = limit - cursor;
1780                         lab4: do {
1781                             // literal, line 188
1782                             if (!(eq_s_b(1, "p")))
1783                             {
1784                                 break lab4;
1785                             }
1786                             return false;
1787                         } while (false);
1788                         cursor = limit - v_5;
1789                     }
1790                     // not, line 188
1791                     {
1792                         v_6 = limit - cursor;
1793                         lab5: do {
1794                             // literal, line 188
1795                             if (!(eq_s_b(1, "t")))
1796                             {
1797                                 break lab5;
1798                             }
1799                             return false;
1800                         } while (false);
1801                         cursor = limit - v_6;
1802                     }
1803                     // <-, line 188
1804                     slice_from("hes");
1805                     break;
1806                 case 29:
1807                     // (, line 189
1808                     // <-, line 189
1809                     slice_from("mis");
1810                     break;
1811                 case 30:
1812                     // (, line 190
1813                     // not, line 190
1814                     {
1815                         v_7 = limit - cursor;
1816                         lab6: do {
1817                             // literal, line 190
1818                             if (!(eq_s_b(1, "m")))
1819                             {
1820                                 break lab6;
1821                             }
1822                             return false;
1823                         } while (false);
1824                         cursor = limit - v_7;
1825                     }
1826                     // <-, line 190
1827                     slice_from("ens");
1828                     break;
1829                 case 31:
1830                     // (, line 192
1831                     // <-, line 192
1832                     slice_from("ers");
1833                     break;
1834                 case 32:
1835                     // (, line 193
1836                     // not, line 193
1837                     {
1838                         v_8 = limit - cursor;
1839                         lab7: do {
1840                             // literal, line 193
1841                             if (!(eq_s_b(1, "n")))
1842                             {
1843                                 break lab7;
1844                             }
1845                             return false;
1846                         } while (false);
1847                         cursor = limit - v_8;
1848                     }
1849                     // <-, line 193
1850                     slice_from("es");
1851                     break;
1852                 case 33:
1853                     // (, line 194
1854                     // <-, line 194
1855                     slice_from("ys");
1856                     break;
1857                 case 34:
1858                     // (, line 195
1859                     // <-, line 195
1860                     slice_from("ys");
1861                     break;
1862             }
1863             return true;
1864         }
1865
1866         public boolean stem() {
1867             int v_1;
1868             int v_2;
1869             int v_3;
1870             // (, line 200
1871             // backwards, line 202
1872             limit_backward = cursor; cursor = limit;
1873             // (, line 202
1874             // do, line 203
1875             v_1 = limit - cursor;
1876             lab0: do {
1877                 // call endings, line 203
1878                 if (!r_endings())
1879                 {
1880                     break lab0;
1881                 }
1882             } while (false);
1883             cursor = limit - v_1;
1884             // do, line 204
1885             v_2 = limit - cursor;
1886             lab1: do {
1887                 // call undouble, line 204
1888                 if (!r_undouble())
1889                 {
1890                     break lab1;
1891                 }
1892             } while (false);
1893             cursor = limit - v_2;
1894             // do, line 205
1895             v_3 = limit - cursor;
1896             lab2: do {
1897                 // call respell, line 205
1898                 if (!r_respell())
1899                 {
1900                     break lab2;
1901                 }
1902             } while (false);
1903             cursor = limit - v_3;
1904             cursor = limit_backward;            return true;
1905         }
1906
1907 }
1908