public IElementType advance() throws java.io.IOException
  {
    int zzInput;
    int zzAction;

    // cached fields:
    int zzCurrentPosL;
    int zzMarkedPosL;
    int zzEndReadL = zzEndRead;
    CharSequence zzBufferL = zzBuffer;

    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];

      // set up zzAction for empty match case:
      int zzAttributes = zzAttrL[zzState];
      if ( (zzAttributes & 1) == 1 ) {
        zzAction = zzState;
      }


      zzForAction: {
        while (true) {

          if (zzCurrentPosL < zzEndReadL) {
            zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL);
            zzCurrentPosL += Character.charCount(zzInput);
          }
          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 = Character.codePointAt(zzBufferL, zzCurrentPosL);
              zzCurrentPosL += Character.charCount(zzInput);
            }
          }
          int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMap(zzInput) ];
          if (zzNext == -1) break zzForAction;
          zzState = zzNext;

          zzAttributes = zzAttrL[zzState];
          if ( (zzAttributes & 1) == 1 ) {
            zzAction = zzState;
            zzMarkedPosL = zzCurrentPosL;
            if ( (zzAttributes & 8) == 8 ) break zzForAction;
          }

        }
      }

      // store back cached position
      zzMarkedPos = zzMarkedPosL;

      if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
        zzAtEOF = true;
            switch (zzLexicalState) {
            case IN_TRIPLE_STRING: {
              yyendstate(IN_TRIPLE_STRING); return storeToken(STRING_TSQ);
            }  // fall though
            case 754: break;
            default:
        return null;
        }
      }
      else {
        switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
          case 1:
            { return T_WRONG;
            }
          // fall through
          case 176: break;
          case 2:
            { return TokenType.WHITE_SPACE;
            }
          // fall through
          case 177: break;
          case 3:
            { return storeToken(NL);
            }
          // fall through
          case 178: break;
          case 4:
            { return storeToken(T_NOT);
            }
          // fall through
          case 179: break;
          case 5:
            { yybeginstate(IN_SINGLE_GSTRING);
                                            return storeToken(GSTRING_BEGIN);
            }
          // fall through
          case 180: break;
          case 6:
            { return storeToken(IDENTIFIER);
            }
          // fall through
          case 181: break;
          case 7:
            { return storeToken(T_REM);
            }
          // fall through
          case 182: break;
          case 8:
            { return storeToken(T_BAND);
            }
          // fall through
          case 183: break;
          case 9:
            { return storeToken(STRING_SQ);
            }
          // fall through
          case 184: break;
          case 10:
            { return storeToken(T_LPAREN);
            }
          // fall through
          case 185: break;
          case 11:
            { return storeToken(T_RPAREN);
            }
          // fall through
          case 186: break;
          case 12:
            { return storeToken(T_STAR);
            }
          // fall through
          case 187: break;
          case 13:
            { return storeToken(T_PLUS);
            }
          // fall through
          case 188: break;
          case 14:
            { return storeToken(T_COMMA);
            }
          // fall through
          case 189: break;
          case 15:
            { return storeToken(T_MINUS);
            }
          // fall through
          case 190: break;
          case 16:
            { return storeToken(T_DOT);
            }
          // fall through
          case 191: break;
          case 17:
            { yybeginstate(IN_SLASHY_STRING);
                                            return storeToken(SLASHY_BEGIN);
            }
          // fall through
          case 192: break;
          case 18:
            { return storeToken(NUM_INT);
            }
          // fall through
          case 193: break;
          case 19:
            { return storeToken(T_COLON);
            }
          // fall through
          case 194: break;
          case 20:
            { return storeToken(T_SEMI);
            }
          // fall through
          case 195: break;
          case 21:
            { return storeToken(T_LT);
            }
          // fall through
          case 196: break;
          case 22:
            { return storeToken(T_ASSIGN);
            }
          // fall through
          case 197: break;
          case 23:
            { return storeToken(T_GT);
            }
          // fall through
          case 198: break;
          case 24:
            { return storeToken(T_Q);
            }
          // fall through
          case 199: break;
          case 25:
            { return storeToken(T_AT);
            }
          // fall through
          case 200: break;
          case 26:
            { return storeToken(T_LBRACK);
            }
          // fall through
          case 201: break;
          case 27:
            { return storeToken(T_RBRACK);
            }
          // fall through
          case 202: break;
          case 28:
            { return storeToken(T_XOR);
            }
          // fall through
          case 203: break;
          case 29:
            { yybeginstate(NLS_AFTER_LBRACE); return storeToken(T_LBRACE);
            }
          // fall through
          case 204: break;
          case 30:
            { return storeToken(T_BOR);
            }
          // fall through
          case 205: break;
          case 31:
            { return storeToken(T_RBRACE);
            }
          // fall through
          case 206: break;
          case 32:
            { return storeToken(T_BNOT);
            }
          // fall through
          case 207: break;
          case 33:
            { yybeginstate(NLS_AFTER_LBRACE, IN_INJECTION_BRACES); return storeToken(T_LBRACE);
            }
          // fall through
          case 208: break;
          case 34:
            { yyendstate(IN_INJECTION, IN_GSTRING_DOLLAR); return storeToken(T_RBRACE);
            }
          // fall through
          case 209: break;
          case 35:
            { yyendstate(IN_INJECTION_BRACES); return storeToken(T_RBRACE);
            }
          // fall through
          case 210: break;
          case 36:
            { yypushback(1);
    yyendstate(DIVISION_EXPECTED);
            }
          // fall through
          case 211: break;
          case 37:
            { yyendstate(DIVISION_EXPECTED);
    return storeToken(T_DIV);
            }
          // fall through
          case 212: break;
          case 38:
            { 
            }
          // fall through
          case 213: break;
          case 39:
            { return storeToken(GSTRING_CONTENT);
            }
          // fall through
          case 214: break;
          case 40:
            { yypushback(1);
    yyendstate(IN_SINGLE_GSTRING);
            }
          // fall through
          case 215: break;
          case 41:
            { yyendstate(IN_SINGLE_GSTRING);
    return storeToken(GSTRING_END);
            }
          // fall through
          case 216: break;
          case 42:
            { yybeginstate(IN_GSTRING_DOLLAR);
    return storeToken(T_DOLLAR);
            }
          // fall through
          case 217: break;
          case 43:
            { return storeToken(SLASHY_CONTENT);
            }
          // fall through
          case 218: break;
          case 44:
            { yyendstate(IN_SLASHY_STRING);
    return storeToken(SLASHY_END);
            }
          // fall through
          case 219: break;
          case 45:
            { return storeToken(DOLLAR_SLASHY_CONTENT);
            }
          // fall through
          case 220: break;
          case 46:
            { yypushback(1);
    yyendstate(IN_GSTRING_DOLLAR);
            }
          // fall through
          case 221: break;
          case 47:
            { yybeginstate(IN_GSTRING_DOT);
    return storeToken(IDENTIFIER);
            }
          // fall through
          case 222: break;
          case 48:
            { yybeginstate(IN_INJECTION, NLS_AFTER_LBRACE);
    return storeToken(T_LBRACE);
            }
          // fall through
          case 223: break;
          case 49:
            { yypushback(1);
    yyendstate(IN_GSTRING_DOT);
            }
          // fall through
          case 224: break;
          case 50:
            { yypushback(1);
    yyendstate(IN_GSTRING_DOT_IDENT);
            }
          // fall through
          case 225: break;
          case 51:
            { yypushback(1);
    yyendstate(NLS_AFTER_LBRACE);
            }
          // fall through
          case 226: break;
          case 52:
            { return storeToken(T_NEQ);
            }
          // fall through
          case 227: break;
          case 53:
            { return storeToken(STRING_DQ);
            }
          // fall through
          case 228: break;
          case 54:
            { return storeToken(SH_COMMENT);
            }
          // fall through
          case 229: break;
          case 55:
            { yybeginstate(IN_DOLLAR_SLASH_STRING);
                                            return storeToken(DOLLAR_SLASHY_BEGIN);
            }
          // fall through
          case 230: break;
          case 56:
            { return storeToken(T_REM_ASSIGN);
            }
          // fall through
          case 231: break;
          case 57:
            { return storeToken(T_LAND);
            }
          // fall through
          case 232: break;
          case 58:
            { return storeToken(T_BAND_ASSIGN);
            }
          // fall through
          case 233: break;
          case 59:
            { return storeToken(T_POW);
            }
          // fall through
          case 234: break;
          case 60:
            { return storeToken(T_SPREAD_DOT);
            }
          // fall through
          case 235: break;
          case 61:
            { return storeToken(T_STAR_ASSIGN);
            }
          // fall through
          case 236: break;
          case 62:
            { return storeToken(T_INC);
            }
          // fall through
          case 237: break;
          case 63:
            { return storeToken(T_PLUS_ASSIGN);
            }
          // fall through
          case 238: break;
          case 64:
            { return storeToken(T_DEC);
            }
          // fall through
          case 239: break;
          case 65:
            { return storeToken(T_MINUS_ASSIGN);
            }
          // fall through
          case 240: break;
          case 66:
            { return storeToken(T_ARROW);
            }
          // fall through
          case 241: break;
          case 67:
            { return storeToken(T_METHOD_CLOSURE);
            }
          // fall through
          case 242: break;
          case 68:
            { return storeToken(T_RANGE);
            }
          // fall through
          case 243: break;
          case 69:
            { return storeToken(NUM_BIG_DECIMAL);
            }
          // fall through
          case 244: break;
          case 70:
            { return storeToken(ML_COMMENT);
            }
          // fall through
          case 245: break;
          case 71:
            { return storeToken(SL_COMMENT);
            }
          // fall through
          case 246: break;
          case 72:
            { return storeToken(NUM_DOUBLE);
            }
          // fall through
          case 247: break;
          case 73:
            { return storeToken(NUM_FLOAT);
            }
          // fall through
          case 248: break;
          case 74:
            { return storeToken(NUM_BIG_INT);
            }
          // fall through
          case 249: break;
          case 75:
            { return storeToken(NUM_LONG);
            }
          // fall through
          case 250: break;
          case 76:
            { return storeToken(T_METHOD_REFERENCE);
            }
          // fall through
          case 251: break;
          case 77:
            { return storeToken(T_LE);
            }
          // fall through
          case 252: break;
          case 78:
            { return storeToken(T_EQ);
            }
          // fall through
          case 253: break;
          case 79:
            { return storeToken(T_REGEX_FIND);
            }
          // fall through
          case 254: break;
          case 80:
            { return storeToken(T_GE);
            }
          // fall through
          case 255: break;
          case 81:
            { return storeToken(T_SAFE_DOT);
            }
          // fall through
          case 256: break;
          case 82:
            { return storeToken(T_ELVIS);
            }
          // fall through
          case 257: break;
          case 83:
            { return storeToken(T_ELVIS_ASSIGN);
            }
          // fall through
          case 258: break;
          case 84:
            { return storeToken(T_XOR_ASSIGN);
            }
          // fall through
          case 259: break;
          case 85:
            { return storeToken(KW_AS);
            }
          // fall through
          case 260: break;
          case 86:
            { return storeToken(KW_DO);
            }
          // fall through
          case 261: break;
          case 87:
            { return storeToken(KW_IF);
            }
          // fall through
          case 262: break;
          case 88:
            { return storeToken(KW_IN);
            }
          // fall through
          case 263: break;
          case 89:
            { return storeToken(T_BOR_ASSIGN);
            }
          // fall through
          case 264: break;
          case 90:
            { return storeToken(T_LOR);
            }
          // fall through
          case 265: break;
          case 91:
            { yypushback(1);
    yyendstate(DIVISION_EXPECTED);
    return storeToken(T_DOLLAR);
            }
          // fall through
          case 266: break;
          case 92:
            { yypushback(2);
    yyendstate(DIVISION_EXPECTED);
            }
          // fall through
          case 267: break;
          case 93:
            { yyendstate(DIVISION_EXPECTED);
    return storeToken(T_DIV_ASSIGN);
            }
          // fall through
          case 268: break;
          case 94:
            // lookahead expression with fixed base length
            zzMarkedPos = Character.offsetByCodePoints
                (zzBufferL, zzStartRead, 1);
            { return storeToken(SLASHY_CONTENT);
            }
          // fall through
          case 269: break;
          case 95:
            // lookahead expression with fixed base length
            zzMarkedPos = Character.offsetByCodePoints
                (zzBufferL, zzStartRead, 1);
            { return storeToken(DOLLAR_SLASHY_CONTENT);
            }
          // fall through
          case 270: break;
          case 96:
            { yyendstate(IN_DOLLAR_SLASH_STRING);
    return storeToken(DOLLAR_SLASHY_END);
            }
          // fall through
          case 271: break;
          case 97:
            // lookahead expression with fixed base length
            zzMarkedPos = Character.offsetByCodePoints
                (zzBufferL, zzStartRead, 1);
            { yybeginstate(IN_GSTRING_DOT_IDENT);
    return storeToken(T_DOT);
            }
          // fall through
          case 272: break;
          case 98:
            { return storeToken(T_NID);
            }
          // fall through
          case 273: break;
          case 99:
            { yybeginstate(IN_TRIPLE_GSTRING);
                                            return storeToken(GSTRING_BEGIN);
            }
          // fall through
          case 274: break;
          case 100:
            { yybeginstate(IN_TRIPLE_STRING);
            }
          // fall through
          case 275: break;
          case 101:
            { return storeToken(T_POW_ASSIGN);
            }
          // fall through
          case 276: break;
          case 102:
            { return storeToken(T_ELLIPSIS);
            }
          // fall through
          case 277: break;
          case 103:
            { return storeToken(T_RANGE_RIGHT_OPEN);
            }
          // fall through
          case 278: break;
          case 104:
            { return storeToken(GROOVY_DOC_COMMENT);
            }
          // fall through
          case 279: break;
          case 105:
            { return storeToken(T_RANGE_LEFT_OPEN);
            }
          // fall through
          case 280: break;
          case 106:
            { return storeToken(T_LSH_ASSIGN);
            }
          // fall through
          case 281: break;
          case 107:
            { return storeToken(T_COMPARE);
            }
          // fall through
          case 282: break;
          case 108:
            { return storeToken(T_ID);
            }
          // fall through
          case 283: break;
          case 109:
            { return storeToken(T_REGEX_MATCH);
            }
          // fall through
          case 284: break;
          case 110:
            { return storeToken(T_RSH_ASSIGN);
            }
          // fall through
          case 285: break;
          case 111:
            { return storeToken(T_SAFE_CHAIN_DOT);
            }
          // fall through
          case 286: break;
          case 112:
            { return storeToken(KW_DEF);
            }
          // fall through
          case 287: break;
          case 113:
            { return storeToken(KW_FOR);
            }
          // fall through
          case 288: break;
          case 114:
            { return storeToken(KW_INT);
            }
          // fall through
          case 289: break;
          case 115:
            { return storeToken(KW_NEW);
            }
          // fall through
          case 290: break;
          case 116:
            { return storeToken(KW_TRY);
            }
          // fall through
          case 291: break;
          case 117:
            { return storeToken(KW_VAR);
            }
          // fall through
          case 292: break;
          case 118:
            { yyendstate(IN_TRIPLE_STRING); return storeToken(STRING_TSQ);
            }
          // fall through
          case 293: break;
          case 119:
            { yyendstate(IN_TRIPLE_GSTRING);
    return storeToken(GSTRING_END);
            }
          // fall through
          case 294: break;
          case 120:
            // lookahead expression with fixed base length
            zzMarkedPos = Character.offsetByCodePoints
                (zzBufferL, zzStartRead, 3);
            { return storeToken(T_NOT_IN);
            }
          // fall through
          case 295: break;
          case 121:
            { return storeToken(T_RANGE_BOTH_OPEN);
            }
          // fall through
          case 296: break;
          case 122:
            { return storeToken(T_RSHU_ASSIGN);
            }
          // fall through
          case 297: break;
          case 123:
            { return storeToken(KW_BYTE);
            }
          // fall through
          case 298: break;
          case 124:
            { return storeToken(KW_CASE);
            }
          // fall through
          case 299: break;
          case 125:
            { return storeToken(KW_CHAR);
            }
          // fall through
          case 300: break;
          case 126:
            { return storeToken(KW_ELSE);
            }
          // fall through
          case 301: break;
          case 127:
            { return storeToken(KW_ENUM);
            }
          // fall through
          case 302: break;
          case 128:
            { return storeToken(KW_LONG);
            }
          // fall through
          case 303: break;
          case 129:
            { return storeToken(KW_NULL);
            }
          // fall through
          case 304: break;
          case 130:
            { return storeToken(KW_THIS);
            }
          // fall through
          case 305: break;
          case 131:
            { return storeToken(KW_TRUE);
            }
          // fall through
          case 306: break;
          case 132:
            { return storeToken(KW_VOID);
            }
          // fall through
          case 307: break;
          case 133:
            { return storeToken(KW_BREAK);
            }
          // fall through
          case 308: break;
          case 134:
            { return storeToken(KW_CATCH);
            }
          // fall through
          case 309: break;
          case 135:
            { return storeToken(KW_CLASS);
            }
          // fall through
          case 310: break;
          case 136:
            { return storeToken(KW_FALSE);
            }
          // fall through
          case 311: break;
          case 137:
            { return storeToken(KW_FINAL);
            }
          // fall through
          case 312: break;
          case 138:
            { return storeToken(KW_FLOAT);
            }
          // fall through
          case 313: break;
          case 139:
            { return storeToken(KW_SHORT);
            }
          // fall through
          case 314: break;
          case 140:
            { return storeToken(KW_SUPER);
            }
          // fall through
          case 315: break;
          case 141:
            { return storeToken(KW_THROW);
            }
          // fall through
          case 316: break;
          case 142:
            { return storeToken(KW_TRAIT);
            }
          // fall through
          case 317: break;
          case 143:
            { return storeToken(KW_WHILE);
            }
          // fall through
          case 318: break;
          case 144:
            { return storeToken(KW_YIELD);
            }
          // fall through
          case 319: break;
          case 145:
            { return storeToken(STRING_TDQ);
            }
          // fall through
          case 320: break;
          case 146:
            { return storeToken(KW_ASSERT);
            }
          // fall through
          case 321: break;
          case 147:
            { return storeToken(KW_DOUBLE);
            }
          // fall through
          case 322: break;
          case 148:
            { return storeToken(KW_IMPORT);
            }
          // fall through
          case 323: break;
          case 149:
            { return storeToken(KW_NATIVE);
            }
          // fall through
          case 324: break;
          case 150:
            { return storeToken(KW_PUBLIC);
            }
          // fall through
          case 325: break;
          case 151:
            { return storeToken(KW_RECORD);
            }
          // fall through
          case 326: break;
          case 152:
            { return storeToken(KW_RETURN);
            }
          // fall through
          case 327: break;
          case 153:
            { return storeToken(KW_SEALED);
            }
          // fall through
          case 328: break;
          case 154:
            { return storeToken(KW_STATIC);
            }
          // fall through
          case 329: break;
          case 155:
            { return storeToken(KW_SWITCH);
            }
          // fall through
          case 330: break;
          case 156:
            { return storeToken(KW_THROWS);
            }
          // fall through
          case 331: break;
          case 157:
            { return storeToken(KW_BOOLEAN);
            }
          // fall through
          case 332: break;
          case 158:
            { return storeToken(KW_DEFAULT);
            }
          // fall through
          case 333: break;
          case 159:
            { return storeToken(KW_EXTENDS);
            }
          // fall through
          case 334: break;
          case 160:
            { return storeToken(KW_FINALLY);
            }
          // fall through
          case 335: break;
          case 161:
            { return storeToken(KW_PACKAGE);
            }
          // fall through
          case 336: break;
          case 162:
            { return storeToken(KW_PERMITS);
            }
          // fall through
          case 337: break;
          case 163:
            { return storeToken(KW_PRIVATE);
            }
          // fall through
          case 338: break;
          case 164:
            { return storeToken(KW_ABSTRACT);
            }
          // fall through
          case 339: break;
          case 165:
            { return storeToken(KW_CONTINUE);
            }
          // fall through
          case 340: break;
          case 166:
            { return storeToken(KW_STRICTFP);
            }
          // fall through
          case 341: break;
          case 167:
            { return storeToken(KW_VOLATILE);
            }
          // fall through
          case 342: break;
          case 168:
            { return storeToken(KW_INTERFACE);
            }
          // fall through
          case 343: break;
          case 169:
            { return storeToken(KW_PROTECTED);
            }
          // fall through
          case 344: break;
          case 170:
            { return storeToken(KW_TRANSIENT);
            }
          // fall through
          case 345: break;
          case 171:
            { return storeToken(KW_IMPLEMENTS);
            }
          // fall through
          case 346: break;
          case 172:
            { return storeToken(KW_INSTANCEOF);
            }
          // fall through
          case 347: break;
          case 173:
            { return storeToken(KW_NON_SEALED);
            }
          // fall through
          case 348: break;
          case 174:
            // lookahead expression with fixed base length
            zzMarkedPos = Character.offsetByCodePoints
                (zzBufferL, zzStartRead, 11);
            { return storeToken(T_NOT_INSTANCEOF);
            }
          // fall through
          case 349: break;
          case 175:
            { return storeToken(KW_SYNCHRONIZED);
            }
          // fall through
          case 350: break;
          default:
            zzScanError(ZZ_NO_MATCH);
          }
      }
    }
  }
public IElementType advance()