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;
        return null;
      }
      else {
        switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
          case 1:
            { return JavaTokenType.BAD_CHARACTER;
            }
          // fall through
          case 105: break;
          case 2:
            { return JavaTokenType.EXCL;
            }
          // fall through
          case 106: break;
          case 3:
            { return JavaTokenType.IDENTIFIER;
            }
          // fall through
          case 107: break;
          case 4:
            { return JavaTokenType.PERC;
            }
          // fall through
          case 108: break;
          case 5:
            { return JavaTokenType.AND;
            }
          // fall through
          case 109: break;
          case 6:
            { return JavaTokenType.LPARENTH;
            }
          // fall through
          case 110: break;
          case 7:
            { return JavaTokenType.RPARENTH;
            }
          // fall through
          case 111: break;
          case 8:
            { return JavaTokenType.ASTERISK;
            }
          // fall through
          case 112: break;
          case 9:
            { return JavaTokenType.PLUS;
            }
          // fall through
          case 113: break;
          case 10:
            { return JavaTokenType.COMMA;
            }
          // fall through
          case 114: break;
          case 11:
            { return JavaTokenType.MINUS;
            }
          // fall through
          case 115: break;
          case 12:
            { return JavaTokenType.DOT;
            }
          // fall through
          case 116: break;
          case 13:
            { return JavaTokenType.DIV;
            }
          // fall through
          case 117: break;
          case 14:
            { return JavaTokenType.INTEGER_LITERAL;
            }
          // fall through
          case 118: break;
          case 15:
            { return JavaTokenType.COLON;
            }
          // fall through
          case 119: break;
          case 16:
            { return JavaTokenType.SEMICOLON;
            }
          // fall through
          case 120: break;
          case 17:
            { return JavaTokenType.LT;
            }
          // fall through
          case 121: break;
          case 18:
            { return JavaTokenType.EQ;
            }
          // fall through
          case 122: break;
          case 19:
            { return JavaTokenType.GT;
            }
          // fall through
          case 123: break;
          case 20:
            { return JavaTokenType.QUEST;
            }
          // fall through
          case 124: break;
          case 21:
            { return JavaTokenType.AT;
            }
          // fall through
          case 125: break;
          case 22:
            { return JavaTokenType.LBRACKET;
            }
          // fall through
          case 126: break;
          case 23:
            { return JavaTokenType.RBRACKET;
            }
          // fall through
          case 127: break;
          case 24:
            { return JavaTokenType.XOR;
            }
          // fall through
          case 128: break;
          case 25:
            { return JavaTokenType.LBRACE;
            }
          // fall through
          case 129: break;
          case 26:
            { return JavaTokenType.OR;
            }
          // fall through
          case 130: break;
          case 27:
            { return JavaTokenType.RBRACE;
            }
          // fall through
          case 131: break;
          case 28:
            { return JavaTokenType.TILDE;
            }
          // fall through
          case 132: break;
          case 29:
            { return JavaTokenType.NE;
            }
          // fall through
          case 133: break;
          case 30:
            { return JavaTokenType.PERCEQ;
            }
          // fall through
          case 134: break;
          case 31:
            { return JavaTokenType.ANDAND;
            }
          // fall through
          case 135: break;
          case 32:
            { return JavaTokenType.ANDEQ;
            }
          // fall through
          case 136: break;
          case 33:
            { return JavaTokenType.ASTERISKEQ;
            }
          // fall through
          case 137: break;
          case 34:
            { return JavaTokenType.PLUSPLUS;
            }
          // fall through
          case 138: break;
          case 35:
            { return JavaTokenType.PLUSEQ;
            }
          // fall through
          case 139: break;
          case 36:
            { return JavaTokenType.MINUSMINUS;
            }
          // fall through
          case 140: break;
          case 37:
            { return JavaTokenType.MINUSEQ;
            }
          // fall through
          case 141: break;
          case 38:
            { return JavaTokenType.ARROW;
            }
          // fall through
          case 142: break;
          case 39:
            { return JavaTokenType.DOUBLE_LITERAL;
            }
          // fall through
          case 143: break;
          case 40:
            { return JavaTokenType.DIVEQ;
            }
          // fall through
          case 144: break;
          case 41:
            { return JavaTokenType.FLOAT_LITERAL;
            }
          // fall through
          case 145: break;
          case 42:
            { return JavaTokenType.LONG_LITERAL;
            }
          // fall through
          case 146: break;
          case 43:
            { return JavaTokenType.DOUBLE_COLON;
            }
          // fall through
          case 147: break;
          case 44:
            { return JavaTokenType.LTLT;
            }
          // fall through
          case 148: break;
          case 45:
            { return JavaTokenType.LE;
            }
          // fall through
          case 149: break;
          case 46:
            { return JavaTokenType.EQEQ;
            }
          // fall through
          case 150: break;
          case 47:
            { return JavaTokenType.XOREQ;
            }
          // fall through
          case 151: break;
          case 48:
            { return JavaTokenType.DO_KEYWORD;
            }
          // fall through
          case 152: break;
          case 49:
            { return JavaTokenType.IF_KEYWORD;
            }
          // fall through
          case 153: break;
          case 50:
            { return JavaTokenType.OREQ;
            }
          // fall through
          case 154: break;
          case 51:
            { return JavaTokenType.OROR;
            }
          // fall through
          case 155: break;
          case 52:
            { return JavaTokenType.ELLIPSIS;
            }
          // fall through
          case 156: break;
          case 53:
            { return JavaTokenType.LTLTEQ;
            }
          // fall through
          case 157: break;
          case 54:
            { return JavaTokenType.FOR_KEYWORD;
            }
          // fall through
          case 158: break;
          case 55:
            { return JavaTokenType.INT_KEYWORD;
            }
          // fall through
          case 159: break;
          case 56:
            { return JavaTokenType.NEW_KEYWORD;
            }
          // fall through
          case 160: break;
          case 57:
            { return JavaTokenType.TRY_KEYWORD;
            }
          // fall through
          case 161: break;
          case 58:
            { return JavaTokenType.BYTE_KEYWORD;
            }
          // fall through
          case 162: break;
          case 59:
            { return JavaTokenType.CASE_KEYWORD;
            }
          // fall through
          case 163: break;
          case 60:
            { return JavaTokenType.CHAR_KEYWORD;
            }
          // fall through
          case 164: break;
          case 61:
            { return JavaTokenType.ELSE_KEYWORD;
            }
          // fall through
          case 165: break;
          case 62:
            { return myEnumKeyword ? JavaTokenType.ENUM_KEYWORD : JavaTokenType.IDENTIFIER;
            }
          // fall through
          case 166: break;
          case 63:
            { return JavaTokenType.GOTO_KEYWORD;
            }
          // fall through
          case 167: break;
          case 64:
            { return JavaTokenType.LONG_KEYWORD;
            }
          // fall through
          case 168: break;
          case 65:
            { return JavaTokenType.NULL_KEYWORD;
            }
          // fall through
          case 169: break;
          case 66:
            { return JavaTokenType.THIS_KEYWORD;
            }
          // fall through
          case 170: break;
          case 67:
            { return JavaTokenType.TRUE_KEYWORD;
            }
          // fall through
          case 171: break;
          case 68:
            { return JavaTokenType.VOID_KEYWORD;
            }
          // fall through
          case 172: break;
          case 69:
            { return JavaTokenType.BREAK_KEYWORD;
            }
          // fall through
          case 173: break;
          case 70:
            { return JavaTokenType.CATCH_KEYWORD;
            }
          // fall through
          case 174: break;
          case 71:
            { return JavaTokenType.CLASS_KEYWORD;
            }
          // fall through
          case 175: break;
          case 72:
            { return JavaTokenType.CONST_KEYWORD;
            }
          // fall through
          case 176: break;
          case 73:
            { return JavaTokenType.FALSE_KEYWORD;
            }
          // fall through
          case 177: break;
          case 74:
            { return JavaTokenType.FINAL_KEYWORD;
            }
          // fall through
          case 178: break;
          case 75:
            { return JavaTokenType.FLOAT_KEYWORD;
            }
          // fall through
          case 179: break;
          case 76:
            { return JavaTokenType.SHORT_KEYWORD;
            }
          // fall through
          case 180: break;
          case 77:
            { return JavaTokenType.SUPER_KEYWORD;
            }
          // fall through
          case 181: break;
          case 78:
            { return JavaTokenType.THROW_KEYWORD;
            }
          // fall through
          case 182: break;
          case 79:
            { return JavaTokenType.WHILE_KEYWORD;
            }
          // fall through
          case 183: break;
          case 80:
            { return myAssertKeyword ? JavaTokenType.ASSERT_KEYWORD : JavaTokenType.IDENTIFIER;
            }
          // fall through
          case 184: break;
          case 81:
            { return JavaTokenType.DOUBLE_KEYWORD;
            }
          // fall through
          case 185: break;
          case 82:
            { return JavaTokenType.IMPORT_KEYWORD;
            }
          // fall through
          case 186: break;
          case 83:
            { return JavaTokenType.NATIVE_KEYWORD;
            }
          // fall through
          case 187: break;
          case 84:
            { return JavaTokenType.PUBLIC_KEYWORD;
            }
          // fall through
          case 188: break;
          case 85:
            { return JavaTokenType.RETURN_KEYWORD;
            }
          // fall through
          case 189: break;
          case 86:
            { return JavaTokenType.STATIC_KEYWORD;
            }
          // fall through
          case 190: break;
          case 87:
            { return JavaTokenType.SWITCH_KEYWORD;
            }
          // fall through
          case 191: break;
          case 88:
            { return JavaTokenType.THROWS_KEYWORD;
            }
          // fall through
          case 192: break;
          case 89:
            { return JavaTokenType.BOOLEAN_KEYWORD;
            }
          // fall through
          case 193: break;
          case 90:
            { return JavaTokenType.DEFAULT_KEYWORD;
            }
          // fall through
          case 194: break;
          case 91:
            { return JavaTokenType.EXTENDS_KEYWORD;
            }
          // fall through
          case 195: break;
          case 92:
            { return JavaTokenType.FINALLY_KEYWORD;
            }
          // fall through
          case 196: break;
          case 93:
            { return JavaTokenType.PACKAGE_KEYWORD;
            }
          // fall through
          case 197: break;
          case 94:
            { return JavaTokenType.PRIVATE_KEYWORD;
            }
          // fall through
          case 198: break;
          case 95:
            { return JavaTokenType.ABSTRACT_KEYWORD;
            }
          // fall through
          case 199: break;
          case 96:
            { return JavaTokenType.CONTINUE_KEYWORD;
            }
          // fall through
          case 200: break;
          case 97:
            { return JavaTokenType.STRICTFP_KEYWORD;
            }
          // fall through
          case 201: break;
          case 98:
            { return JavaTokenType.VOLATILE_KEYWORD;
            }
          // fall through
          case 202: break;
          case 99:
            { return JavaTokenType.INTERFACE_KEYWORD;
            }
          // fall through
          case 203: break;
          case 100:
            { return JavaTokenType.PROTECTED_KEYWORD;
            }
          // fall through
          case 204: break;
          case 101:
            { return JavaTokenType.TRANSIENT_KEYWORD;
            }
          // fall through
          case 205: break;
          case 102:
            { return JavaTokenType.IMPLEMENTS_KEYWORD;
            }
          // fall through
          case 206: break;
          case 103:
            { return JavaTokenType.INSTANCEOF_KEYWORD;
            }
          // fall through
          case 207: break;
          case 104:
            { return JavaTokenType.SYNCHRONIZED_KEYWORD;
            }
          // fall through
          case 208: break;
          default:
            zzScanError(ZZ_NO_MATCH);
          }
      }
    }
  }
public IElementType advance()