0001: // This file was generated automatically by the Snowball to Java compiler
0002:
0003: package net.sf.snowball.ext;
0004:
0005: import net.sf.snowball.SnowballProgram;
0006: import net.sf.snowball.Among;
0007:
0008: /**
0009: * Generated class implementing code defined by a snowball script.
0010: */
0011: public class LovinsStemmer extends SnowballProgram {
0012:
0013: private Among a_0[] = { new Among("d", -1, -1, "", this ),
0014: new Among("f", -1, -1, "", this ),
0015: new Among("ph", -1, -1, "", this ),
0016: new Among("th", -1, -1, "", this ),
0017: new Among("l", -1, -1, "", this ),
0018: new Among("er", -1, -1, "", this ),
0019: new Among("or", -1, -1, "", this ),
0020: new Among("es", -1, -1, "", this ),
0021: new Among("t", -1, -1, "", this ) };
0022:
0023: private Among a_1[] = { new Among("s'", -1, 1, "r_A", this ),
0024: new Among("a", -1, 1, "r_A", this ),
0025: new Among("ia", 1, 1, "r_A", this ),
0026: new Among("ata", 1, 1, "r_A", this ),
0027: new Among("ic", -1, 1, "r_A", this ),
0028: new Among("aic", 4, 1, "r_A", this ),
0029: new Among("allic", 4, 1, "r_BB", this ),
0030: new Among("aric", 4, 1, "r_A", this ),
0031: new Among("atic", 4, 1, "r_B", this ),
0032: new Among("itic", 4, 1, "r_H", this ),
0033: new Among("antic", 4, 1, "r_C", this ),
0034: new Among("istic", 4, 1, "r_A", this ),
0035: new Among("alistic", 11, 1, "r_B", this ),
0036: new Among("aristic", 11, 1, "r_A", this ),
0037: new Among("ivistic", 11, 1, "r_A", this ),
0038: new Among("ed", -1, 1, "r_E", this ),
0039: new Among("anced", 15, 1, "r_B", this ),
0040: new Among("enced", 15, 1, "r_A", this ),
0041: new Among("ished", 15, 1, "r_A", this ),
0042: new Among("ied", 15, 1, "r_A", this ),
0043: new Among("ened", 15, 1, "r_E", this ),
0044: new Among("ioned", 15, 1, "r_A", this ),
0045: new Among("ated", 15, 1, "r_I", this ),
0046: new Among("ented", 15, 1, "r_C", this ),
0047: new Among("ized", 15, 1, "r_F", this ),
0048: new Among("arized", 24, 1, "r_A", this ),
0049: new Among("oid", -1, 1, "r_A", this ),
0050: new Among("aroid", 26, 1, "r_A", this ),
0051: new Among("hood", -1, 1, "r_A", this ),
0052: new Among("ehood", 28, 1, "r_A", this ),
0053: new Among("ihood", 28, 1, "r_A", this ),
0054: new Among("elihood", 30, 1, "r_E", this ),
0055: new Among("ward", -1, 1, "r_A", this ),
0056: new Among("e", -1, 1, "r_A", this ),
0057: new Among("ae", 33, 1, "r_A", this ),
0058: new Among("ance", 33, 1, "r_B", this ),
0059: new Among("icance", 35, 1, "r_A", this ),
0060: new Among("ence", 33, 1, "r_A", this ),
0061: new Among("ide", 33, 1, "r_L", this ),
0062: new Among("icide", 38, 1, "r_A", this ),
0063: new Among("otide", 38, 1, "r_A", this ),
0064: new Among("age", 33, 1, "r_B", this ),
0065: new Among("able", 33, 1, "r_A", this ),
0066: new Among("atable", 42, 1, "r_A", this ),
0067: new Among("izable", 42, 1, "r_E", this ),
0068: new Among("arizable", 44, 1, "r_A", this ),
0069: new Among("ible", 33, 1, "r_A", this ),
0070: new Among("encible", 46, 1, "r_A", this ),
0071: new Among("ene", 33, 1, "r_E", this ),
0072: new Among("ine", 33, 1, "r_M", this ),
0073: new Among("idine", 49, 1, "r_I", this ),
0074: new Among("one", 33, 1, "r_R", this ),
0075: new Among("ature", 33, 1, "r_E", this ),
0076: new Among("eature", 52, 1, "r_Z", this ),
0077: new Among("ese", 33, 1, "r_A", this ),
0078: new Among("wise", 33, 1, "r_A", this ),
0079: new Among("ate", 33, 1, "r_A", this ),
0080: new Among("entiate", 56, 1, "r_A", this ),
0081: new Among("inate", 56, 1, "r_A", this ),
0082: new Among("ionate", 56, 1, "r_D", this ),
0083: new Among("ite", 33, 1, "r_AA", this ),
0084: new Among("ive", 33, 1, "r_A", this ),
0085: new Among("ative", 61, 1, "r_A", this ),
0086: new Among("ize", 33, 1, "r_F", this ),
0087: new Among("alize", 63, 1, "r_A", this ),
0088: new Among("icalize", 64, 1, "r_A", this ),
0089: new Among("ialize", 64, 1, "r_A", this ),
0090: new Among("entialize", 66, 1, "r_A", this ),
0091: new Among("ionalize", 64, 1, "r_A", this ),
0092: new Among("arize", 63, 1, "r_A", this ),
0093: new Among("ing", -1, 1, "r_N", this ),
0094: new Among("ancing", 70, 1, "r_B", this ),
0095: new Among("encing", 70, 1, "r_A", this ),
0096: new Among("aging", 70, 1, "r_B", this ),
0097: new Among("ening", 70, 1, "r_E", this ),
0098: new Among("ioning", 70, 1, "r_A", this ),
0099: new Among("ating", 70, 1, "r_I", this ),
0100: new Among("enting", 70, 1, "r_C", this ),
0101: new Among("ying", 70, 1, "r_B", this ),
0102: new Among("izing", 70, 1, "r_F", this ),
0103: new Among("arizing", 79, 1, "r_A", this ),
0104: new Among("ish", -1, 1, "r_C", this ),
0105: new Among("yish", 81, 1, "r_A", this ),
0106: new Among("i", -1, 1, "r_A", this ),
0107: new Among("al", -1, 1, "r_BB", this ),
0108: new Among("ical", 84, 1, "r_A", this ),
0109: new Among("aical", 85, 1, "r_A", this ),
0110: new Among("istical", 85, 1, "r_A", this ),
0111: new Among("oidal", 84, 1, "r_A", this ),
0112: new Among("eal", 84, 1, "r_Y", this ),
0113: new Among("ial", 84, 1, "r_A", this ),
0114: new Among("ancial", 90, 1, "r_A", this ),
0115: new Among("arial", 90, 1, "r_A", this ),
0116: new Among("ential", 90, 1, "r_A", this ),
0117: new Among("ional", 84, 1, "r_A", this ),
0118: new Among("ational", 94, 1, "r_B", this ),
0119: new Among("izational", 95, 1, "r_A", this ),
0120: new Among("ental", 84, 1, "r_A", this ),
0121: new Among("ful", -1, 1, "r_A", this ),
0122: new Among("eful", 98, 1, "r_A", this ),
0123: new Among("iful", 98, 1, "r_A", this ),
0124: new Among("yl", -1, 1, "r_R", this ),
0125: new Among("ism", -1, 1, "r_B", this ),
0126: new Among("icism", 102, 1, "r_A", this ),
0127: new Among("oidism", 102, 1, "r_A", this ),
0128: new Among("alism", 102, 1, "r_B", this ),
0129: new Among("icalism", 105, 1, "r_A", this ),
0130: new Among("ionalism", 105, 1, "r_A", this ),
0131: new Among("inism", 102, 1, "r_J", this ),
0132: new Among("ativism", 102, 1, "r_A", this ),
0133: new Among("um", -1, 1, "r_U", this ),
0134: new Among("ium", 110, 1, "r_A", this ),
0135: new Among("ian", -1, 1, "r_A", this ),
0136: new Among("ician", 112, 1, "r_A", this ),
0137: new Among("en", -1, 1, "r_F", this ),
0138: new Among("ogen", 114, 1, "r_A", this ),
0139: new Among("on", -1, 1, "r_S", this ),
0140: new Among("ion", 116, 1, "r_Q", this ),
0141: new Among("ation", 117, 1, "r_B", this ),
0142: new Among("ication", 118, 1, "r_G", this ),
0143: new Among("entiation", 118, 1, "r_A", this ),
0144: new Among("ination", 118, 1, "r_A", this ),
0145: new Among("isation", 118, 1, "r_A", this ),
0146: new Among("arisation", 122, 1, "r_A", this ),
0147: new Among("entation", 118, 1, "r_A", this ),
0148: new Among("ization", 118, 1, "r_F", this ),
0149: new Among("arization", 125, 1, "r_A", this ),
0150: new Among("action", 117, 1, "r_G", this ),
0151: new Among("o", -1, 1, "r_A", this ),
0152: new Among("ar", -1, 1, "r_X", this ),
0153: new Among("ear", 129, 1, "r_Y", this ),
0154: new Among("ier", -1, 1, "r_A", this ),
0155: new Among("ariser", -1, 1, "r_A", this ),
0156: new Among("izer", -1, 1, "r_F", this ),
0157: new Among("arizer", 133, 1, "r_A", this ),
0158: new Among("or", -1, 1, "r_T", this ),
0159: new Among("ator", 135, 1, "r_A", this ),
0160: new Among("s", -1, 1, "r_W", this ),
0161: new Among("'s", 137, 1, "r_A", this ),
0162: new Among("as", 137, 1, "r_B", this ),
0163: new Among("ics", 137, 1, "r_A", this ),
0164: new Among("istics", 140, 1, "r_A", this ),
0165: new Among("es", 137, 1, "r_E", this ),
0166: new Among("ances", 142, 1, "r_B", this ),
0167: new Among("ences", 142, 1, "r_A", this ),
0168: new Among("ides", 142, 1, "r_L", this ),
0169: new Among("oides", 145, 1, "r_A", this ),
0170: new Among("ages", 142, 1, "r_B", this ),
0171: new Among("ies", 142, 1, "r_P", this ),
0172: new Among("acies", 148, 1, "r_A", this ),
0173: new Among("ancies", 148, 1, "r_A", this ),
0174: new Among("encies", 148, 1, "r_A", this ),
0175: new Among("aries", 148, 1, "r_A", this ),
0176: new Among("ities", 148, 1, "r_A", this ),
0177: new Among("alities", 153, 1, "r_A", this ),
0178: new Among("ivities", 153, 1, "r_A", this ),
0179: new Among("ines", 142, 1, "r_M", this ),
0180: new Among("nesses", 142, 1, "r_A", this ),
0181: new Among("ates", 142, 1, "r_A", this ),
0182: new Among("atives", 142, 1, "r_A", this ),
0183: new Among("ings", 137, 1, "r_N", this ),
0184: new Among("is", 137, 1, "r_A", this ),
0185: new Among("als", 137, 1, "r_BB", this ),
0186: new Among("ials", 162, 1, "r_A", this ),
0187: new Among("entials", 163, 1, "r_A", this ),
0188: new Among("ionals", 162, 1, "r_A", this ),
0189: new Among("isms", 137, 1, "r_B", this ),
0190: new Among("ians", 137, 1, "r_A", this ),
0191: new Among("icians", 167, 1, "r_A", this ),
0192: new Among("ions", 137, 1, "r_B", this ),
0193: new Among("ations", 169, 1, "r_B", this ),
0194: new Among("arisations", 170, 1, "r_A", this ),
0195: new Among("entations", 170, 1, "r_A", this ),
0196: new Among("izations", 170, 1, "r_A", this ),
0197: new Among("arizations", 173, 1, "r_A", this ),
0198: new Among("ars", 137, 1, "r_O", this ),
0199: new Among("iers", 137, 1, "r_A", this ),
0200: new Among("izers", 137, 1, "r_F", this ),
0201: new Among("ators", 137, 1, "r_A", this ),
0202: new Among("less", 137, 1, "r_A", this ),
0203: new Among("eless", 179, 1, "r_A", this ),
0204: new Among("ness", 137, 1, "r_A", this ),
0205: new Among("eness", 181, 1, "r_E", this ),
0206: new Among("ableness", 182, 1, "r_A", this ),
0207: new Among("eableness", 183, 1, "r_E", this ),
0208: new Among("ibleness", 182, 1, "r_A", this ),
0209: new Among("ateness", 182, 1, "r_A", this ),
0210: new Among("iteness", 182, 1, "r_A", this ),
0211: new Among("iveness", 182, 1, "r_A", this ),
0212: new Among("ativeness", 188, 1, "r_A", this ),
0213: new Among("ingness", 181, 1, "r_A", this ),
0214: new Among("ishness", 181, 1, "r_A", this ),
0215: new Among("iness", 181, 1, "r_A", this ),
0216: new Among("ariness", 192, 1, "r_E", this ),
0217: new Among("alness", 181, 1, "r_A", this ),
0218: new Among("icalness", 194, 1, "r_A", this ),
0219: new Among("antialness", 194, 1, "r_A", this ),
0220: new Among("entialness", 194, 1, "r_A", this ),
0221: new Among("ionalness", 194, 1, "r_A", this ),
0222: new Among("fulness", 181, 1, "r_A", this ),
0223: new Among("lessness", 181, 1, "r_A", this ),
0224: new Among("ousness", 181, 1, "r_A", this ),
0225: new Among("eousness", 201, 1, "r_A", this ),
0226: new Among("iousness", 201, 1, "r_A", this ),
0227: new Among("itousness", 201, 1, "r_A", this ),
0228: new Among("entness", 181, 1, "r_A", this ),
0229: new Among("ants", 137, 1, "r_B", this ),
0230: new Among("ists", 137, 1, "r_A", this ),
0231: new Among("icists", 207, 1, "r_A", this ),
0232: new Among("us", 137, 1, "r_V", this ),
0233: new Among("ous", 209, 1, "r_A", this ),
0234: new Among("eous", 210, 1, "r_A", this ),
0235: new Among("aceous", 211, 1, "r_A", this ),
0236: new Among("antaneous", 211, 1, "r_A", this ),
0237: new Among("ious", 210, 1, "r_A", this ),
0238: new Among("acious", 214, 1, "r_B", this ),
0239: new Among("itous", 210, 1, "r_A", this ),
0240: new Among("ant", -1, 1, "r_B", this ),
0241: new Among("icant", 217, 1, "r_A", this ),
0242: new Among("ent", -1, 1, "r_C", this ),
0243: new Among("ement", 219, 1, "r_A", this ),
0244: new Among("izement", 220, 1, "r_A", this ),
0245: new Among("ist", -1, 1, "r_A", this ),
0246: new Among("icist", 222, 1, "r_A", this ),
0247: new Among("alist", 222, 1, "r_A", this ),
0248: new Among("icalist", 224, 1, "r_A", this ),
0249: new Among("ialist", 224, 1, "r_A", this ),
0250: new Among("ionist", 222, 1, "r_A", this ),
0251: new Among("entist", 222, 1, "r_A", this ),
0252: new Among("y", -1, 1, "r_B", this ),
0253: new Among("acy", 229, 1, "r_A", this ),
0254: new Among("ancy", 229, 1, "r_B", this ),
0255: new Among("ency", 229, 1, "r_A", this ),
0256: new Among("ly", 229, 1, "r_B", this ),
0257: new Among("ealy", 233, 1, "r_Y", this ),
0258: new Among("ably", 233, 1, "r_A", this ),
0259: new Among("ibly", 233, 1, "r_A", this ),
0260: new Among("edly", 233, 1, "r_E", this ),
0261: new Among("iedly", 237, 1, "r_A", this ),
0262: new Among("ely", 233, 1, "r_E", this ),
0263: new Among("ately", 239, 1, "r_A", this ),
0264: new Among("ively", 239, 1, "r_A", this ),
0265: new Among("atively", 241, 1, "r_A", this ),
0266: new Among("ingly", 233, 1, "r_B", this ),
0267: new Among("atingly", 243, 1, "r_A", this ),
0268: new Among("ily", 233, 1, "r_A", this ),
0269: new Among("lily", 245, 1, "r_A", this ),
0270: new Among("arily", 245, 1, "r_A", this ),
0271: new Among("ally", 233, 1, "r_B", this ),
0272: new Among("ically", 248, 1, "r_A", this ),
0273: new Among("aically", 249, 1, "r_A", this ),
0274: new Among("allically", 249, 1, "r_C", this ),
0275: new Among("istically", 249, 1, "r_A", this ),
0276: new Among("alistically", 252, 1, "r_B", this ),
0277: new Among("oidally", 248, 1, "r_A", this ),
0278: new Among("ially", 248, 1, "r_A", this ),
0279: new Among("entially", 255, 1, "r_A", this ),
0280: new Among("ionally", 248, 1, "r_A", this ),
0281: new Among("ationally", 257, 1, "r_B", this ),
0282: new Among("izationally", 258, 1, "r_B", this ),
0283: new Among("entally", 248, 1, "r_A", this ),
0284: new Among("fully", 233, 1, "r_A", this ),
0285: new Among("efully", 261, 1, "r_A", this ),
0286: new Among("ifully", 261, 1, "r_A", this ),
0287: new Among("enly", 233, 1, "r_E", this ),
0288: new Among("arly", 233, 1, "r_K", this ),
0289: new Among("early", 265, 1, "r_Y", this ),
0290: new Among("lessly", 233, 1, "r_A", this ),
0291: new Among("ously", 233, 1, "r_A", this ),
0292: new Among("eously", 268, 1, "r_A", this ),
0293: new Among("iously", 268, 1, "r_A", this ),
0294: new Among("ently", 233, 1, "r_A", this ),
0295: new Among("ary", 229, 1, "r_F", this ),
0296: new Among("ery", 229, 1, "r_E", this ),
0297: new Among("icianry", 229, 1, "r_A", this ),
0298: new Among("atory", 229, 1, "r_A", this ),
0299: new Among("ity", 229, 1, "r_A", this ),
0300: new Among("acity", 276, 1, "r_A", this ),
0301: new Among("icity", 276, 1, "r_A", this ),
0302: new Among("eity", 276, 1, "r_A", this ),
0303: new Among("ality", 276, 1, "r_A", this ),
0304: new Among("icality", 280, 1, "r_A", this ),
0305: new Among("iality", 280, 1, "r_A", this ),
0306: new Among("antiality", 282, 1, "r_A", this ),
0307: new Among("entiality", 282, 1, "r_A", this ),
0308: new Among("ionality", 280, 1, "r_A", this ),
0309: new Among("elity", 276, 1, "r_A", this ),
0310: new Among("ability", 276, 1, "r_A", this ),
0311: new Among("izability", 287, 1, "r_A", this ),
0312: new Among("arizability", 288, 1, "r_A", this ),
0313: new Among("ibility", 276, 1, "r_A", this ),
0314: new Among("inity", 276, 1, "r_CC", this ),
0315: new Among("arity", 276, 1, "r_B", this ),
0316: new Among("ivity", 276, 1, "r_A", this ) };
0317:
0318: private Among a_2[] = { new Among("bb", -1, -1, "", this ),
0319: new Among("dd", -1, -1, "", this ),
0320: new Among("gg", -1, -1, "", this ),
0321: new Among("ll", -1, -1, "", this ),
0322: new Among("mm", -1, -1, "", this ),
0323: new Among("nn", -1, -1, "", this ),
0324: new Among("pp", -1, -1, "", this ),
0325: new Among("rr", -1, -1, "", this ),
0326: new Among("ss", -1, -1, "", this ),
0327: new Among("tt", -1, -1, "", this ) };
0328:
0329: private Among a_3[] = { new Among("uad", -1, 18, "", this ),
0330: new Among("vad", -1, 19, "", this ),
0331: new Among("cid", -1, 20, "", this ),
0332: new Among("lid", -1, 21, "", this ),
0333: new Among("erid", -1, 22, "", this ),
0334: new Among("pand", -1, 23, "", this ),
0335: new Among("end", -1, 24, "", this ),
0336: new Among("ond", -1, 25, "", this ),
0337: new Among("lud", -1, 26, "", this ),
0338: new Among("rud", -1, 27, "", this ),
0339: new Among("ul", -1, 9, "", this ),
0340: new Among("her", -1, 28, "", this ),
0341: new Among("metr", -1, 7, "", this ),
0342: new Among("istr", -1, 6, "", this ),
0343: new Among("urs", -1, 5, "", this ),
0344: new Among("uct", -1, 2, "", this ),
0345: new Among("et", -1, 32, "", this ),
0346: new Among("mit", -1, 29, "", this ),
0347: new Among("ent", -1, 30, "", this ),
0348: new Among("umpt", -1, 3, "", this ),
0349: new Among("rpt", -1, 4, "", this ),
0350: new Among("ert", -1, 31, "", this ),
0351: new Among("yt", -1, 33, "", this ),
0352: new Among("iev", -1, 1, "", this ),
0353: new Among("olv", -1, 8, "", this ),
0354: new Among("ax", -1, 14, "", this ),
0355: new Among("ex", -1, 15, "", this ),
0356: new Among("bex", 26, 10, "", this ),
0357: new Among("dex", 26, 11, "", this ),
0358: new Among("pex", 26, 12, "", this ),
0359: new Among("tex", 26, 13, "", this ),
0360: new Among("ix", -1, 16, "", this ),
0361: new Among("lux", -1, 17, "", this ),
0362: new Among("yz", -1, 34, "", this ) };
0363:
0364: private void copy_from(LovinsStemmer other) {
0365: super .copy_from(other);
0366: }
0367:
0368: private boolean r_A() {
0369: // (, line 21
0370: // hop, line 21
0371: {
0372: int c = cursor - 2;
0373: if (limit_backward > c || c > limit) {
0374: return false;
0375: }
0376: cursor = c;
0377: }
0378: return true;
0379: }
0380:
0381: private boolean r_B() {
0382: // (, line 22
0383: // hop, line 22
0384: {
0385: int c = cursor - 3;
0386: if (limit_backward > c || c > limit) {
0387: return false;
0388: }
0389: cursor = c;
0390: }
0391: return true;
0392: }
0393:
0394: private boolean r_C() {
0395: // (, line 23
0396: // hop, line 23
0397: {
0398: int c = cursor - 4;
0399: if (limit_backward > c || c > limit) {
0400: return false;
0401: }
0402: cursor = c;
0403: }
0404: return true;
0405: }
0406:
0407: private boolean r_D() {
0408: // (, line 24
0409: // hop, line 24
0410: {
0411: int c = cursor - 5;
0412: if (limit_backward > c || c > limit) {
0413: return false;
0414: }
0415: cursor = c;
0416: }
0417: return true;
0418: }
0419:
0420: private boolean r_E() {
0421: int v_1;
0422: int v_2;
0423: // (, line 25
0424: // test, line 25
0425: v_1 = limit - cursor;
0426: // hop, line 25
0427: {
0428: int c = cursor - 2;
0429: if (limit_backward > c || c > limit) {
0430: return false;
0431: }
0432: cursor = c;
0433: }
0434: cursor = limit - v_1;
0435: // not, line 25
0436: {
0437: v_2 = limit - cursor;
0438: lab0: do {
0439: // literal, line 25
0440: if (!(eq_s_b(1, "e"))) {
0441: break lab0;
0442: }
0443: return false;
0444: } while (false);
0445: cursor = limit - v_2;
0446: }
0447: return true;
0448: }
0449:
0450: private boolean r_F() {
0451: int v_1;
0452: int v_2;
0453: // (, line 26
0454: // test, line 26
0455: v_1 = limit - cursor;
0456: // hop, line 26
0457: {
0458: int c = cursor - 3;
0459: if (limit_backward > c || c > limit) {
0460: return false;
0461: }
0462: cursor = c;
0463: }
0464: cursor = limit - v_1;
0465: // not, line 26
0466: {
0467: v_2 = limit - cursor;
0468: lab0: do {
0469: // literal, line 26
0470: if (!(eq_s_b(1, "e"))) {
0471: break lab0;
0472: }
0473: return false;
0474: } while (false);
0475: cursor = limit - v_2;
0476: }
0477: return true;
0478: }
0479:
0480: private boolean r_G() {
0481: int v_1;
0482: // (, line 27
0483: // test, line 27
0484: v_1 = limit - cursor;
0485: // hop, line 27
0486: {
0487: int c = cursor - 3;
0488: if (limit_backward > c || c > limit) {
0489: return false;
0490: }
0491: cursor = c;
0492: }
0493: cursor = limit - v_1;
0494: // literal, line 27
0495: if (!(eq_s_b(1, "f"))) {
0496: return false;
0497: }
0498: return true;
0499: }
0500:
0501: private boolean r_H() {
0502: int v_1;
0503: int v_2;
0504: // (, line 28
0505: // test, line 28
0506: v_1 = limit - cursor;
0507: // hop, line 28
0508: {
0509: int c = cursor - 2;
0510: if (limit_backward > c || c > limit) {
0511: return false;
0512: }
0513: cursor = c;
0514: }
0515: cursor = limit - v_1;
0516: // or, line 28
0517: lab0: do {
0518: v_2 = limit - cursor;
0519: lab1: do {
0520: // literal, line 28
0521: if (!(eq_s_b(1, "t"))) {
0522: break lab1;
0523: }
0524: break lab0;
0525: } while (false);
0526: cursor = limit - v_2;
0527: // literal, line 28
0528: if (!(eq_s_b(2, "ll"))) {
0529: return false;
0530: }
0531: } while (false);
0532: return true;
0533: }
0534:
0535: private boolean r_I() {
0536: int v_1;
0537: int v_2;
0538: int v_3;
0539: // (, line 29
0540: // test, line 29
0541: v_1 = limit - cursor;
0542: // hop, line 29
0543: {
0544: int c = cursor - 2;
0545: if (limit_backward > c || c > limit) {
0546: return false;
0547: }
0548: cursor = c;
0549: }
0550: cursor = limit - v_1;
0551: // not, line 29
0552: {
0553: v_2 = limit - cursor;
0554: lab0: do {
0555: // literal, line 29
0556: if (!(eq_s_b(1, "o"))) {
0557: break lab0;
0558: }
0559: return false;
0560: } while (false);
0561: cursor = limit - v_2;
0562: }
0563: // not, line 29
0564: {
0565: v_3 = limit - cursor;
0566: lab1: do {
0567: // literal, line 29
0568: if (!(eq_s_b(1, "e"))) {
0569: break lab1;
0570: }
0571: return false;
0572: } while (false);
0573: cursor = limit - v_3;
0574: }
0575: return true;
0576: }
0577:
0578: private boolean r_J() {
0579: int v_1;
0580: int v_2;
0581: int v_3;
0582: // (, line 30
0583: // test, line 30
0584: v_1 = limit - cursor;
0585: // hop, line 30
0586: {
0587: int c = cursor - 2;
0588: if (limit_backward > c || c > limit) {
0589: return false;
0590: }
0591: cursor = c;
0592: }
0593: cursor = limit - v_1;
0594: // not, line 30
0595: {
0596: v_2 = limit - cursor;
0597: lab0: do {
0598: // literal, line 30
0599: if (!(eq_s_b(1, "a"))) {
0600: break lab0;
0601: }
0602: return false;
0603: } while (false);
0604: cursor = limit - v_2;
0605: }
0606: // not, line 30
0607: {
0608: v_3 = limit - cursor;
0609: lab1: do {
0610: // literal, line 30
0611: if (!(eq_s_b(1, "e"))) {
0612: break lab1;
0613: }
0614: return false;
0615: } while (false);
0616: cursor = limit - v_3;
0617: }
0618: return true;
0619: }
0620:
0621: private boolean r_K() {
0622: int v_1;
0623: int v_2;
0624: // (, line 31
0625: // test, line 31
0626: v_1 = limit - cursor;
0627: // hop, line 31
0628: {
0629: int c = cursor - 3;
0630: if (limit_backward > c || c > limit) {
0631: return false;
0632: }
0633: cursor = c;
0634: }
0635: cursor = limit - v_1;
0636: // or, line 31
0637: lab0: do {
0638: v_2 = limit - cursor;
0639: lab1: do {
0640: // literal, line 31
0641: if (!(eq_s_b(1, "l"))) {
0642: break lab1;
0643: }
0644: break lab0;
0645: } while (false);
0646: cursor = limit - v_2;
0647: lab2: do {
0648: // literal, line 31
0649: if (!(eq_s_b(1, "i"))) {
0650: break lab2;
0651: }
0652: break lab0;
0653: } while (false);
0654: cursor = limit - v_2;
0655: // (, line 31
0656: // literal, line 31
0657: if (!(eq_s_b(1, "e"))) {
0658: return false;
0659: }
0660: // next, line 31
0661: if (cursor <= limit_backward) {
0662: return false;
0663: }
0664: cursor--;
0665: // literal, line 31
0666: if (!(eq_s_b(1, "u"))) {
0667: return false;
0668: }
0669: } while (false);
0670: return true;
0671: }
0672:
0673: private boolean r_L() {
0674: int v_1;
0675: int v_2;
0676: int v_3;
0677: int v_4;
0678: int v_5;
0679: // (, line 32
0680: // test, line 32
0681: v_1 = limit - cursor;
0682: // hop, line 32
0683: {
0684: int c = cursor - 2;
0685: if (limit_backward > c || c > limit) {
0686: return false;
0687: }
0688: cursor = c;
0689: }
0690: cursor = limit - v_1;
0691: // not, line 32
0692: {
0693: v_2 = limit - cursor;
0694: lab0: do {
0695: // literal, line 32
0696: if (!(eq_s_b(1, "u"))) {
0697: break lab0;
0698: }
0699: return false;
0700: } while (false);
0701: cursor = limit - v_2;
0702: }
0703: // not, line 32
0704: {
0705: v_3 = limit - cursor;
0706: lab1: do {
0707: // literal, line 32
0708: if (!(eq_s_b(1, "x"))) {
0709: break lab1;
0710: }
0711: return false;
0712: } while (false);
0713: cursor = limit - v_3;
0714: }
0715: // not, line 32
0716: {
0717: v_4 = limit - cursor;
0718: lab2: do {
0719: // (, line 32
0720: // literal, line 32
0721: if (!(eq_s_b(1, "s"))) {
0722: break lab2;
0723: }
0724: // not, line 32
0725: {
0726: v_5 = limit - cursor;
0727: lab3: do {
0728: // literal, line 32
0729: if (!(eq_s_b(1, "o"))) {
0730: break lab3;
0731: }
0732: break lab2;
0733: } while (false);
0734: cursor = limit - v_5;
0735: }
0736: return false;
0737: } while (false);
0738: cursor = limit - v_4;
0739: }
0740: return true;
0741: }
0742:
0743: private boolean r_M() {
0744: int v_1;
0745: int v_2;
0746: int v_3;
0747: int v_4;
0748: int v_5;
0749: // (, line 33
0750: // test, line 33
0751: v_1 = limit - cursor;
0752: // hop, line 33
0753: {
0754: int c = cursor - 2;
0755: if (limit_backward > c || c > limit) {
0756: return false;
0757: }
0758: cursor = c;
0759: }
0760: cursor = limit - v_1;
0761: // not, line 33
0762: {
0763: v_2 = limit - cursor;
0764: lab0: do {
0765: // literal, line 33
0766: if (!(eq_s_b(1, "a"))) {
0767: break lab0;
0768: }
0769: return false;
0770: } while (false);
0771: cursor = limit - v_2;
0772: }
0773: // not, line 33
0774: {
0775: v_3 = limit - cursor;
0776: lab1: do {
0777: // literal, line 33
0778: if (!(eq_s_b(1, "c"))) {
0779: break lab1;
0780: }
0781: return false;
0782: } while (false);
0783: cursor = limit - v_3;
0784: }
0785: // not, line 33
0786: {
0787: v_4 = limit - cursor;
0788: lab2: do {
0789: // literal, line 33
0790: if (!(eq_s_b(1, "e"))) {
0791: break lab2;
0792: }
0793: return false;
0794: } while (false);
0795: cursor = limit - v_4;
0796: }
0797: // not, line 33
0798: {
0799: v_5 = limit - cursor;
0800: lab3: do {
0801: // literal, line 33
0802: if (!(eq_s_b(1, "m"))) {
0803: break lab3;
0804: }
0805: return false;
0806: } while (false);
0807: cursor = limit - v_5;
0808: }
0809: return true;
0810: }
0811:
0812: private boolean r_N() {
0813: int v_1;
0814: int v_2;
0815: int v_3;
0816: // (, line 34
0817: // test, line 34
0818: v_1 = limit - cursor;
0819: // hop, line 34
0820: {
0821: int c = cursor - 3;
0822: if (limit_backward > c || c > limit) {
0823: return false;
0824: }
0825: cursor = c;
0826: }
0827: cursor = limit - v_1;
0828: // (, line 34
0829: // hop, line 34
0830: {
0831: int c = cursor - 2;
0832: if (limit_backward > c || c > limit) {
0833: return false;
0834: }
0835: cursor = c;
0836: }
0837: // or, line 34
0838: lab0: do {
0839: v_2 = limit - cursor;
0840: lab1: do {
0841: // not, line 34
0842: {
0843: v_3 = limit - cursor;
0844: lab2: do {
0845: // literal, line 34
0846: if (!(eq_s_b(1, "s"))) {
0847: break lab2;
0848: }
0849: break lab1;
0850: } while (false);
0851: cursor = limit - v_3;
0852: }
0853: break lab0;
0854: } while (false);
0855: cursor = limit - v_2;
0856: // hop, line 34
0857: {
0858: int c = cursor - 2;
0859: if (limit_backward > c || c > limit) {
0860: return false;
0861: }
0862: cursor = c;
0863: }
0864: } while (false);
0865: return true;
0866: }
0867:
0868: private boolean r_O() {
0869: int v_1;
0870: int v_2;
0871: // (, line 35
0872: // test, line 35
0873: v_1 = limit - cursor;
0874: // hop, line 35
0875: {
0876: int c = cursor - 2;
0877: if (limit_backward > c || c > limit) {
0878: return false;
0879: }
0880: cursor = c;
0881: }
0882: cursor = limit - v_1;
0883: // or, line 35
0884: lab0: do {
0885: v_2 = limit - cursor;
0886: lab1: do {
0887: // literal, line 35
0888: if (!(eq_s_b(1, "l"))) {
0889: break lab1;
0890: }
0891: break lab0;
0892: } while (false);
0893: cursor = limit - v_2;
0894: // literal, line 35
0895: if (!(eq_s_b(1, "i"))) {
0896: return false;
0897: }
0898: } while (false);
0899: return true;
0900: }
0901:
0902: private boolean r_P() {
0903: int v_1;
0904: int v_2;
0905: // (, line 36
0906: // test, line 36
0907: v_1 = limit - cursor;
0908: // hop, line 36
0909: {
0910: int c = cursor - 2;
0911: if (limit_backward > c || c > limit) {
0912: return false;
0913: }
0914: cursor = c;
0915: }
0916: cursor = limit - v_1;
0917: // not, line 36
0918: {
0919: v_2 = limit - cursor;
0920: lab0: do {
0921: // literal, line 36
0922: if (!(eq_s_b(1, "c"))) {
0923: break lab0;
0924: }
0925: return false;
0926: } while (false);
0927: cursor = limit - v_2;
0928: }
0929: return true;
0930: }
0931:
0932: private boolean r_Q() {
0933: int v_1;
0934: int v_2;
0935: int v_3;
0936: int v_4;
0937: // (, line 37
0938: // test, line 37
0939: v_1 = limit - cursor;
0940: // hop, line 37
0941: {
0942: int c = cursor - 2;
0943: if (limit_backward > c || c > limit) {
0944: return false;
0945: }
0946: cursor = c;
0947: }
0948: cursor = limit - v_1;
0949: // test, line 37
0950: v_2 = limit - cursor;
0951: // hop, line 37
0952: {
0953: int c = cursor - 3;
0954: if (limit_backward > c || c > limit) {
0955: return false;
0956: }
0957: cursor = c;
0958: }
0959: cursor = limit - v_2;
0960: // not, line 37
0961: {
0962: v_3 = limit - cursor;
0963: lab0: do {
0964: // literal, line 37
0965: if (!(eq_s_b(1, "l"))) {
0966: break lab0;
0967: }
0968: return false;
0969: } while (false);
0970: cursor = limit - v_3;
0971: }
0972: // not, line 37
0973: {
0974: v_4 = limit - cursor;
0975: lab1: do {
0976: // literal, line 37
0977: if (!(eq_s_b(1, "n"))) {
0978: break lab1;
0979: }
0980: return false;
0981: } while (false);
0982: cursor = limit - v_4;
0983: }
0984: return true;
0985: }
0986:
0987: private boolean r_R() {
0988: int v_1;
0989: int v_2;
0990: // (, line 38
0991: // test, line 38
0992: v_1 = limit - cursor;
0993: // hop, line 38
0994: {
0995: int c = cursor - 2;
0996: if (limit_backward > c || c > limit) {
0997: return false;
0998: }
0999: cursor = c;
1000: }
1001: cursor = limit - v_1;
1002: // or, line 38
1003: lab0: do {
1004: v_2 = limit - cursor;
1005: lab1: do {
1006: // literal, line 38
1007: if (!(eq_s_b(1, "n"))) {
1008: break lab1;
1009: }
1010: break lab0;
1011: } while (false);
1012: cursor = limit - v_2;
1013: // literal, line 38
1014: if (!(eq_s_b(1, "r"))) {
1015: return false;
1016: }
1017: } while (false);
1018: return true;
1019: }
1020:
1021: private boolean r_S() {
1022: int v_1;
1023: int v_2;
1024: int v_3;
1025: // (, line 39
1026: // test, line 39
1027: v_1 = limit - cursor;
1028: // hop, line 39
1029: {
1030: int c = cursor - 2;
1031: if (limit_backward > c || c > limit) {
1032: return false;
1033: }
1034: cursor = c;
1035: }
1036: cursor = limit - v_1;
1037: // or, line 39
1038: lab0: do {
1039: v_2 = limit - cursor;
1040: lab1: do {
1041: // literal, line 39
1042: if (!(eq_s_b(2, "dr"))) {
1043: break lab1;
1044: }
1045: break lab0;
1046: } while (false);
1047: cursor = limit - v_2;
1048: // (, line 39
1049: // literal, line 39
1050: if (!(eq_s_b(1, "t"))) {
1051: return false;
1052: }
1053: // not, line 39
1054: {
1055: v_3 = limit - cursor;
1056: lab2: do {
1057: // literal, line 39
1058: if (!(eq_s_b(1, "t"))) {
1059: break lab2;
1060: }
1061: return false;
1062: } while (false);
1063: cursor = limit - v_3;
1064: }
1065: } while (false);
1066: return true;
1067: }
1068:
1069: private boolean r_T() {
1070: int v_1;
1071: int v_2;
1072: int v_3;
1073: // (, line 40
1074: // test, line 40
1075: v_1 = limit - cursor;
1076: // hop, line 40
1077: {
1078: int c = cursor - 2;
1079: if (limit_backward > c || c > limit) {
1080: return false;
1081: }
1082: cursor = c;
1083: }
1084: cursor = limit - v_1;
1085: // or, line 40
1086: lab0: do {
1087: v_2 = limit - cursor;
1088: lab1: do {
1089: // literal, line 40
1090: if (!(eq_s_b(1, "s"))) {
1091: break lab1;
1092: }
1093: break lab0;
1094: } while (false);
1095: cursor = limit - v_2;
1096: // (, line 40
1097: // literal, line 40
1098: if (!(eq_s_b(1, "t"))) {
1099: return false;
1100: }
1101: // not, line 40
1102: {
1103: v_3 = limit - cursor;
1104: lab2: do {
1105: // literal, line 40
1106: if (!(eq_s_b(1, "o"))) {
1107: break lab2;
1108: }
1109: return false;
1110: } while (false);
1111: cursor = limit - v_3;
1112: }
1113: } while (false);
1114: return true;
1115: }
1116:
1117: private boolean r_U() {
1118: int v_1;
1119: int v_2;
1120: // (, line 41
1121: // test, line 41
1122: v_1 = limit - cursor;
1123: // hop, line 41
1124: {
1125: int c = cursor - 2;
1126: if (limit_backward > c || c > limit) {
1127: return false;
1128: }
1129: cursor = c;
1130: }
1131: cursor = limit - v_1;
1132: // or, line 41
1133: lab0: do {
1134: v_2 = limit - cursor;
1135: lab1: do {
1136: // literal, line 41
1137: if (!(eq_s_b(1, "l"))) {
1138: break lab1;
1139: }
1140: break lab0;
1141: } while (false);
1142: cursor = limit - v_2;
1143: lab2: do {
1144: // literal, line 41
1145: if (!(eq_s_b(1, "m"))) {
1146: break lab2;
1147: }
1148: break lab0;
1149: } while (false);
1150: cursor = limit - v_2;
1151: lab3: do {
1152: // literal, line 41
1153: if (!(eq_s_b(1, "n"))) {
1154: break lab3;
1155: }
1156: break lab0;
1157: } while (false);
1158: cursor = limit - v_2;
1159: // literal, line 41
1160: if (!(eq_s_b(1, "r"))) {
1161: return false;
1162: }
1163: } while (false);
1164: return true;
1165: }
1166:
1167: private boolean r_V() {
1168: int v_1;
1169: // (, line 42
1170: // test, line 42
1171: v_1 = limit - cursor;
1172: // hop, line 42
1173: {
1174: int c = cursor - 2;
1175: if (limit_backward > c || c > limit) {
1176: return false;
1177: }
1178: cursor = c;
1179: }
1180: cursor = limit - v_1;
1181: // literal, line 42
1182: if (!(eq_s_b(1, "c"))) {
1183: return false;
1184: }
1185: return true;
1186: }
1187:
1188: private boolean r_W() {
1189: int v_1;
1190: int v_2;
1191: int v_3;
1192: // (, line 43
1193: // test, line 43
1194: v_1 = limit - cursor;
1195: // hop, line 43
1196: {
1197: int c = cursor - 2;
1198: if (limit_backward > c || c > limit) {
1199: return false;
1200: }
1201: cursor = c;
1202: }
1203: cursor = limit - v_1;
1204: // not, line 43
1205: {
1206: v_2 = limit - cursor;
1207: lab0: do {
1208: // literal, line 43
1209: if (!(eq_s_b(1, "s"))) {
1210: break lab0;
1211: }
1212: return false;
1213: } while (false);
1214: cursor = limit - v_2;
1215: }
1216: // not, line 43
1217: {
1218: v_3 = limit - cursor;
1219: lab1: do {
1220: // literal, line 43
1221: if (!(eq_s_b(1, "u"))) {
1222: break lab1;
1223: }
1224: return false;
1225: } while (false);
1226: cursor = limit - v_3;
1227: }
1228: return true;
1229: }
1230:
1231: private boolean r_X() {
1232: int v_1;
1233: int v_2;
1234: // (, line 44
1235: // test, line 44
1236: v_1 = limit - cursor;
1237: // hop, line 44
1238: {
1239: int c = cursor - 2;
1240: if (limit_backward > c || c > limit) {
1241: return false;
1242: }
1243: cursor = c;
1244: }
1245: cursor = limit - v_1;
1246: // or, line 44
1247: lab0: do {
1248: v_2 = limit - cursor;
1249: lab1: do {
1250: // literal, line 44
1251: if (!(eq_s_b(1, "l"))) {
1252: break lab1;
1253: }
1254: break lab0;
1255: } while (false);
1256: cursor = limit - v_2;
1257: lab2: do {
1258: // literal, line 44
1259: if (!(eq_s_b(1, "i"))) {
1260: break lab2;
1261: }
1262: break lab0;
1263: } while (false);
1264: cursor = limit - v_2;
1265: // (, line 44
1266: // literal, line 44
1267: if (!(eq_s_b(1, "e"))) {
1268: return false;
1269: }
1270: // next, line 44
1271: if (cursor <= limit_backward) {
1272: return false;
1273: }
1274: cursor--;
1275: // literal, line 44
1276: if (!(eq_s_b(1, "u"))) {
1277: return false;
1278: }
1279: } while (false);
1280: return true;
1281: }
1282:
1283: private boolean r_Y() {
1284: int v_1;
1285: // (, line 45
1286: // test, line 45
1287: v_1 = limit - cursor;
1288: // hop, line 45
1289: {
1290: int c = cursor - 2;
1291: if (limit_backward > c || c > limit) {
1292: return false;
1293: }
1294: cursor = c;
1295: }
1296: cursor = limit - v_1;
1297: // literal, line 45
1298: if (!(eq_s_b(2, "in"))) {
1299: return false;
1300: }
1301: return true;
1302: }
1303:
1304: private boolean r_Z() {
1305: int v_1;
1306: int v_2;
1307: // (, line 46
1308: // test, line 46
1309: v_1 = limit - cursor;
1310: // hop, line 46
1311: {
1312: int c = cursor - 2;
1313: if (limit_backward > c || c > limit) {
1314: return false;
1315: }
1316: cursor = c;
1317: }
1318: cursor = limit - v_1;
1319: // not, line 46
1320: {
1321: v_2 = limit - cursor;
1322: lab0: do {
1323: // literal, line 46
1324: if (!(eq_s_b(1, "f"))) {
1325: break lab0;
1326: }
1327: return false;
1328: } while (false);
1329: cursor = limit - v_2;
1330: }
1331: return true;
1332: }
1333:
1334: private boolean r_AA() {
1335: int v_1;
1336: // (, line 47
1337: // test, line 47
1338: v_1 = limit - cursor;
1339: // hop, line 47
1340: {
1341: int c = cursor - 2;
1342: if (limit_backward > c || c > limit) {
1343: return false;
1344: }
1345: cursor = c;
1346: }
1347: cursor = limit - v_1;
1348: // among, line 47
1349: if (find_among_b(a_0, 9) == 0) {
1350: return false;
1351: }
1352: return true;
1353: }
1354:
1355: private boolean r_BB() {
1356: int v_1;
1357: int v_2;
1358: int v_3;
1359: // (, line 49
1360: // test, line 49
1361: v_1 = limit - cursor;
1362: // hop, line 49
1363: {
1364: int c = cursor - 3;
1365: if (limit_backward > c || c > limit) {
1366: return false;
1367: }
1368: cursor = c;
1369: }
1370: cursor = limit - v_1;
1371: // not, line 49
1372: {
1373: v_2 = limit - cursor;
1374: lab0: do {
1375: // literal, line 49
1376: if (!(eq_s_b(3, "met"))) {
1377: break lab0;
1378: }
1379: return false;
1380: } while (false);
1381: cursor = limit - v_2;
1382: }
1383: // not, line 49
1384: {
1385: v_3 = limit - cursor;
1386: lab1: do {
1387: // literal, line 49
1388: if (!(eq_s_b(4, "ryst"))) {
1389: break lab1;
1390: }
1391: return false;
1392: } while (false);
1393: cursor = limit - v_3;
1394: }
1395: return true;
1396: }
1397:
1398: private boolean r_CC() {
1399: int v_1;
1400: // (, line 50
1401: // test, line 50
1402: v_1 = limit - cursor;
1403: // hop, line 50
1404: {
1405: int c = cursor - 2;
1406: if (limit_backward > c || c > limit) {
1407: return false;
1408: }
1409: cursor = c;
1410: }
1411: cursor = limit - v_1;
1412: // literal, line 50
1413: if (!(eq_s_b(1, "l"))) {
1414: return false;
1415: }
1416: return true;
1417: }
1418:
1419: private boolean r_endings() {
1420: int among_var;
1421: // (, line 55
1422: // [, line 56
1423: ket = cursor;
1424: // substring, line 56
1425: among_var = find_among_b(a_1, 294);
1426: if (among_var == 0) {
1427: return false;
1428: }
1429: // ], line 56
1430: bra = cursor;
1431: switch (among_var) {
1432: case 0:
1433: return false;
1434: case 1:
1435: // (, line 145
1436: // delete, line 145
1437: slice_del();
1438: break;
1439: }
1440: return true;
1441: }
1442:
1443: private boolean r_undouble() {
1444: int v_1;
1445: // (, line 151
1446: // test, line 152
1447: v_1 = limit - cursor;
1448: // substring, line 152
1449: if (find_among_b(a_2, 10) == 0) {
1450: return false;
1451: }
1452: cursor = limit - v_1;
1453: // [, line 154
1454: ket = cursor;
1455: // next, line 154
1456: if (cursor <= limit_backward) {
1457: return false;
1458: }
1459: cursor--;
1460: // ], line 154
1461: bra = cursor;
1462: // delete, line 154
1463: slice_del();
1464: return true;
1465: }
1466:
1467: private boolean r_respell() {
1468: int among_var;
1469: int v_1;
1470: int v_2;
1471: int v_3;
1472: int v_4;
1473: int v_5;
1474: int v_6;
1475: int v_7;
1476: int v_8;
1477: // (, line 159
1478: // [, line 160
1479: ket = cursor;
1480: // substring, line 160
1481: among_var = find_among_b(a_3, 34);
1482: if (among_var == 0) {
1483: return false;
1484: }
1485: // ], line 160
1486: bra = cursor;
1487: switch (among_var) {
1488: case 0:
1489: return false;
1490: case 1:
1491: // (, line 161
1492: // <-, line 161
1493: slice_from("ief");
1494: break;
1495: case 2:
1496: // (, line 162
1497: // <-, line 162
1498: slice_from("uc");
1499: break;
1500: case 3:
1501: // (, line 163
1502: // <-, line 163
1503: slice_from("um");
1504: break;
1505: case 4:
1506: // (, line 164
1507: // <-, line 164
1508: slice_from("rb");
1509: break;
1510: case 5:
1511: // (, line 165
1512: // <-, line 165
1513: slice_from("ur");
1514: break;
1515: case 6:
1516: // (, line 166
1517: // <-, line 166
1518: slice_from("ister");
1519: break;
1520: case 7:
1521: // (, line 167
1522: // <-, line 167
1523: slice_from("meter");
1524: break;
1525: case 8:
1526: // (, line 168
1527: // <-, line 168
1528: slice_from("olut");
1529: break;
1530: case 9:
1531: // (, line 169
1532: // not, line 169
1533: {
1534: v_1 = limit - cursor;
1535: lab0: do {
1536: // literal, line 169
1537: if (!(eq_s_b(1, "a"))) {
1538: break lab0;
1539: }
1540: return false;
1541: } while (false);
1542: cursor = limit - v_1;
1543: }
1544: // not, line 169
1545: {
1546: v_2 = limit - cursor;
1547: lab1: do {
1548: // literal, line 169
1549: if (!(eq_s_b(1, "i"))) {
1550: break lab1;
1551: }
1552: return false;
1553: } while (false);
1554: cursor = limit - v_2;
1555: }
1556: // not, line 169
1557: {
1558: v_3 = limit - cursor;
1559: lab2: do {
1560: // literal, line 169
1561: if (!(eq_s_b(1, "o"))) {
1562: break lab2;
1563: }
1564: return false;
1565: } while (false);
1566: cursor = limit - v_3;
1567: }
1568: // <-, line 169
1569: slice_from("l");
1570: break;
1571: case 10:
1572: // (, line 170
1573: // <-, line 170
1574: slice_from("bic");
1575: break;
1576: case 11:
1577: // (, line 171
1578: // <-, line 171
1579: slice_from("dic");
1580: break;
1581: case 12:
1582: // (, line 172
1583: // <-, line 172
1584: slice_from("pic");
1585: break;
1586: case 13:
1587: // (, line 173
1588: // <-, line 173
1589: slice_from("tic");
1590: break;
1591: case 14:
1592: // (, line 174
1593: // <-, line 174
1594: slice_from("ac");
1595: break;
1596: case 15:
1597: // (, line 175
1598: // <-, line 175
1599: slice_from("ec");
1600: break;
1601: case 16:
1602: // (, line 176
1603: // <-, line 176
1604: slice_from("ic");
1605: break;
1606: case 17:
1607: // (, line 177
1608: // <-, line 177
1609: slice_from("luc");
1610: break;
1611: case 18:
1612: // (, line 178
1613: // <-, line 178
1614: slice_from("uas");
1615: break;
1616: case 19:
1617: // (, line 179
1618: // <-, line 179
1619: slice_from("vas");
1620: break;
1621: case 20:
1622: // (, line 180
1623: // <-, line 180
1624: slice_from("cis");
1625: break;
1626: case 21:
1627: // (, line 181
1628: // <-, line 181
1629: slice_from("lis");
1630: break;
1631: case 22:
1632: // (, line 182
1633: // <-, line 182
1634: slice_from("eris");
1635: break;
1636: case 23:
1637: // (, line 183
1638: // <-, line 183
1639: slice_from("pans");
1640: break;
1641: case 24:
1642: // (, line 184
1643: // not, line 184
1644: {
1645: v_4 = limit - cursor;
1646: lab3: do {
1647: // literal, line 184
1648: if (!(eq_s_b(1, "s"))) {
1649: break lab3;
1650: }
1651: return false;
1652: } while (false);
1653: cursor = limit - v_4;
1654: }
1655: // <-, line 184
1656: slice_from("ens");
1657: break;
1658: case 25:
1659: // (, line 185
1660: // <-, line 185
1661: slice_from("ons");
1662: break;
1663: case 26:
1664: // (, line 186
1665: // <-, line 186
1666: slice_from("lus");
1667: break;
1668: case 27:
1669: // (, line 187
1670: // <-, line 187
1671: slice_from("rus");
1672: break;
1673: case 28:
1674: // (, line 188
1675: // not, line 188
1676: {
1677: v_5 = limit - cursor;
1678: lab4: do {
1679: // literal, line 188
1680: if (!(eq_s_b(1, "p"))) {
1681: break lab4;
1682: }
1683: return false;
1684: } while (false);
1685: cursor = limit - v_5;
1686: }
1687: // not, line 188
1688: {
1689: v_6 = limit - cursor;
1690: lab5: do {
1691: // literal, line 188
1692: if (!(eq_s_b(1, "t"))) {
1693: break lab5;
1694: }
1695: return false;
1696: } while (false);
1697: cursor = limit - v_6;
1698: }
1699: // <-, line 188
1700: slice_from("hes");
1701: break;
1702: case 29:
1703: // (, line 189
1704: // <-, line 189
1705: slice_from("mis");
1706: break;
1707: case 30:
1708: // (, line 190
1709: // not, line 190
1710: {
1711: v_7 = limit - cursor;
1712: lab6: do {
1713: // literal, line 190
1714: if (!(eq_s_b(1, "m"))) {
1715: break lab6;
1716: }
1717: return false;
1718: } while (false);
1719: cursor = limit - v_7;
1720: }
1721: // <-, line 190
1722: slice_from("ens");
1723: break;
1724: case 31:
1725: // (, line 192
1726: // <-, line 192
1727: slice_from("ers");
1728: break;
1729: case 32:
1730: // (, line 193
1731: // not, line 193
1732: {
1733: v_8 = limit - cursor;
1734: lab7: do {
1735: // literal, line 193
1736: if (!(eq_s_b(1, "n"))) {
1737: break lab7;
1738: }
1739: return false;
1740: } while (false);
1741: cursor = limit - v_8;
1742: }
1743: // <-, line 193
1744: slice_from("es");
1745: break;
1746: case 33:
1747: // (, line 194
1748: // <-, line 194
1749: slice_from("ys");
1750: break;
1751: case 34:
1752: // (, line 195
1753: // <-, line 195
1754: slice_from("ys");
1755: break;
1756: }
1757: return true;
1758: }
1759:
1760: public boolean stem() {
1761: int v_1;
1762: int v_2;
1763: int v_3;
1764: // (, line 200
1765: // backwards, line 202
1766: limit_backward = cursor;
1767: cursor = limit;
1768: // (, line 202
1769: // do, line 203
1770: v_1 = limit - cursor;
1771: lab0: do {
1772: // call endings, line 203
1773: if (!r_endings()) {
1774: break lab0;
1775: }
1776: } while (false);
1777: cursor = limit - v_1;
1778: // do, line 204
1779: v_2 = limit - cursor;
1780: lab1: do {
1781: // call undouble, line 204
1782: if (!r_undouble()) {
1783: break lab1;
1784: }
1785: } while (false);
1786: cursor = limit - v_2;
1787: // do, line 205
1788: v_3 = limit - cursor;
1789: lab2: do {
1790: // call respell, line 205
1791: if (!r_respell()) {
1792: break lab2;
1793: }
1794: } while (false);
1795: cursor = limit - v_3;
1796: cursor = limit_backward;
1797: return true;
1798: }
1799:
1800: }
|