docs: public String next() throws java.io.IOException {
      int zzInput;
      int zzAction;
  
      // cached fields:
      int zzCurrentPosL;
      int zzMarkedPosL;
      int zzEndReadL = zzEndRead;
      char [] zzBufferL = zzBuffer;
      char [] zzCMapL = ZZ_CMAP;
  
      int [] zzTransL = ZZ_TRANS;
      int [] zzRowMapL = ZZ_ROWMAP;
      int [] zzAttrL = ZZ_ATTRIBUTE;
  
      while (true) {
        zzMarkedPosL = zzMarkedPos;
  
        zzAction = -1;
  
        zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
    
        zzState = ZZ_LEXSTATE[zzLexicalState];
  
  
        zzForAction: {
          while (true) {
      
            if (zzCurrentPosL < zzEndReadL)
              zzInput = zzBufferL[zzCurrentPosL++];
            else if (zzAtEOF) {
              zzInput = YYEOF;
              break zzForAction;
            }
            else {
              // store back cached positions
              zzCurrentPos  = zzCurrentPosL;
              zzMarkedPos   = zzMarkedPosL;
              boolean eof = zzRefill();
              // get translated positions and possibly new buffer
              zzCurrentPosL  = zzCurrentPos;
              zzMarkedPosL   = zzMarkedPos;
              zzBufferL      = zzBuffer;
              zzEndReadL     = zzEndRead;
              if (eof) {
                zzInput = YYEOF;
                break zzForAction;
              }
              else {
                zzInput = zzBufferL[zzCurrentPosL++];
              }
            }
            int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
            if (zzNext == -1) break zzForAction;
            zzState = zzNext;
  
            int zzAttributes = zzAttrL[zzState];
            if ( (zzAttributes & 1) == 1 ) {
              zzAction = zzState;
              zzMarkedPosL = zzCurrentPosL;
              if ( (zzAttributes & 8) == 8 ) break zzForAction;
            }
  
          }
        }
  
        // store back cached position
        zzMarkedPos = zzMarkedPosL;
  
        switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
          case 180: 
            { return(stem(3,"te","ed"));
            }
          case 372: break;
          case 298: 
            { return(stem(1,"a","s"));
            }
          case 373: break;
          case 94: 
            { return(stem(3,"ide","ed"));
            }
          case 374: break;
          case 126: 
            { return(stem(2,"al","s"));
            }
          case 375: break;
          case 15: 
            { return(null_stem());
            }
          case 376: break;
          case 293: 
            { return(stem(2,"la","s"));
            }
          case 377: break;
          case 38: 
            { return(stem(3,"will",""));
            }
          case 378: break;
          case 8: 
            { yybegin(scan); if (option(tag_output)) return yytext();
            }
          case 379: break;
          case 11: 
            { return cnull_stem();
            }
          case 380: break;
          case 72: 
            { return(stem(3,"eel","ed"));
            }
          case 381: break;
          case 173: 
            { return(stem(3,"eal","ed"));
            }
          case 382: break;
          case 177: 
            { return(stem(4,"ake","en"));
            }
          case 383: break;
          case 134: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"I",""));
            }
          case 384: break;
          case 133: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(1,"y",""));
            }
          case 385: break;
          case 259: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 4;
            { return(stem(1,"y",""));
            }
          case 386: break;
          case 89: 
            { return(stem(3,"ay","ed"));
            }
          case 387: break;
          case 272: 
            { return(stem(3,"se","ed"));
            }
          case 388: break;
          case 95: 
            { return(stem(3,"ise","ed"));
            }
          case 389: break;
          case 236: 
            { return(stem(3,"ike","ed"));
            }
          case 390: break;
          case 29: 
            { return(ynull_stem());
            }
          case 391: break;
          case 111: 
            { return(stem(3,"ell","ed"));
            }
          case 392: break;
          case 10: 
            { return(stem(1,"us","s"));
            }
          case 393: break;
          case 1: 
            { return(common_noun_stem());
            }
          case 394: break;
          case 13: 
            // lookahead expression with fixed lookahead length
            yypushback(1);
            { return(common_noun_stem());
            }
          case 395: break;
          case 70: 
            { return(stem(3,"ly","ed"));
            }
          case 396: break;
          case 67: 
            { return(stem(3,"ive","ed"));
            }
          case 397: break;
          case 355: 
            { return(stem(3,"is","s"));
            }
          case 398: break;
          case 239: 
            { return(stem(5,"eek","ed"));
            }
          case 399: break;
          case 160: 
            { return(stem(3,"ar","ed"));
            }
          case 400: break;
          case 267: 
            { return(stem(4,"ame","ed"));
            }
          case 401: break;
          case 33: 
            { return(stem(3,"see","ed"));
            }
          case 402: break;
          case 151: 
            { return(stem(3,"epe","ed"));
            }
          case 403: break;
          case 21: 
            { return(stem(3,"get","ed"));
            }
          case 404: break;
          case 351: 
            { return(stem(8,"-de-sac","s"));
            }
          case 405: break;
          case 369: 
            { return(stem(12,"-in-the-box","s"));
            }
          case 406: break;
          case 266: 
            { return(stem(5,"ing","ed"));
            }
          case 407: break;
          case 182: 
            { return(stem(2,"i","s"));
            }
          case 408: break;
          case 162: 
            { return(stem(3,"an","ed"));
            }
          case 409: break;
          case 30: 
            { return(stem(3,"red","ed"));
            }
          case 410: break;
          case 51: 
            { return(stem(3,"e","ing"));
            }
          case 411: break;
          case 214: 
            { return(stem(3,"ass","ed"));
            }
          case 412: break;
          case 249: 
            { return(stem(2,"re","s"));
            }
          case 413: break;
          case 65: 
            { return(stem(2,"e","s"));
            }
          case 414: break;
          case 78: 
            { return(stem(3,"o","en"));
            }
          case 415: break;
          case 155: 
            { return(stem(5,"do","ed"));
            }
          case 416: break;
          case 71: 
            { return(stem(3,"all","ed"));
            }
          case 417: break;
          case 125: 
            { return(stem(2,"ra","s"));
            }
          case 418: break;
          case 212: 
            { return(stem(6,"clepe","ed"));
            }
          case 419: break;
          case 256: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 4;
            { return(stem(1,"",""));
            }
          case 420: break;
          case 60: 
            { return(stem(3,"ear","ed"));
            }
          case 421: break;
          case 63: 
            { return(stem(3,"ome","ed"));
            }
          case 422: break;
          case 52: 
            { return(stem(1,"","ed"));
            }
          case 423: break;
          case 157: 
            { return(stem(3,"eeze","ed"));
            }
          case 424: break;
          case 27: 
            { return(stem(3,"light","ed"));
            }
          case 425: break;
          case 139: 
            { return(stem(3,"y","s"));
            }
          case 426: break;
          case 296: 
            { return(stem(2,"zo","s"));
            }
          case 427: break;
          case 31: 
            { return(stem(3,"run","ed"));
            }
          case 428: break;
          case 46: 
            { return(stem(2,"an","s"));
            }
          case 429: break;
          case 333: 
            { return(stem(3,"ix","ed"));
            }
          case 430: break;
          case 304: 
            { return(stem(4,"g","ing"));
            }
          case 431: break;
          case 57: 
            { return(stem(3,"end","ed"));
            }
          case 432: break;
          case 131: 
            // general lookahead, find correct zzMarkedPos
            { int zzFState = 5;
              int zzFPos = zzStartRead;
              if (zzFin.length <= zzBufferL.length) { zzFin = new boolean[zzBufferL.length+1]; }
              boolean zzFinL[] = zzFin;
              while (zzFState != -1 && zzFPos < zzMarkedPos) {
                if ((zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 
                zzInput = zzBufferL[zzFPos++];
                zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
              }
              if (zzFState != -1 && (zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 
  
              zzFState = 7;
              zzFPos = zzMarkedPos;
              while (!zzFinL[zzFPos] || (zzAttrL[zzFState] & 1) != 1) {
                zzInput = zzBufferL[--zzFPos];
                zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
              };
              zzMarkedPos = zzFPos;
            }
            { return(proper_name_stem());
            }
          case 433: break;
          case 50: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 1;
            { return(proper_name_stem());
            }
          case 434: break;
          case 55: 
            { return(stem(3,"low","ed"));
            }
          case 435: break;
          case 193: 
            { return(stem(2,"ny","s"));
            }
          case 436: break;
          case 138: 
            { return(stem(3,"y","ed"));
            }
          case 437: break;
          case 104: 
            { return(stem(3,"mite","ed"));
            }
          case 438: break;
          case 305: 
            { return(stem(3,"d","en"));
            }
          case 439: break;
          case 14: 
            { return(stem(2,"e","ed"));
            }
          case 440: break;
          case 100: 
            { return(stem(3,"hoot","ed"));
            }
          case 441: break;
          case 185: 
            { return(stem(2,"so","s"));
            }
          case 442: break;
          case 341: 
            { return(stem(2,"r","s"));
            }
          case 443: break;
          case 231: 
            { return(stem(5,"elt","en"));
            }
          case 444: break;
          case 225: 
            { return(stem(4,"eeze","en"));
            }
          case 445: break;
          case 332: 
            { return(stem(4,"y","ing"));
            }
          case 446: break;
          case 130: 
            // general lookahead, find correct zzMarkedPos
            { int zzFState = 5;
              int zzFPos = zzStartRead;
              if (zzFin.length <= zzBufferL.length) { zzFin = new boolean[zzBufferL.length+1]; }
              boolean zzFinL[] = zzFin;
              while (zzFState != -1 && zzFPos < zzMarkedPos) {
                if ((zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 
                zzInput = zzBufferL[zzFPos++];
                zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
              }
              if (zzFState != -1 && (zzAttrL[zzFState] & 1) == 1) { zzFinL[zzFPos] = true; } 
  
              zzFState = 6;
              zzFPos = zzMarkedPos;
              while (!zzFinL[zzFPos] || (zzAttrL[zzFState] & 1) != 1) {
                zzInput = zzBufferL[--zzFPos];
                zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];
              };
              zzMarkedPos = zzFPos;
            }
            { yybegin(noun); yypushback(yylength()); return(next());
            }
          case 447: break;
          case 81: 
            { return(stem(3,"ew","en"));
            }
          case 448: break;
          case 113: 
            { return(stem(3,"aw","en"));
            }
          case 449: break;
          case 49: 
            // lookahead expression with fixed lookahead length
            yypushback(2);
            { yybegin(verb); yypushback(yylength()); return(next());
            }
          case 450: break;
          case 314: 
            { return(stem(3,"ship","ed"));
            }
          case 451: break;
          case 335: 
            { return(stem(1,"de","s"));
            }
          case 452: break;
          case 364: 
            { return(stem(9,"-mutuel","s"));
            }
          case 453: break;
          case 370: 
            { return(stem(14,"y-in-waiting","s"));
            }
          case 454: break;
          case 9: 
            { return(stem(2,"be",""));
            }
          case 455: break;
          case 206: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"be",""));
            }
          case 456: break;
          case 69: 
            { return(stem(3,"lee","ed"));
            }
          case 457: break;
          case 40: 
            { return(stem(1,"um","s"));
            }
          case 458: break;
          case 56: 
            { return(stem(3,"reed","ed"));
            }
          case 459: break;
          case 163: 
            { return(stem(3,"ap","ed"));
            }
          case 460: break;
          case 343: 
            { return(stem(2,"te","s"));
            }
          case 461: break;
          case 197: 
            { return(stem(3,"f","s"));
            }
          case 462: break;
          case 200: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"can",""));
            }
          case 463: break;
          case 300: 
            { return(stem(2,"lio","s"));
            }
          case 464: break;
          case 108: 
            { return(stem(3,"wim","en"));
            }
          case 465: break;
          case 91: 
            { return(stem(3,"ow","en"));
            }
          case 466: break;
          case 321: 
            { return(stem(2,"g","s"));
            }
          case 467: break;
          case 228: 
            { return(semi_reg_stem(1,""));
            }
          case 468: break;
          case 275: 
            { return(stem(2,"gue","s"));
            }
          case 469: break;
          case 143: 
            { return(stem(3,"ei","ed"));
            }
          case 470: break;
          case 37: 
            { return(stem(3,"eat","ed"));
            }
          case 471: break;
          case 17: 
            { return(stem(3,"bid","ed"));
            }
          case 472: break;
          case 217: 
            { return(stem(3,"","en"));
            }
          case 473: break;
          case 354: 
            { return(stem(10,"an-at-arms","s"));
            }
          case 474: break;
          case 132: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"we",""));
            }
          case 475: break;
          case 244: 
            { return(stem(2,"ron","s"));
            }
          case 476: break;
          case 338: 
            { return(stem(2,"non","s"));
            }
          case 477: break;
          case 196: 
            { return(stem(2,"uum","s"));
            }
          case 478: break;
          case 24: 
            { return(stem(3,"have","ed"));
            }
          case 479: break;
          case 344: 
            { return(stem(3,"ff","s"));
            }
          case 480: break;
          case 251: 
            { return(stem(2,"mum","s"));
            }
          case 481: break;
          case 242: 
            { return(stem(2,"ie","ed"));
            }
          case 482: break;
          case 273: 
            { return(stem(2,"ee","ed"));
            }
          case 483: break;
          case 334: 
            { return(stem(2,"do","s"));
            }
          case 484: break;
          case 262: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"do","s"));
            }
          case 485: break;
          case 360: 
            { return(stem(6,"-doux","s"));
            }
          case 486: break;
          case 299: 
            { return(stem(3,"ly","s"));
            }
          case 487: break;
          case 224: 
            { return(stem(4,"w","ed"));
            }
          case 488: break;
          case 237: 
            { return(stem(4,"eal","en"));
            }
          case 489: break;
          case 253: 
            { return(stem(6,"m.p.","s"));
            }
          case 490: break;
          case 45: 
            { return(stem(2,"","s"));
            }
          case 491: break;
          case 346: 
            { return(stem(9,"an-of-war","s"));
            }
          case 492: break;
          case 90: 
            { return(stem(3,"ie","en"));
            }
          case 493: break;
          case 121: 
            { return(stem(2,"tum","s"));
            }
          case 494: break;
          case 199: 
            { return(stem(5,"eyrir","s"));
            }
          case 495: break;
          case 110: 
            { return(stem(3,"ee","en"));
            }
          case 496: break;
          case 204: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"will",""));
            }
          case 497: break;
          case 250: 
            { return(stem(2,"ia","s"));
            }
          case 498: break;
          case 255: 
            { return(stem(3,"s","s"));
            }
          case 499: break;
          case 44: 
            { return(stem(2,"uo","s"));
            }
          case 500: break;
          case 226: 
            { return(stem(5,"ight","ed"));
            }
          case 501: break;
          case 124: 
            { return(stem(3,"ouse","s"));
            }
          case 502: break;
          case 358: 
            { return(stem(2,"t","s"));
            }
          case 503: break;
          case 7: 
            { return(stem(2,"be","s"));
            }
          case 504: break;
          case 260: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"be","s"));
            }
          case 505: break;
          case 53: 
            { return(semi_reg_stem(0,"e"));
            }
          case 506: break;
          case 356: 
            { return(stem(8,"-in-law","s"));
            }
          case 507: break;
          case 181: 
            { return(stem(4,".","s"));
            }
          case 508: break;
          case 169: 
            { return(stem(3,"ay","en"));
            }
          case 509: break;
          case 165: 
            { return(stem(3,"se","en"));
            }
          case 510: break;
          case 39: 
            { return(stem(3,"have",""));
            }
          case 511: break;
          case 166: 
            { return(stem(3,"ine","ed"));
            }
          case 512: break;
          case 278: 
            { return(stem(5,"ink","ed"));
            }
          case 513: break;
          case 326: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 4;
            { return(stem(4,"be","ed"));
            }
          case 514: break;
          case 116: 
            { return(stem(4,"be","ed"));
            }
          case 515: break;
          case 359: 
            { return(stem(9,"-down","ing"));
            }
          case 516: break;
          case 297: 
            { return(stem(3,"en","s"));
            }
          case 517: break;
          case 148: 
            { return(stem(4,"ear","en"));
            }
          case 518: break;
          case 361: 
            { return(stem(8,"-de-lys","s"));
            }
          case 519: break;
          case 115: 
            { return(stem(4,"go","ed"));
            }
          case 520: break;
          case 309: 
            { return(stem(4,"y","ed"));
            }
          case 521: break;
          case 42: 
            { return(stem(2,"a","s"));
            }
          case 522: break;
          case 2: 
            { String str = yytext();
                                    int first = str.charAt(0);
  	                          String msg = String.format("Untokenizable: %s (U+%s, decimal: %s) - this may be because your text isn't using _ as a tag delimiter", yytext(), Integer.toHexString(first).toUpperCase(), Integer.toString(first));
                    LOGGER.warning(msg);
            }
          case 523: break;
          case 189: 
            { return(stem(3,"x","s"));
            }
          case 524: break;
          case 61: 
            { return(stem(3,"id","ed"));
            }
          case 525: break;
          case 83: 
            { return(stem(4,"have","s"));
            }
          case 526: break;
          case 59: 
            { return(stem(3,"ear","en"));
            }
          case 527: break;
          case 96: 
            { return(stem(3,"eeve","ed"));
            }
          case 528: break;
          case 76: 
            { return(stem(3,"ild","ed"));
            }
          case 529: break;
          case 353: 
            { return(stem(10,"anservant","s"));
            }
          case 530: break;
          case 202: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"he",""));
            }
          case 531: break;
          case 254: 
            { return(stem(4,"ex","s"));
            }
          case 532: break;
          case 150: 
            { return(stem(3,"oose","ed"));
            }
          case 533: break;
          case 336: 
            { return(stem(4,"-in","s"));
            }
          case 534: break;
          case 285: 
            { return(stem(6,"ork","ed"));
            }
          case 535: break;
          case 144: 
            { return(stem(3,"eak","ed"));
            }
          case 536: break;
          case 112: 
            { return(stem(3,"ink","ed"));
            }
          case 537: break;
          case 241: 
            { return(stem(3,"a","ed"));
            }
          case 538: break;
          case 141: 
            { return(stem(3,"rn","ed"));
            }
          case 539: break;
          case 330: 
            { return(stem(6,"-up","ed"));
            }
          case 540: break;
          case 156: 
            { return(stem(3,"y","en"));
            }
          case 541: break;
          case 119: 
            { return(stem(2,"um","s"));
            }
          case 542: break;
          case 222: 
            { return(stem(4,"tch","ed"));
            }
          case 543: break;
          case 88: 
            { return(stem(3,"ose","ed"));
            }
          case 544: break;
          case 25: 
            { return(stem(3,"have","s"));
            }
          case 545: break;
          case 101: 
            { return(stem(3,"hit","ed"));
            }
          case 546: break;
          case 122: 
            { return(stem(3,"oot","s"));
            }
          case 547: break;
          case 68: 
            { return(stem(4,"do","s"));
            }
          case 548: break;
          case 97: 
            { return(stem(3,"ing","ed"));
            }
          case 549: break;
          case 246: 
            { return(stem(3,"denum","s"));
            }
          case 550: break;
          case 352: 
            { return(stem(6,"-over","s"));
            }
          case 551: break;
          case 191: 
            { return(stem(1,"s","s"));
            }
          case 552: break;
          case 34: 
            { return(stem(3,"win","ed"));
            }
          case 553: break;
          case 82: 
            { return(stem(3,"eave","ed"));
            }
          case 554: break;
          case 342: 
            { return(stem(7,"-up","ing"));
            }
          case 555: break;
          case 74: 
            { return(stem(3,"eld","ed"));
            }
          case 556: break;
          case 289: 
            { return(stem(4,"yatid","s"));
            }
          case 557: break;
          case 291: 
            { return(stem(1,"o","s"));
            }
          case 558: break;
          case 127: 
            { return(stem(2,"lo","s"));
            }
          case 559: break;
          case 103: 
            { return(stem(3,"lide","ed"));
            }
          case 560: break;
          case 41: 
            { return(stem(2,".","s"));
            }
          case 561: break;
          case 175: 
            { return(stem(3,"and","ed"));
            }
          case 562: break;
          case 223: 
            { return(stem(3,"am","ed"));
            }
          case 563: break;
          case 3: 
            { return common_noun_stem().concat(next());
            }
          case 564: break;
          case 114: 
            { return(stem(3,"read","ed"));
            }
          case 565: break;
          case 263: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"have","s"));
            }
          case 566: break;
          case 349: 
            { return(stem(8,"-down","ed"));
            }
          case 567: break;
          case 209: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"have","ed"));
            }
          case 568: break;
          case 137: 
            { return(stem(3,"","ing"));
            }
          case 569: break;
          case 146: 
            { return(stem(5,"be","ing"));
            }
          case 570: break;
          case 219: 
            { return(stem(4,"te","ing"));
            }
          case 571: break;
          case 322: 
            { return(stem(4,"isee","s"));
            }
          case 572: break;
          case 118: 
            { return(stem(1,"on","s"));
            }
          case 573: break;
          case 117: 
            { return(stem(2,"","ed"));
            }
          case 574: break;
          case 307: 
            { return(stem(4,"y","s"));
            }
          case 575: break;
          case 345: 
            { return(stem(4,"-on","s"));
            }
          case 576: break;
          case 337: 
            { return(stem(8,"onsieur","s"));
            }
          case 577: break;
          case 178: 
            { return(stem(4,"eave","en"));
            }
          case 578: break;
          case 248: 
            { return(stem(3,"us","s"));
            }
          case 579: break;
          case 365: 
            { return(stem(9,"-de-camp","s"));
            }
          case 580: break;
          case 201: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"she",""));
            }
          case 581: break;
          case 64: 
            { return(stem(3,"raw","ed"));
            }
          case 582: break;
          case 317: 
            { return(stem(2,"cio","s"));
            }
          case 583: break;
          case 371: 
            { return(stem(11,"y-general","s"));
            }
          case 584: break;
          case 320: 
            { return(stem(2,"eum","s"));
            }
          case 585: break;
          case 368: 
            { return(stem(9,"-at-arms","s"));
            }
          case 586: break;
          case 315: 
            { return(stem(2,"ion","s"));
            }
          case 587: break;
          case 367: 
            { return(stem(11,"erfamilias","s"));
            }
          case 588: break;
          case 328: 
            { return(stem(6,"-down","s"));
            }
          case 589: break;
          case 288: 
            { return(stem(1,"x","s"));
            }
          case 590: break;
          case 323: 
            { return(stem(2,"oan","s"));
            }
          case 591: break;
          case 306: 
            { return(stem(5,"eech","ed"));
            }
          case 592: break;
          case 73: 
            { return(stem(3,"row","ed"));
            }
          case 593: break;
          case 4: 
            { return yytext();
            }
          case 594: break;
          case 292: 
            { return(stem(2,"ro","s"));
            }
          case 595: break;
          case 252: 
            { return(stem(3,"ey","s"));
            }
          case 596: break;
          case 324: 
            { return(stem(2,"ton","s"));
            }
          case 597: break;
          case 5: 
            { return(stem(1,"","s"));
            }
          case 598: break;
          case 303: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"be",""));
            }
          case 599: break;
          case 36: 
            { return(stem(3,"be",""));
            }
          case 600: break;
          case 229: 
            { return(stem(5,"et","en"));
            }
          case 601: break;
          case 99: 
            { return(stem(3,"hoe","ed"));
            }
          case 602: break;
          case 164: 
            { return(stem(3,"de","en"));
            }
          case 603: break;
          case 43: 
            { return(xnull_stem());
            }
          case 604: break;
          case 362: 
            { return(stem(8,"-de-lis","s"));
            }
          case 605: break;
          case 207: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"have",""));
            }
          case 606: break;
          case 271: 
            { return(stem(5,"ivy","s"));
            }
          case 607: break;
          case 238: 
            { return(stem(3,"ge","ed"));
            }
          case 608: break;
          case 233: 
            { return(stem(3,"ce","ed"));
            }
          case 609: break;
          case 176: 
            { return(stem(3,"ke","en"));
            }
          case 610: break;
          case 105: 
            { return(stem(3,"pin","ed"));
            }
          case 611: break;
          case 287: 
            { return(stem(2,"no","s"));
            }
          case 612: break;
          case 312: 
            { return(semi_reg_stem(0,"ue"));
            }
          case 613: break;
          case 235: 
            { return(stem(3,"il","ed"));
            }
          case 614: break;
          case 350: 
            { return(stem(2,"l","s"));
            }
          case 615: break;
          case 167: 
            { return(semi_reg_stem(0,""));
            }
          case 616: break;
          case 159: 
            { return(stem(3,"ve","en"));
            }
          case 617: break;
          case 203: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(2,"e",""));
            }
          case 618: break;
          case 234: 
            { return(stem(5,"ink","en"));
            }
          case 619: break;
          case 145: 
            { return(stem(3,"gin","ed"));
            }
          case 620: break;
          case 286: 
            { return(stem(5,"y","ed"));
            }
          case 621: break;
          case 205: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"we",""));
            }
          case 622: break;
          case 171: 
            { return(stem(3,"ill","ed"));
            }
          case 623: break;
          case 232: 
            { return(stem(3,"ue","ed"));
            }
          case 624: break;
          case 245: 
            { return(stem(1,"i","s"));
            }
          case 625: break;
          case 183: 
            { return(stem(2,"d","s"));
            }
          case 626: break;
          case 19: 
            { return(stem(3,"do","ed"));
            }
          case 627: break;
          case 58: 
            { return(stem(4,"be","en"));
            }
          case 628: break;
          case 270: 
            { return(stem(5,"ivy","ed"));
            }
          case 629: break;
          case 168: 
            { return(stem(3,"i","ed"));
            }
          case 630: break;
          case 187: 
            { return(stem(1,"e","s"));
            }
          case 631: break;
          case 340: 
            { return(stem(2,"le","s"));
            }
          case 632: break;
          case 280: 
            { return(stem(5,"ead","en"));
            }
          case 633: break;
          case 301: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 5;
            { return(stem(2,"y",""));
            }
          case 634: break;
          case 149: 
            { return(stem(3,"rse","ed"));
            }
          case 635: break;
          case 66: 
            { return(stem(4,"do","en"));
            }
          case 636: break;
          case 170: 
            { return(stem(3,"ite","ed"));
            }
          case 637: break;
          case 227: 
            { return(stem(3,"l","en"));
            }
          case 638: break;
          case 128: 
            { return(stem(4,"ABC","s"));
            }
          case 639: break;
          case 106: 
            { return(stem(3,"peed","ed"));
            }
          case 640: break;
          case 215: 
            { return(stem(4,"eak","en"));
            }
          case 641: break;
          case 28: 
            { return(stem(3,"meet","ed"));
            }
          case 642: break;
          case 347: 
            { return(stem(4,"-by","s"));
            }
          case 643: break;
          case 135: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(1, "", "n"));
            }
          case 644: break;
          case 325: 
            { return(stem(4,"s","s"));
            }
          case 645: break;
          case 318: 
            { return(stem(3,"esis","s"));
            }
          case 646: break;
          case 230: 
            { return(stem(3,"ey","ed"));
            }
          case 647: break;
          case 142: 
            { return(stem(3,"ess","ed"));
            }
          case 648: break;
          case 218: 
            { return(stem(3,"e","en"));
            }
          case 649: break;
          case 348: 
            { return(stem(4,"o","s"));
            }
          case 650: break;
          case 152: 
            { return(stem(4,"are","ed"));
            }
          case 651: break;
          case 147: 
            { return(stem(4,"ind","ed"));
            }
          case 652: break;
          case 172: 
            { return(stem(3,"ick","ed"));
            }
          case 653: break;
          case 153: 
            { return(stem(4,"ie","ing"));
            }
          case 654: break;
          case 107: 
            { return(stem(3,"pit","ed"));
            }
          case 655: break;
          case 184: 
            { return(stem(2,"u","s"));
            }
          case 656: break;
          case 129: 
            { return(stem(2,"to","s"));
            }
          case 657: break;
          case 268: 
            { return(stem(3,"ride","ed"));
            }
          case 658: break;
          case 186: 
            { return(stem(2,"denum","s"));
            }
          case 659: break;
          case 290: 
            { return(stem(4,"sbok","s"));
            }
          case 660: break;
          case 308: 
            { return(stem(6,"ivy","ing"));
            }
          case 661: break;
          case 366: 
            { return(stem(13,"ademoiselle","s"));
            }
          case 662: break;
          case 195: 
            { return(stem(4,"ooth","s"));
            }
          case 663: break;
          case 20: 
            { return(stem(3,"feed","ed"));
            }
          case 664: break;
          case 98: 
            { return(stem(3,"ink","en"));
            }
          case 665: break;
          case 92: 
            { return(stem(3,"ake","ed"));
            }
          case 666: break;
          case 62: 
            { return(stem(3,"lothe","ed"));
            }
          case 667: break;
          case 18: 
            { return(stem(3,"dig","ed"));
            }
          case 668: break;
          case 279: 
            { return(stem(4,"k","ed"));
            }
          case 669: break;
          case 194: 
            { return(stem(2,"po","s"));
            }
          case 670: break;
          case 221: 
            { return(stem(3,"ose","en"));
            }
          case 671: break;
          case 174: 
            { return(stem(3,"ave","ed"));
            }
          case 672: break;
          case 77: 
            { return(stem(3,"ird","ed"));
            }
          case 673: break;
          case 161: 
            { return(stem(3,"in","ed"));
            }
          case 674: break;
          case 210: 
            { return(stem(4,"","ing"));
            }
          case 675: break;
          case 85: 
            { return(stem(3,"en","ed"));
            }
          case 676: break;
          case 87: 
            { return(stem(3,"o","ed"));
            }
          case 677: break;
          case 281: 
            { return(stem(3,"mel","s"));
            }
          case 678: break;
          case 274: 
            { return(stem(4,"-up","s"));
            }
          case 679: break;
          case 12: 
            { return(stem(2,"is","s"));
            }
          case 680: break;
          case 23: 
            { return(stem(3,"hide","ed"));
            }
          case 681: break;
          case 93: 
            { return(stem(3,"ing","en"));
            }
          case 682: break;
          case 257: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"not",""));
            }
          case 683: break;
          case 283: 
            { return(stem(4,"i","ing"));
            }
          case 684: break;
          case 243: 
            { return(stem(4,"e","ing"));
            }
          case 685: break;
          case 284: 
            { return(stem(4,"a","ing"));
            }
          case 686: break;
          case 136: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"'s",""));
            }
          case 687: break;
          case 264: 
            { return(condub_stem(3,"","ing"));
            }
          case 688: break;
          case 120: 
            { return(stem(3,"a","s"));
            }
          case 689: break;
          case 327: 
            { return(stem(4,"l","ing"));
            }
          case 690: break;
          case 316: 
            { return(stem(2,"ne","s"));
            }
          case 691: break;
          case 247: 
            { return(stem(3,"ur","s"));
            }
          case 692: break;
          case 198: 
            { return(stem(2,"b","s"));
            }
          case 693: break;
          case 220: 
            { return(stem(5,"uy","ed"));
            }
          case 694: break;
          case 258: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"shall",""));
            }
          case 695: break;
          case 190: 
            { return(stem(3,"fe","s"));
            }
          case 696: break;
          case 216: 
            { return(stem(2,"","en"));
            }
          case 697: break;
          case 311: 
            { return(stem(5,"ify","s"));
            }
          case 698: break;
          case 313: 
            { return(stem(5,"k","ing"));
            }
          case 699: break;
          case 6: 
            { return(cnull_stem());
            }
          case 700: break;
          case 80: 
            { return(stem(3,"old","ed"));
            }
          case 701: break;
          case 339: 
            { return(stem(4,"ese","s"));
            }
          case 702: break;
          case 294: 
            { return(stem(2,"dum","s"));
            }
          case 703: break;
          case 47: 
            { return(stem(2,"s","s"));
            }
          case 704: break;
          case 329: 
            { return(stem(5,"y","ing"));
            }
          case 705: break;
          case 357: 
            { return(stem(6,"-lit","s"));
            }
          case 706: break;
          case 158: 
            { return(stem(3,"ip","ed"));
            }
          case 707: break;
          case 79: 
            { return(stem(3,"ang","ed"));
            }
          case 708: break;
          case 331: 
            { return(stem(6,"ify","ing"));
            }
          case 709: break;
          case 295: 
            { return(stem(4,"belly","s"));
            }
          case 710: break;
          case 188: 
            { return(stem(4,"oose","s"));
            }
          case 711: break;
          case 282: 
            { return(stem(4,"ge","ing"));
            }
          case 712: break;
          case 109: 
            { return(stem(3,"wim","ed"));
            }
          case 713: break;
          case 179: 
            { return(stem(3,"t","en"));
            }
          case 714: break;
          case 276: 
            { return(stem(4,"ue","ing"));
            }
          case 715: break;
          case 48: 
            { return(stem(2,"vum","s"));
            }
          case 716: break;
          case 123: 
            { return(stem(2,"rum","s"));
            }
          case 717: break;
          case 192: 
            { return(stem(2,"num","s"));
            }
          case 718: break;
          case 102: 
            { return(stem(3,"lay","ed"));
            }
          case 719: break;
          case 277: 
            { return(stem(5,"ell","en"));
            }
          case 720: break;
          case 140: 
            { return(stem(3,"","ed"));
            }
          case 721: break;
          case 261: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"as",""));
            }
          case 722: break;
          case 16: 
            { return(stem(3,"bite","ed"));
            }
          case 723: break;
          case 154: 
            { return(stem(3,"al","ed"));
            }
          case 724: break;
          case 213: 
            { return(stem(3,"","s"));
            }
          case 725: break;
          case 302: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 3;
            { return(stem(3,"be","ed"));
            }
          case 726: break;
          case 35: 
            { return(stem(3,"be","ed"));
            }
          case 727: break;
          case 32: 
            { return(stem(3,"sit","ed"));
            }
          case 728: break;
          case 240: 
            { return(stem(5,"each","ed"));
            }
          case 729: break;
          case 363: 
            { return(stem(9,"-a-terre","s"));
            }
          case 730: break;
          case 84: 
            { return(stem(3,"now","ed"));
            }
          case 731: break;
          case 22: 
            { return(stem(3,"gin","en"));
            }
          case 732: break;
          case 269: 
            { return(stem(3,"ie","ed"));
            }
          case 733: break;
          case 75: 
            { return(stem(3,"ee","ed"));
            }
          case 734: break;
          case 86: 
            { return(stem(3,"eep","ed"));
            }
          case 735: break;
          case 208: 
            // lookahead expression with fixed base length
            zzMarkedPos = zzStartRead + 2;
            { return(stem(2,"would",""));
            }
          case 736: break;
          case 54: 
            { return(stem(3,"leed","ed"));
            }
          case 737: break;
          case 26: 
            { return(stem(3,"lead","ed"));
            }
          case 738: break;
          case 265: 
            { return(stem(7,"clepe","ed"));
            }
          case 739: break;
          case 319: 
            { return(stem(4,"eps","s"));
            }
          case 740: break;
          case 310: 
            { return(stem(5,"ify","ed"));
            }
          case 741: break;
          case 211: 
            { return(condub_stem(2,"","ed"));
            }
          case 742: break;
          default: 
            if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
              zzAtEOF = true;
                {
                  return null;
                }
            } 
            else {
              zzScanError(ZZ_NO_MATCH);
            }
        }
      }
    }