View Javadoc

    1   /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
    2   package net.sourceforge.pmd.ast;
    3   public class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/
    4     protected JJTJavaParserState jjtree = new JJTJavaParserState();
    5     private boolean isJDK13;
    6     private boolean isJDK15;
    7
    8     public void setJDK13() {
    9      this.isJDK13 = true;
    10    }
    11
    12    public void setJDK15() {
    13     this.isJDK15 = true;
    14    }
    15
    16    private void checkForBadAssertUsage(String in, String usage) {
    17      if (!isJDK13 && in.equals("assert")) {
    18        throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");
    19      }
    20    }
    21
    22    private void checkForBadStaticImportUsage() {
    23      if (!isJDK15) {
    24        throw new ParseException("Can't use static imports when running in JDK 1.4 mode!");
    25      }
    26    }
    27
    28    private void checkForBadVariableArgumentsUsage() {
    29      if (!isJDK15) {
    30        throw new ParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");
    31      }
    32    }
    33
    34    private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {
    35      if (!isJDK15) {
    36        throw new ParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");
    37      }
    38    }
    39
    40    private void checkForBadEnumUsage(String in, String usage) {
    41      if (isJDK15 && in.equals("enum")) {
    42        throw new ParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");
    43      }
    44    }
    45
    46    // This is a semantic LOOKAHEAD to determine if we're dealing with an assert
    47    // Note that this can't be replaced with a syntactic lookahead
    48    // since "assert" isn't a string literal token
    49    private boolean isNextTokenAnAssert() {
    50      boolean res = getToken(1).image.equals("assert");
    51      if (res && isJDK13 && getToken(2).image.equals("(")) {
    52       res = false;
    53      }
    54      return res;
    55    }
    56
    57    private boolean isPrecededByComment(Token tok) {
    58        boolean res = false;
    59        while (!res && tok.specialToken != null) {
    60            tok = tok.specialToken;
    61            res = tok.kind == SINGLE_LINE_COMMENT ||
    62                  tok.kind == FORMAL_COMMENT ||
    63                  tok.kind == MULTI_LINE_COMMENT;
    64        }
    65        return res;
    66    }
    67
    68  /******************************************
    69   * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
    70   *****************************************/
    71
    72  /*
    73   * Program structuring syntax follows.
    74   */
    75    final public ASTCompilationUnit CompilationUnit() throws ParseException {
    76   /*@bgen(jjtree) CompilationUnit */
    77    ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
    78    boolean jjtc000 = true;
    79    jjtree.openNodeScope(jjtn000);
    80      try {
    81        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    82        case PACKAGE:
    83          PackageDeclaration();
    84          break;
    85        default:
    86          jj_la1[0] = jj_gen;
    87          ;
    88        }
    89        label_1:
    90        while (true) {
    91          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    92          case IMPORT:
    93            ;
    94            break;
    95          default:
    96            jj_la1[1] = jj_gen;
    97            break label_1;
    98          }
    99          ImportDeclaration();
    100       }
    101       label_2:
    102       while (true) {
    103         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    104         case ABSTRACT:
    105         case CLASS:
    106         case FINAL:
    107         case INTERFACE:
    108         case NATIVE:
    109         case PRIVATE:
    110         case PROTECTED:
    111         case PUBLIC:
    112         case STATIC:
    113         case SYNCHRONIZED:
    114         case TRANSIENT:
    115         case VOLATILE:
    116         case STRICTFP:
    117         case IDENTIFIER:
    118         case SEMICOLON:
    119         case AT:
    120           ;
    121           break;
    122         default:
    123           jj_la1[2] = jj_gen;
    124           break label_2;
    125         }
    126         TypeDeclaration();
    127       }
    128       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    129       case 122:
    130         jj_consume_token(122);
    131         break;
    132       default:
    133         jj_la1[3] = jj_gen;
    134         ;
    135       }
    136       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    137       case 123:
    138         jj_consume_token(123);
    139         break;
    140       default:
    141         jj_la1[4] = jj_gen;
    142         ;
    143       }
    144       jj_consume_token(0);
    145   jjtree.closeNodeScope(jjtn000, true);
    146   jjtc000 = false;
    147  {if (true) return jjtn000;}
    148     } catch (Throwable jjte000) {
    149     if (jjtc000) {
    150       jjtree.clearNodeScope(jjtn000);
    151       jjtc000 = false;
    152     } else {
    153       jjtree.popNode();
    154     }
    155     if (jjte000 instanceof RuntimeException) {
    156       {if (true) throw (RuntimeException)jjte000;}
    157     }
    158     if (jjte000 instanceof ParseException) {
    159       {if (true) throw (ParseException)jjte000;}
    160     }
    161     {if (true) throw (Error)jjte000;}
    162     } finally {
    163     if (jjtc000) {
    164       jjtree.closeNodeScope(jjtn000, true);
    165     }
    166     }
    167     throw new RuntimeException("Missing return statement in function");
    168   }
    169
    170   final public void PackageDeclaration() throws ParseException {
    171  /*@bgen(jjtree) PackageDeclaration */
    172   ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);
    173   boolean jjtc000 = true;
    174   jjtree.openNodeScope(jjtn000);
    175     try {
    176       jj_consume_token(PACKAGE);
    177       Name();
    178       jj_consume_token(SEMICOLON);
    179     } catch (Throwable jjte000) {
    180     if (jjtc000) {
    181       jjtree.clearNodeScope(jjtn000);
    182       jjtc000 = false;
    183     } else {
    184       jjtree.popNode();
    185     }
    186     if (jjte000 instanceof RuntimeException) {
    187       {if (true) throw (RuntimeException)jjte000;}
    188     }
    189     if (jjte000 instanceof ParseException) {
    190       {if (true) throw (ParseException)jjte000;}
    191     }
    192     {if (true) throw (Error)jjte000;}
    193     } finally {
    194     if (jjtc000) {
    195       jjtree.closeNodeScope(jjtn000, true);
    196     }
    197     }
    198   }
    199
    200   final public void ImportDeclaration() throws ParseException {
    201  /*@bgen(jjtree) ImportDeclaration */
    202   ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);
    203   boolean jjtc000 = true;
    204   jjtree.openNodeScope(jjtn000);
    205     try {
    206       jj_consume_token(IMPORT);
    207       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    208       case STATIC:
    209         jj_consume_token(STATIC);
    210                        checkForBadStaticImportUsage();jjtn000.setStatic();
    211         break;
    212       default:
    213         jj_la1[5] = jj_gen;
    214         ;
    215       }
    216       Name();
    217       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    218       case DOT:
    219         jj_consume_token(DOT);
    220         jj_consume_token(STAR);
    221                                                                                                 jjtn000.setImportOnDemand();
    222         break;
    223       default:
    224         jj_la1[6] = jj_gen;
    225         ;
    226       }
    227       jj_consume_token(SEMICOLON);
    228     } catch (Throwable jjte000) {
    229     if (jjtc000) {
    230       jjtree.clearNodeScope(jjtn000);
    231       jjtc000 = false;
    232     } else {
    233       jjtree.popNode();
    234     }
    235     if (jjte000 instanceof RuntimeException) {
    236       {if (true) throw (RuntimeException)jjte000;}
    237     }
    238     if (jjte000 instanceof ParseException) {
    239       {if (true) throw (ParseException)jjte000;}
    240     }
    241     {if (true) throw (Error)jjte000;}
    242     } finally {
    243     if (jjtc000) {
    244       jjtree.closeNodeScope(jjtn000, true);
    245     }
    246     }
    247   }
    248
    249 /*
    250  * Modifiers. We match all modifiers in a single rule to reduce the chances of
    251  * syntax errors for simple modifier mistakes. It will also enable us to give
    252  * better error messages.
    253  */
    254   final public int Modifiers() throws ParseException {
    255    int modifiers = 0;
    256     label_3:
    257     while (true) {
    258       if (jj_2_1(2)) {
    259         ;
    260       } else {
    261         break label_3;
    262       }
    263       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    264       case PUBLIC:
    265         jj_consume_token(PUBLIC);
    266               modifiers |= AccessNode.PUBLIC;
    267         break;
    268       case STATIC:
    269         jj_consume_token(STATIC);
    270                modifiers |= AccessNode.STATIC;
    271         break;
    272       case PROTECTED:
    273         jj_consume_token(PROTECTED);
    274                   modifiers |= AccessNode.PROTECTED;
    275         break;
    276       case PRIVATE:
    277         jj_consume_token(PRIVATE);
    278                 modifiers |= AccessNode.PRIVATE;
    279         break;
    280       case FINAL:
    281         jj_consume_token(FINAL);
    282               modifiers |= AccessNode.FINAL;
    283         break;
    284       case ABSTRACT:
    285         jj_consume_token(ABSTRACT);
    286                  modifiers |= AccessNode.ABSTRACT;
    287         break;
    288       case SYNCHRONIZED:
    289         jj_consume_token(SYNCHRONIZED);
    290                      modifiers |= AccessNode.SYNCHRONIZED;
    291         break;
    292       case NATIVE:
    293         jj_consume_token(NATIVE);
    294                modifiers |= AccessNode.NATIVE;
    295         break;
    296       case TRANSIENT:
    297         jj_consume_token(TRANSIENT);
    298                   modifiers |= AccessNode.TRANSIENT;
    299         break;
    300       case VOLATILE:
    301         jj_consume_token(VOLATILE);
    302                  modifiers |= AccessNode.VOLATILE;
    303         break;
    304       case STRICTFP:
    305         jj_consume_token(STRICTFP);
    306                  modifiers |= AccessNode.STRICTFP;
    307         break;
    308       case AT:
    309         Annotation();
    310         break;
    311       default:
    312         jj_la1[7] = jj_gen;
    313         jj_consume_token(-1);
    314         throw new ParseException();
    315       }
    316     }
    317     {if (true) return modifiers;}
    318     throw new RuntimeException("Missing return statement in function");
    319   }
    320
    321 /*
    322  * Declaration syntax follows.
    323  */
    324   final public void TypeDeclaration() throws ParseException {
    325  /*@bgen(jjtree) TypeDeclaration */
    326    ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);
    327    boolean jjtc000 = true;
    328    jjtree.openNodeScope(jjtn000);int modifiers;
    329     try {
    330       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    331       case SEMICOLON:
    332         jj_consume_token(SEMICOLON);
    333         break;
    334       case ABSTRACT:
    335       case CLASS:
    336       case FINAL:
    337       case INTERFACE:
    338       case NATIVE:
    339       case PRIVATE:
    340       case PROTECTED:
    341       case PUBLIC:
    342       case STATIC:
    343       case SYNCHRONIZED:
    344       case TRANSIENT:
    345       case VOLATILE:
    346       case STRICTFP:
    347       case IDENTIFIER:
    348       case AT:
    349         modifiers = Modifiers();
    350         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    351         case ABSTRACT:
    352         case CLASS:
    353         case FINAL:
    354         case INTERFACE:
    355           ClassOrInterfaceDeclaration(modifiers);
    356           break;
    357         case IDENTIFIER:
    358           EnumDeclaration(modifiers);
    359           break;
    360         case AT:
    361           AnnotationTypeDeclaration(modifiers);
    362           break;
    363         default:
    364           jj_la1[8] = jj_gen;
    365           jj_consume_token(-1);
    366           throw new ParseException();
    367         }
    368         break;
    369       default:
    370         jj_la1[9] = jj_gen;
    371         jj_consume_token(-1);
    372         throw new ParseException();
    373       }
    374     } catch (Throwable jjte000) {
    375     if (jjtc000) {
    376       jjtree.clearNodeScope(jjtn000);
    377       jjtc000 = false;
    378     } else {
    379       jjtree.popNode();
    380     }
    381     if (jjte000 instanceof RuntimeException) {
    382       {if (true) throw (RuntimeException)jjte000;}
    383     }
    384     if (jjte000 instanceof ParseException) {
    385       {if (true) throw (ParseException)jjte000;}
    386     }
    387     {if (true) throw (Error)jjte000;}
    388     } finally {
    389     if (jjtc000) {
    390       jjtree.closeNodeScope(jjtn000, true);
    391     }
    392     }
    393   }
    394
    395   final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
    396  /*@bgen(jjtree) ClassOrInterfaceDeclaration */
    397 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);
    398 boolean jjtc000 = true;
    399 jjtree.openNodeScope(jjtn000);Token t = null;
    400 jjtn000.setModifiers(modifiers);
    401     try {
    402       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    403       case ABSTRACT:
    404       case CLASS:
    405       case FINAL:
    406         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    407         case ABSTRACT:
    408         case FINAL:
    409           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    410           case FINAL:
    411             jj_consume_token(FINAL);
    412             break;
    413           case ABSTRACT:
    414             jj_consume_token(ABSTRACT);
    415             break;
    416           default:
    417             jj_la1[10] = jj_gen;
    418             jj_consume_token(-1);
    419             throw new ParseException();
    420           }
    421           break;
    422         default:
    423           jj_la1[11] = jj_gen;
    424           ;
    425         }
    426         jj_consume_token(CLASS);
    427         break;
    428       case INTERFACE:
    429         jj_consume_token(INTERFACE);
    430                                                                                                                      jjtn000.setInterface();
    431         break;
    432       default:
    433         jj_la1[12] = jj_gen;
    434         jj_consume_token(-1);
    435         throw new ParseException();
    436       }
    437       t = jj_consume_token(IDENTIFIER);
    438                    jjtn000.setImage(t.image);
    439       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    440       case LT:
    441         TypeParameters();
    442         break;
    443       default:
    444         jj_la1[13] = jj_gen;
    445         ;
    446       }
    447       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    448       case EXTENDS:
    449         ExtendsList();
    450         break;
    451       default:
    452         jj_la1[14] = jj_gen;
    453         ;
    454       }
    455       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    456       case IMPLEMENTS:
    457         ImplementsList();
    458         break;
    459       default:
    460         jj_la1[15] = jj_gen;
    461         ;
    462       }
    463       ClassOrInterfaceBody();
    464     } catch (Throwable jjte000) {
    465     if (jjtc000) {
    466       jjtree.clearNodeScope(jjtn000);
    467       jjtc000 = false;
    468     } else {
    469       jjtree.popNode();
    470     }
    471     if (jjte000 instanceof RuntimeException) {
    472       {if (true) throw (RuntimeException)jjte000;}
    473     }
    474     if (jjte000 instanceof ParseException) {
    475       {if (true) throw (ParseException)jjte000;}
    476     }
    477     {if (true) throw (Error)jjte000;}
    478     } finally {
    479     if (jjtc000) {
    480       jjtree.closeNodeScope(jjtn000, true);
    481     }
    482     }
    483   }
    484
    485   final public void ExtendsList() throws ParseException {
    486  /*@bgen(jjtree) ExtendsList */
    487    ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);
    488    boolean jjtc000 = true;
    489    jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;
    490     try {
    491       jj_consume_token(EXTENDS);
    492       ClassOrInterfaceType();
    493       label_4:
    494       while (true) {
    495         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    496         case COMMA:
    497           ;
    498           break;
    499         default:
    500           jj_la1[16] = jj_gen;
    501           break label_4;
    502         }
    503         jj_consume_token(COMMA);
    504         ClassOrInterfaceType();
    505                                   extendsMoreThanOne = true;
    506       }
    507     } catch (Throwable jjte000) {
    508      if (jjtc000) {
    509        jjtree.clearNodeScope(jjtn000);
    510        jjtc000 = false;
    511      } else {
    512        jjtree.popNode();
    513      }
    514      if (jjte000 instanceof RuntimeException) {
    515        {if (true) throw (RuntimeException)jjte000;}
    516      }
    517      if (jjte000 instanceof ParseException) {
    518        {if (true) throw (ParseException)jjte000;}
    519      }
    520      {if (true) throw (Error)jjte000;}
    521     } finally {
    522      if (jjtc000) {
    523        jjtree.closeNodeScope(jjtn000, true);
    524      }
    525     }
    526   }
    527
    528   final public void ImplementsList() throws ParseException {
    529  /*@bgen(jjtree) ImplementsList */
    530   ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);
    531   boolean jjtc000 = true;
    532   jjtree.openNodeScope(jjtn000);
    533     try {
    534       jj_consume_token(IMPLEMENTS);
    535       ClassOrInterfaceType();
    536       label_5:
    537       while (true) {
    538         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    539         case COMMA:
    540           ;
    541           break;
    542         default:
    543           jj_la1[17] = jj_gen;
    544           break label_5;
    545         }
    546         jj_consume_token(COMMA);
    547         ClassOrInterfaceType();
    548       }
    549     } catch (Throwable jjte000) {
    550      if (jjtc000) {
    551        jjtree.clearNodeScope(jjtn000);
    552        jjtc000 = false;
    553      } else {
    554        jjtree.popNode();
    555      }
    556      if (jjte000 instanceof RuntimeException) {
    557        {if (true) throw (RuntimeException)jjte000;}
    558      }
    559      if (jjte000 instanceof ParseException) {
    560        {if (true) throw (ParseException)jjte000;}
    561      }
    562      {if (true) throw (Error)jjte000;}
    563     } finally {
    564      if (jjtc000) {
    565        jjtree.closeNodeScope(jjtn000, true);
    566      }
    567     }
    568   }
    569
    570   final public void EnumDeclaration(int modifiers) throws ParseException {
    571  /*@bgen(jjtree) EnumDeclaration */
    572 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
    573 boolean jjtc000 = true;
    574 jjtree.openNodeScope(jjtn000);Token t;
    575 jjtn000.setModifiers(modifiers);
    576     try {
    577       t = jj_consume_token(IDENTIFIER);
    578                     ;
    579     if (!t.image.equals("enum")) {
    580       {if (true) throw new ParseException("ERROR: expecting enum");}
    581     }
    582     if (!this.isJDK15) {
    583       {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
    584     }
    585       t = jj_consume_token(IDENTIFIER);
    586                   jjtn000.setImage(t.image);
    587       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    588       case IMPLEMENTS:
    589         ImplementsList();
    590         break;
    591       default:
    592         jj_la1[18] = jj_gen;
    593         ;
    594       }
    595       EnumBody();
    596     } catch (Throwable jjte000) {
    597     if (jjtc000) {
    598       jjtree.clearNodeScope(jjtn000);
    599       jjtc000 = false;
    600     } else {
    601       jjtree.popNode();
    602     }
    603     if (jjte000 instanceof RuntimeException) {
    604       {if (true) throw (RuntimeException)jjte000;}
    605     }
    606     if (jjte000 instanceof ParseException) {
    607       {if (true) throw (ParseException)jjte000;}
    608     }
    609     {if (true) throw (Error)jjte000;}
    610     } finally {
    611     if (jjtc000) {
    612       jjtree.closeNodeScope(jjtn000, true);
    613     }
    614     }
    615   }
    616
    617   final public void EnumBody() throws ParseException {
    618  /*@bgen(jjtree) EnumBody */
    619   ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);
    620   boolean jjtc000 = true;
    621   jjtree.openNodeScope(jjtn000);
    622     try {
    623       jj_consume_token(LBRACE);
    624       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    625       case IDENTIFIER:
    626         EnumConstant();
    627         label_6:
    628         while (true) {
    629           if (jj_2_2(2)) {
    630             ;
    631           } else {
    632             break label_6;
    633           }
    634           jj_consume_token(COMMA);
    635           EnumConstant();
    636         }
    637         break;
    638       default:
    639         jj_la1[19] = jj_gen;
    640         ;
    641       }
    642       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    643       case COMMA:
    644         jj_consume_token(COMMA);
    645         break;
    646       default:
    647         jj_la1[20] = jj_gen;
    648         ;
    649       }
    650       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    651       case SEMICOLON:
    652         jj_consume_token(SEMICOLON);
    653         label_7:
    654         while (true) {
    655           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    656           case ABSTRACT:
    657           case BOOLEAN:
    658           case BYTE:
    659           case CHAR:
    660           case CLASS:
    661           case DOUBLE:
    662           case FINAL:
    663           case FLOAT:
    664           case INT:
    665           case INTERFACE:
    666           case LONG:
    667           case NATIVE:
    668           case PRIVATE:
    669           case PROTECTED:
    670           case PUBLIC:
    671           case SHORT:
    672           case STATIC:
    673           case SYNCHRONIZED:
    674           case TRANSIENT:
    675           case VOID:
    676           case VOLATILE:
    677           case STRICTFP:
    678           case IDENTIFIER:
    679           case LBRACE:
    680           case SEMICOLON:
    681           case AT:
    682           case LT:
    683             ;
    684             break;
    685           default:
    686             jj_la1[21] = jj_gen;
    687             break label_7;
    688           }
    689           ClassOrInterfaceBodyDeclaration();
    690         }
    691         break;
    692       default:
    693         jj_la1[22] = jj_gen;
    694         ;
    695       }
    696       jj_consume_token(RBRACE);
    697     } catch (Throwable jjte000) {
    698      if (jjtc000) {
    699        jjtree.clearNodeScope(jjtn000);
    700        jjtc000 = false;
    701      } else {
    702        jjtree.popNode();
    703      }
    704      if (jjte000 instanceof RuntimeException) {
    705        {if (true) throw (RuntimeException)jjte000;}
    706      }
    707      if (jjte000 instanceof ParseException) {
    708        {if (true) throw (ParseException)jjte000;}
    709      }
    710      {if (true) throw (Error)jjte000;}
    711     } finally {
    712      if (jjtc000) {
    713        jjtree.closeNodeScope(jjtn000, true);
    714      }
    715     }
    716   }
    717
    718   final public void EnumConstant() throws ParseException {
    719  /*@bgen(jjtree) EnumConstant */
    720   ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);
    721   boolean jjtc000 = true;
    722   jjtree.openNodeScope(jjtn000);
    723     try {
    724       jj_consume_token(IDENTIFIER);
    725       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    726       case LPAREN:
    727         Arguments();
    728         break;
    729       default:
    730         jj_la1[23] = jj_gen;
    731         ;
    732       }
    733       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    734       case LBRACE:
    735         ClassOrInterfaceBody();
    736         break;
    737       default:
    738         jj_la1[24] = jj_gen;
    739         ;
    740       }
    741     } catch (Throwable jjte000) {
    742     if (jjtc000) {
    743       jjtree.clearNodeScope(jjtn000);
    744       jjtc000 = false;
    745     } else {
    746       jjtree.popNode();
    747     }
    748     if (jjte000 instanceof RuntimeException) {
    749       {if (true) throw (RuntimeException)jjte000;}
    750     }
    751     if (jjte000 instanceof ParseException) {
    752       {if (true) throw (ParseException)jjte000;}
    753     }
    754     {if (true) throw (Error)jjte000;}
    755     } finally {
    756     if (jjtc000) {
    757       jjtree.closeNodeScope(jjtn000, true);
    758     }
    759     }
    760   }
    761
    762   final public void TypeParameters() throws ParseException {
    763  /*@bgen(jjtree) TypeParameters */
    764   ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);
    765   boolean jjtc000 = true;
    766   jjtree.openNodeScope(jjtn000);
    767     try {
    768       jj_consume_token(LT);
    769       TypeParameter();
    770       label_8:
    771       while (true) {
    772         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    773         case COMMA:
    774           ;
    775           break;
    776         default:
    777           jj_la1[25] = jj_gen;
    778           break label_8;
    779         }
    780         jj_consume_token(COMMA);
    781         TypeParameter();
    782       }
    783       jj_consume_token(GT);
    784     } catch (Throwable jjte000) {
    785      if (jjtc000) {
    786        jjtree.clearNodeScope(jjtn000);
    787        jjtc000 = false;
    788      } else {
    789        jjtree.popNode();
    790      }
    791      if (jjte000 instanceof RuntimeException) {
    792        {if (true) throw (RuntimeException)jjte000;}
    793      }
    794      if (jjte000 instanceof ParseException) {
    795        {if (true) throw (ParseException)jjte000;}
    796      }
    797      {if (true) throw (Error)jjte000;}
    798     } finally {
    799      if (jjtc000) {
    800        jjtree.closeNodeScope(jjtn000, true);
    801      }
    802     }
    803   }
    804
    805   final public void TypeParameter() throws ParseException {
    806  /*@bgen(jjtree) TypeParameter */
    807   ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);
    808   boolean jjtc000 = true;
    809   jjtree.openNodeScope(jjtn000);
    810     try {
    811       jj_consume_token(IDENTIFIER);
    812       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    813       case EXTENDS:
    814         TypeBound();
    815         break;
    816       default:
    817         jj_la1[26] = jj_gen;
    818         ;
    819       }
    820     } catch (Throwable jjte000) {
    821      if (jjtc000) {
    822        jjtree.clearNodeScope(jjtn000);
    823        jjtc000 = false;
    824      } else {
    825        jjtree.popNode();
    826      }
    827      if (jjte000 instanceof RuntimeException) {
    828        {if (true) throw (RuntimeException)jjte000;}
    829      }
    830      if (jjte000 instanceof ParseException) {
    831        {if (true) throw (ParseException)jjte000;}
    832      }
    833      {if (true) throw (Error)jjte000;}
    834     } finally {
    835      if (jjtc000) {
    836        jjtree.closeNodeScope(jjtn000, true);
    837      }
    838     }
    839   }
    840
    841   final public void TypeBound() throws ParseException {
    842  /*@bgen(jjtree) TypeBound */
    843   ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);
    844   boolean jjtc000 = true;
    845   jjtree.openNodeScope(jjtn000);
    846     try {
    847       jj_consume_token(EXTENDS);
    848       ClassOrInterfaceType();
    849       label_9:
    850       while (true) {
    851         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    852         case BIT_AND:
    853           ;
    854           break;
    855         default:
    856           jj_la1[27] = jj_gen;
    857           break label_9;
    858         }
    859         jj_consume_token(BIT_AND);
    860         ClassOrInterfaceType();
    861       }
    862     } catch (Throwable jjte000) {
    863      if (jjtc000) {
    864        jjtree.clearNodeScope(jjtn000);
    865        jjtc000 = false;
    866      } else {
    867        jjtree.popNode();
    868      }
    869      if (jjte000 instanceof RuntimeException) {
    870        {if (true) throw (RuntimeException)jjte000;}
    871      }
    872      if (jjte000 instanceof ParseException) {
    873        {if (true) throw (ParseException)jjte000;}
    874      }
    875      {if (true) throw (Error)jjte000;}
    876     } finally {
    877      if (jjtc000) {
    878        jjtree.closeNodeScope(jjtn000, true);
    879      }
    880     }
    881   }
    882
    883   final public void ClassOrInterfaceBody() throws ParseException {
    884  /*@bgen(jjtree) ClassOrInterfaceBody */
    885   ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);
    886   boolean jjtc000 = true;
    887   jjtree.openNodeScope(jjtn000);
    888     try {
    889       jj_consume_token(LBRACE);
    890       label_10:
    891       while (true) {
    892         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    893         case ABSTRACT:
    894         case BOOLEAN:
    895         case BYTE:
    896         case CHAR:
    897         case CLASS:
    898         case DOUBLE:
    899         case FINAL:
    900         case FLOAT:
    901         case INT:
    902         case INTERFACE:
    903         case LONG:
    904         case NATIVE:
    905         case PRIVATE:
    906         case PROTECTED:
    907         case PUBLIC:
    908         case SHORT:
    909         case STATIC:
    910         case SYNCHRONIZED:
    911         case TRANSIENT:
    912         case VOID:
    913         case VOLATILE:
    914         case STRICTFP:
    915         case IDENTIFIER:
    916         case LBRACE:
    917         case SEMICOLON:
    918         case AT:
    919         case LT:
    920           ;
    921           break;
    922         default:
    923           jj_la1[28] = jj_gen;
    924           break label_10;
    925         }
    926         ClassOrInterfaceBodyDeclaration();
    927       }
    928       jj_consume_token(RBRACE);
    929     } catch (Throwable jjte000) {
    930     if (jjtc000) {
    931       jjtree.clearNodeScope(jjtn000);
    932       jjtc000 = false;
    933     } else {
    934       jjtree.popNode();
    935     }
    936     if (jjte000 instanceof RuntimeException) {
    937       {if (true) throw (RuntimeException)jjte000;}
    938     }
    939     if (jjte000 instanceof ParseException) {
    940       {if (true) throw (ParseException)jjte000;}
    941     }
    942     {if (true) throw (Error)jjte000;}
    943     } finally {
    944     if (jjtc000) {
    945       jjtree.closeNodeScope(jjtn000, true);
    946     }
    947     }
    948   }
    949
    950   final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
    951  /*@bgen(jjtree) ClassOrInterfaceBodyDeclaration */
    952    ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);
    953    boolean jjtc000 = true;
    954    jjtree.openNodeScope(jjtn000);int modifiers;
    955     try {
    956       if (jj_2_7(2147483647)) {
    957         Initializer();
    958       } else {
    959         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    960         case ABSTRACT:
    961         case BOOLEAN:
    962         case BYTE:
    963         case CHAR:
    964         case CLASS:
    965         case DOUBLE:
    966         case FINAL:
    967         case FLOAT:
    968         case INT:
    969         case INTERFACE:
    970         case LONG:
    971         case NATIVE:
    972         case PRIVATE:
    973         case PROTECTED:
    974         case PUBLIC:
    975         case SHORT:
    976         case STATIC:
    977         case SYNCHRONIZED:
    978         case TRANSIENT:
    979         case VOID:
    980         case VOLATILE:
    981         case STRICTFP:
    982         case IDENTIFIER:
    983         case AT:
    984         case LT:
    985           modifiers = Modifiers();
    986           if (jj_2_3(3)) {
    987             ClassOrInterfaceDeclaration(modifiers);
    988           } else if (jj_2_4(3)) {
    989             EnumDeclaration(modifiers);
    990           } else if (jj_2_5(2147483647)) {
    991             ConstructorDeclaration(modifiers);
    992           } else if (jj_2_6(2147483647)) {
    993             FieldDeclaration(modifiers);
    994           } else {
    995             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    996             case BOOLEAN:
    997             case BYTE:
    998             case CHAR:
    999             case DOUBLE:
    1000             case FLOAT:
    1001             case INT:
    1002             case LONG:
    1003             case SHORT:
    1004             case VOID:
    1005             case IDENTIFIER:
    1006             case LT:
    1007               MethodDeclaration(modifiers);
    1008               break;
    1009             default:
    1010               jj_la1[29] = jj_gen;
    1011               jj_consume_token(-1);
    1012               throw new ParseException();
    1013             }
    1014           }
    1015           break;
    1016         case SEMICOLON:
    1017           jj_consume_token(SEMICOLON);
    1018           break;
    1019         default:
    1020           jj_la1[30] = jj_gen;
    1021           jj_consume_token(-1);
    1022           throw new ParseException();
    1023         }
    1024       }
    1025     } catch (Throwable jjte000) {
    1026     if (jjtc000) {
    1027       jjtree.clearNodeScope(jjtn000);
    1028       jjtc000 = false;
    1029     } else {
    1030       jjtree.popNode();
    1031     }
    1032     if (jjte000 instanceof RuntimeException) {
    1033       {if (true) throw (RuntimeException)jjte000;}
    1034     }
    1035     if (jjte000 instanceof ParseException) {
    1036       {if (true) throw (ParseException)jjte000;}
    1037     }
    1038     {if (true) throw (Error)jjte000;}
    1039     } finally {
    1040     if (jjtc000) {
    1041       jjtree.closeNodeScope(jjtn000, true);
    1042     }
    1043     }
    1044   }
    1045
    1046   final public void FieldDeclaration(int modifiers) throws ParseException {
    1047  /*@bgen(jjtree) FieldDeclaration */
    1048  ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
    1049  boolean jjtc000 = true;
    1050  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
    1051     try {
    1052       Type();
    1053       VariableDeclarator();
    1054       label_11:
    1055       while (true) {
    1056         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1057         case COMMA:
    1058           ;
    1059           break;
    1060         default:
    1061           jj_la1[31] = jj_gen;
    1062           break label_11;
    1063         }
    1064         jj_consume_token(COMMA);
    1065         VariableDeclarator();
    1066       }
    1067       jj_consume_token(SEMICOLON);
    1068     } catch (Throwable jjte000) {
    1069     if (jjtc000) {
    1070       jjtree.clearNodeScope(jjtn000);
    1071       jjtc000 = false;
    1072     } else {
    1073       jjtree.popNode();
    1074     }
    1075     if (jjte000 instanceof RuntimeException) {
    1076       {if (true) throw (RuntimeException)jjte000;}
    1077     }
    1078     if (jjte000 instanceof ParseException) {
    1079       {if (true) throw (ParseException)jjte000;}
    1080     }
    1081     {if (true) throw (Error)jjte000;}
    1082     } finally {
    1083     if (jjtc000) {
    1084       jjtree.closeNodeScope(jjtn000, true);
    1085     }
    1086     }
    1087   }
    1088
    1089   final public void VariableDeclarator() throws ParseException {
    1090  /*@bgen(jjtree) VariableDeclarator */
    1091   ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);
    1092   boolean jjtc000 = true;
    1093   jjtree.openNodeScope(jjtn000);
    1094     try {
    1095       VariableDeclaratorId();
    1096       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1097       case ASSIGN:
    1098         jj_consume_token(ASSIGN);
    1099         VariableInitializer();
    1100         break;
    1101       default:
    1102         jj_la1[32] = jj_gen;
    1103         ;
    1104       }
    1105     } catch (Throwable jjte000) {
    1106     if (jjtc000) {
    1107       jjtree.clearNodeScope(jjtn000);
    1108       jjtc000 = false;
    1109     } else {
    1110       jjtree.popNode();
    1111     }
    1112     if (jjte000 instanceof RuntimeException) {
    1113       {if (true) throw (RuntimeException)jjte000;}
    1114     }
    1115     if (jjte000 instanceof ParseException) {
    1116       {if (true) throw (ParseException)jjte000;}
    1117     }
    1118     {if (true) throw (Error)jjte000;}
    1119     } finally {
    1120     if (jjtc000) {
    1121       jjtree.closeNodeScope(jjtn000, true);
    1122     }
    1123     }
    1124   }
    1125
    1126   final public void VariableDeclaratorId() throws ParseException {
    1127  /*@bgen(jjtree) VariableDeclaratorId */
    1128  ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);
    1129  boolean jjtc000 = true;
    1130  jjtree.openNodeScope(jjtn000);Token t;
    1131     try {
    1132       t = jj_consume_token(IDENTIFIER);
    1133       label_12:
    1134       while (true) {
    1135         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1136         case LBRACKET:
    1137           ;
    1138           break;
    1139         default:
    1140           jj_la1[33] = jj_gen;
    1141           break label_12;
    1142         }
    1143         jj_consume_token(LBRACKET);
    1144         jj_consume_token(RBRACKET);
    1145                jjtn000.bumpArrayDepth();
    1146       }
    1147     jjtree.closeNodeScope(jjtn000, true);
    1148     jjtc000 = false;
    1149     checkForBadAssertUsage(t.image, "a variable name");
    1150     checkForBadEnumUsage(t.image, "a variable name");
    1151     jjtn000.setImage( t.image );
    1152     } finally {
    1153     if (jjtc000) {
    1154       jjtree.closeNodeScope(jjtn000, true);
    1155     }
    1156     }
    1157   }
    1158
    1159   final public void VariableInitializer() throws ParseException {
    1160  /*@bgen(jjtree) VariableInitializer */
    1161   ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);
    1162   boolean jjtc000 = true;
    1163   jjtree.openNodeScope(jjtn000);
    1164     try {
    1165       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1166       case LBRACE:
    1167         ArrayInitializer();
    1168         break;
    1169       case BOOLEAN:
    1170       case BYTE:
    1171       case CHAR:
    1172       case DOUBLE:
    1173       case FALSE:
    1174       case FLOAT:
    1175       case INT:
    1176       case LONG:
    1177       case NEW:
    1178       case NULL:
    1179       case SHORT:
    1180       case SUPER:
    1181       case THIS:
    1182       case TRUE:
    1183       case VOID:
    1184       case INTEGER_LITERAL:
    1185       case FLOATING_POINT_LITERAL:
    1186       case CHARACTER_LITERAL:
    1187       case STRING_LITERAL:
    1188       case IDENTIFIER:
    1189       case LPAREN:
    1190       case BANG:
    1191       case TILDE:
    1192       case INCR:
    1193       case DECR:
    1194       case PLUS:
    1195       case MINUS:
    1196         Expression();
    1197         break;
    1198       default:
    1199         jj_la1[34] = jj_gen;
    1200         jj_consume_token(-1);
    1201         throw new ParseException();
    1202       }
    1203     } catch (Throwable jjte000) {
    1204     if (jjtc000) {
    1205       jjtree.clearNodeScope(jjtn000);
    1206       jjtc000 = false;
    1207     } else {
    1208       jjtree.popNode();
    1209     }
    1210     if (jjte000 instanceof RuntimeException) {
    1211       {if (true) throw (RuntimeException)jjte000;}
    1212     }
    1213     if (jjte000 instanceof ParseException) {
    1214       {if (true) throw (ParseException)jjte000;}
    1215     }
    1216     {if (true) throw (Error)jjte000;}
    1217     } finally {
    1218     if (jjtc000) {
    1219       jjtree.closeNodeScope(jjtn000, true);
    1220     }
    1221     }
    1222   }
    1223
    1224   final public void ArrayInitializer() throws ParseException {
    1225  /*@bgen(jjtree) ArrayInitializer */
    1226   ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);
    1227   boolean jjtc000 = true;
    1228   jjtree.openNodeScope(jjtn000);
    1229     try {
    1230       jj_consume_token(LBRACE);
    1231       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1232       case BOOLEAN:
    1233       case BYTE:
    1234       case CHAR:
    1235       case DOUBLE:
    1236       case FALSE:
    1237       case FLOAT:
    1238       case INT:
    1239       case LONG:
    1240       case NEW:
    1241       case NULL:
    1242       case SHORT:
    1243       case SUPER:
    1244       case THIS:
    1245       case TRUE:
    1246       case VOID:
    1247       case INTEGER_LITERAL:
    1248       case FLOATING_POINT_LITERAL:
    1249       case CHARACTER_LITERAL:
    1250       case STRING_LITERAL:
    1251       case IDENTIFIER:
    1252       case LPAREN:
    1253       case LBRACE:
    1254       case BANG:
    1255       case TILDE:
    1256       case INCR:
    1257       case DECR:
    1258       case PLUS:
    1259       case MINUS:
    1260         VariableInitializer();
    1261         label_13:
    1262         while (true) {
    1263           if (jj_2_8(2)) {
    1264             ;
    1265           } else {
    1266             break label_13;
    1267           }
    1268           jj_consume_token(COMMA);
    1269           VariableInitializer();
    1270         }
    1271         break;
    1272       default:
    1273         jj_la1[35] = jj_gen;
    1274         ;
    1275       }
    1276       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1277       case COMMA:
    1278         jj_consume_token(COMMA);
    1279         break;
    1280       default:
    1281         jj_la1[36] = jj_gen;
    1282         ;
    1283       }
    1284       jj_consume_token(RBRACE);
    1285     } catch (Throwable jjte000) {
    1286     if (jjtc000) {
    1287       jjtree.clearNodeScope(jjtn000);
    1288       jjtc000 = false;
    1289     } else {
    1290       jjtree.popNode();
    1291     }
    1292     if (jjte000 instanceof RuntimeException) {
    1293       {if (true) throw (RuntimeException)jjte000;}
    1294     }
    1295     if (jjte000 instanceof ParseException) {
    1296       {if (true) throw (ParseException)jjte000;}
    1297     }
    1298     {if (true) throw (Error)jjte000;}
    1299     } finally {
    1300     if (jjtc000) {
    1301       jjtree.closeNodeScope(jjtn000, true);
    1302     }
    1303     }
    1304   }
    1305
    1306   final public void MethodDeclaration(int modifiers) throws ParseException {
    1307  /*@bgen(jjtree) MethodDeclaration */
    1308  ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
    1309  boolean jjtc000 = true;
    1310  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
    1311     try {
    1312       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1313       case LT:
    1314         TypeParameters();
    1315         break;
    1316       default:
    1317         jj_la1[37] = jj_gen;
    1318         ;
    1319       }
    1320       ResultType();
    1321       MethodDeclarator();
    1322       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1323       case THROWS:
    1324         jj_consume_token(THROWS);
    1325         NameList();
    1326         break;
    1327       default:
    1328         jj_la1[38] = jj_gen;
    1329         ;
    1330       }
    1331       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1332       case LBRACE:
    1333         Block();
    1334         break;
    1335       case SEMICOLON:
    1336         jj_consume_token(SEMICOLON);
    1337         break;
    1338       default:
    1339         jj_la1[39] = jj_gen;
    1340         jj_consume_token(-1);
    1341         throw new ParseException();
    1342       }
    1343     } catch (Throwable jjte000) {
    1344     if (jjtc000) {
    1345       jjtree.clearNodeScope(jjtn000);
    1346       jjtc000 = false;
    1347     } else {
    1348       jjtree.popNode();
    1349     }
    1350     if (jjte000 instanceof RuntimeException) {
    1351       {if (true) throw (RuntimeException)jjte000;}
    1352     }
    1353     if (jjte000 instanceof ParseException) {
    1354       {if (true) throw (ParseException)jjte000;}
    1355     }
    1356     {if (true) throw (Error)jjte000;}
    1357     } finally {
    1358     if (jjtc000) {
    1359       jjtree.closeNodeScope(jjtn000, true);
    1360     }
    1361     }
    1362   }
    1363
    1364   final public void MethodDeclarator() throws ParseException {
    1365  /*@bgen(jjtree) MethodDeclarator */
    1366  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
    1367  boolean jjtc000 = true;
    1368  jjtree.openNodeScope(jjtn000);Token t;
    1369     try {
    1370       t = jj_consume_token(IDENTIFIER);
    1371     checkForBadAssertUsage(t.image, "a method name");
    1372     checkForBadEnumUsage(t.image, "a method name");
    1373     jjtn000.setImage( t.image );
    1374       FormalParameters();
    1375       label_14:
    1376       while (true) {
    1377         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1378         case LBRACKET:
    1379           ;
    1380           break;
    1381         default:
    1382           jj_la1[40] = jj_gen;
    1383           break label_14;
    1384         }
    1385         jj_consume_token(LBRACKET);
    1386         jj_consume_token(RBRACKET);
    1387       }
    1388     } catch (Throwable jjte000) {
    1389     if (jjtc000) {
    1390       jjtree.clearNodeScope(jjtn000);
    1391       jjtc000 = false;
    1392     } else {
    1393       jjtree.popNode();
    1394     }
    1395     if (jjte000 instanceof RuntimeException) {
    1396       {if (true) throw (RuntimeException)jjte000;}
    1397     }
    1398     if (jjte000 instanceof ParseException) {
    1399       {if (true) throw (ParseException)jjte000;}
    1400     }
    1401     {if (true) throw (Error)jjte000;}
    1402     } finally {
    1403     if (jjtc000) {
    1404       jjtree.closeNodeScope(jjtn000, true);
    1405     }
    1406     }
    1407   }
    1408
    1409   final public void FormalParameters() throws ParseException {
    1410  /*@bgen(jjtree) FormalParameters */
    1411   ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
    1412   boolean jjtc000 = true;
    1413   jjtree.openNodeScope(jjtn000);
    1414     try {
    1415       jj_consume_token(LPAREN);
    1416       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1417       case BOOLEAN:
    1418       case BYTE:
    1419       case CHAR:
    1420       case DOUBLE:
    1421       case FINAL:
    1422       case FLOAT:
    1423       case INT:
    1424       case LONG:
    1425       case SHORT:
    1426       case IDENTIFIER:
    1427       case AT:
    1428         FormalParameter();
    1429         label_15:
    1430         while (true) {
    1431           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1432           case COMMA:
    1433             ;
    1434             break;
    1435           default:
    1436             jj_la1[41] = jj_gen;
    1437             break label_15;
    1438           }
    1439           jj_consume_token(COMMA);
    1440           FormalParameter();
    1441         }
    1442         break;
    1443       default:
    1444         jj_la1[42] = jj_gen;
    1445         ;
    1446       }
    1447       jj_consume_token(RPAREN);
    1448     } catch (Throwable jjte000) {
    1449     if (jjtc000) {
    1450       jjtree.clearNodeScope(jjtn000);
    1451       jjtc000 = false;
    1452     } else {
    1453       jjtree.popNode();
    1454     }
    1455     if (jjte000 instanceof RuntimeException) {
    1456       {if (true) throw (RuntimeException)jjte000;}
    1457     }
    1458     if (jjte000 instanceof ParseException) {
    1459       {if (true) throw (ParseException)jjte000;}
    1460     }
    1461     {if (true) throw (Error)jjte000;}
    1462     } finally {
    1463     if (jjtc000) {
    1464       jjtree.closeNodeScope(jjtn000, true);
    1465     }
    1466     }
    1467   }
    1468
    1469   final public void FormalParameter() throws ParseException {
    1470  /*@bgen(jjtree) FormalParameter */
    1471   ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
    1472   boolean jjtc000 = true;
    1473   jjtree.openNodeScope(jjtn000);
    1474     try {
    1475       label_16:
    1476       while (true) {
    1477         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1478         case FINAL:
    1479         case AT:
    1480           ;
    1481           break;
    1482         default:
    1483           jj_la1[43] = jj_gen;
    1484           break label_16;
    1485         }
    1486         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1487         case FINAL:
    1488           jj_consume_token(FINAL);
    1489               jjtn000.setFinal();
    1490           break;
    1491         case AT:
    1492           Annotation();
    1493           break;
    1494         default:
    1495           jj_la1[44] = jj_gen;
    1496           jj_consume_token(-1);
    1497           throw new ParseException();
    1498         }
    1499       }
    1500       Type();
    1501       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1502       case ELLIPSIS:
    1503         jj_consume_token(ELLIPSIS);
    1504             checkForBadVariableArgumentsUsage();
    1505         break;
    1506       default:
    1507         jj_la1[45] = jj_gen;
    1508         ;
    1509       }
    1510       VariableDeclaratorId();
    1511     } catch (Throwable jjte000) {
    1512      if (jjtc000) {
    1513        jjtree.clearNodeScope(jjtn000);
    1514        jjtc000 = false;
    1515      } else {
    1516        jjtree.popNode();
    1517      }
    1518      if (jjte000 instanceof RuntimeException) {
    1519        {if (true) throw (RuntimeException)jjte000;}
    1520      }
    1521      if (jjte000 instanceof ParseException) {
    1522        {if (true) throw (ParseException)jjte000;}
    1523      }
    1524      {if (true) throw (Error)jjte000;}
    1525     } finally {
    1526      if (jjtc000) {
    1527        jjtree.closeNodeScope(jjtn000, true);
    1528      }
    1529     }
    1530   }
    1531
    1532   final public void ConstructorDeclaration(int modifiers) throws ParseException {
    1533  /*@bgen(jjtree) ConstructorDeclaration */
    1534  ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);
    1535  boolean jjtc000 = true;
    1536  jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
    1537 Token t;
    1538     try {
    1539       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1540       case LT:
    1541         TypeParameters();
    1542         break;
    1543       default:
    1544         jj_la1[46] = jj_gen;
    1545         ;
    1546       }
    1547       jj_consume_token(IDENTIFIER);
    1548       FormalParameters();
    1549       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1550       case THROWS:
    1551         jj_consume_token(THROWS);
    1552         NameList();
    1553         break;
    1554       default:
    1555         jj_la1[47] = jj_gen;
    1556         ;
    1557       }
    1558       jj_consume_token(LBRACE);
    1559       if (jj_2_9(2147483647)) {
    1560         ExplicitConstructorInvocation();
    1561       } else {
    1562         ;
    1563       }
    1564       label_17:
    1565       while (true) {
    1566         if (jj_2_10(1)) {
    1567           ;
    1568         } else {
    1569           break label_17;
    1570         }
    1571         BlockStatement();
    1572       }
    1573       t = jj_consume_token(RBRACE);
    1574             jjtree.closeNodeScope(jjtn000, true);
    1575             jjtc000 = false;
    1576             if (isPrecededByComment(t)) { jjtn000.setContainsComment(); };
    1577     } catch (Throwable jjte000) {
    1578       if (jjtc000) {
    1579         jjtree.clearNodeScope(jjtn000);
    1580         jjtc000 = false;
    1581       } else {
    1582         jjtree.popNode();
    1583       }
    1584       if (jjte000 instanceof RuntimeException) {
    1585         {if (true) throw (RuntimeException)jjte000;}
    1586       }
    1587       if (jjte000 instanceof ParseException) {
    1588         {if (true) throw (ParseException)jjte000;}
    1589       }
    1590       {if (true) throw (Error)jjte000;}
    1591     } finally {
    1592       if (jjtc000) {
    1593         jjtree.closeNodeScope(jjtn000, true);
    1594       }
    1595     }
    1596   }
    1597
    1598   final public void ExplicitConstructorInvocation() throws ParseException {
    1599  /*@bgen(jjtree) ExplicitConstructorInvocation */
    1600   ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION);
    1601   boolean jjtc000 = true;
    1602   jjtree.openNodeScope(jjtn000);
    1603     try {
    1604       if (jj_2_12(2147483647)) {
    1605         jj_consume_token(THIS);
    1606                                              jjtn000.setIsThis();
    1607         Arguments();
    1608         jj_consume_token(SEMICOLON);
    1609       } else {
    1610         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1611         case BOOLEAN:
    1612         case BYTE:
    1613         case CHAR:
    1614         case DOUBLE:
    1615         case FALSE:
    1616         case FLOAT:
    1617         case INT:
    1618         case LONG:
    1619         case NEW:
    1620         case NULL:
    1621         case SHORT:
    1622         case SUPER:
    1623         case THIS:
    1624         case TRUE:
    1625         case VOID:
    1626         case INTEGER_LITERAL:
    1627         case FLOATING_POINT_LITERAL:
    1628         case CHARACTER_LITERAL:
    1629         case STRING_LITERAL:
    1630         case IDENTIFIER:
    1631         case LPAREN:
    1632           if (jj_2_11(2)) {
    1633             PrimaryExpression();
    1634             jj_consume_token(DOT);
    1635             jj_consume_token(SUPER);
    1636             jj_consume_token(LPAREN);
    1637           } else {
    1638             ;
    1639           }
    1640           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1641           case SUPER:
    1642             jj_consume_token(SUPER);
    1643             break;
    1644           case THIS:
    1645             jj_consume_token(THIS);
    1646             break;
    1647           default:
    1648             jj_la1[48] = jj_gen;
    1649             jj_consume_token(-1);
    1650             throw new ParseException();
    1651           }
    1652           Arguments();
    1653           jj_consume_token(SEMICOLON);
    1654           break;
    1655         default:
    1656           jj_la1[49] = jj_gen;
    1657           jj_consume_token(-1);
    1658           throw new ParseException();
    1659         }
    1660       }
    1661     } catch (Throwable jjte000) {
    1662     if (jjtc000) {
    1663       jjtree.clearNodeScope(jjtn000);
    1664       jjtc000 = false;
    1665     } else {
    1666       jjtree.popNode();
    1667     }
    1668     if (jjte000 instanceof RuntimeException) {
    1669       {if (true) throw (RuntimeException)jjte000;}
    1670     }
    1671     if (jjte000 instanceof ParseException) {
    1672       {if (true) throw (ParseException)jjte000;}
    1673     }
    1674     {if (true) throw (Error)jjte000;}
    1675     } finally {
    1676     if (jjtc000) {
    1677       jjtree.closeNodeScope(jjtn000, true);
    1678     }
    1679     }
    1680   }
    1681
    1682   final public void Initializer() throws ParseException {
    1683  /*@bgen(jjtree) Initializer */
    1684   ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER);
    1685   boolean jjtc000 = true;
    1686   jjtree.openNodeScope(jjtn000);
    1687     try {
    1688       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1689       case STATIC:
    1690         jj_consume_token(STATIC);
    1691               jjtn000.setStatic();
    1692         break;
    1693       default:
    1694         jj_la1[50] = jj_gen;
    1695         ;
    1696       }
    1697       Block();
    1698     } catch (Throwable jjte000) {
    1699     if (jjtc000) {
    1700       jjtree.clearNodeScope(jjtn000);
    1701       jjtc000 = false;
    1702     } else {
    1703       jjtree.popNode();
    1704     }
    1705     if (jjte000 instanceof RuntimeException) {
    1706       {if (true) throw (RuntimeException)jjte000;}
    1707     }
    1708     if (jjte000 instanceof ParseException) {
    1709       {if (true) throw (ParseException)jjte000;}
    1710     }
    1711     {if (true) throw (Error)jjte000;}
    1712     } finally {
    1713     if (jjtc000) {
    1714       jjtree.closeNodeScope(jjtn000, true);
    1715     }
    1716     }
    1717   }
    1718
    1719 /*
    1720  * Type, name and expression syntax follows.
    1721  */
    1722   final public void Type() throws ParseException {
    1723  /*@bgen(jjtree) Type */
    1724   ASTType jjtn000 = new ASTType(this, JJTTYPE);
    1725   boolean jjtc000 = true;
    1726   jjtree.openNodeScope(jjtn000);
    1727     try {
    1728       if (jj_2_13(2)) {
    1729         ReferenceType();
    1730       } else {
    1731         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1732         case BOOLEAN:
    1733         case BYTE:
    1734         case CHAR:
    1735         case DOUBLE:
    1736         case FLOAT:
    1737         case INT:
    1738         case LONG:
    1739         case SHORT:
    1740           PrimitiveType();
    1741           break;
    1742         default:
    1743           jj_la1[51] = jj_gen;
    1744           jj_consume_token(-1);
    1745           throw new ParseException();
    1746         }
    1747       }
    1748     } catch (Throwable jjte000) {
    1749      if (jjtc000) {
    1750        jjtree.clearNodeScope(jjtn000);
    1751        jjtc000 = false;
    1752      } else {
    1753        jjtree.popNode();
    1754      }
    1755      if (jjte000 instanceof RuntimeException) {
    1756        {if (true) throw (RuntimeException)jjte000;}
    1757      }
    1758      if (jjte000 instanceof ParseException) {
    1759        {if (true) throw (ParseException)jjte000;}
    1760      }
    1761      {if (true) throw (Error)jjte000;}
    1762     } finally {
    1763      if (jjtc000) {
    1764        jjtree.closeNodeScope(jjtn000, true);
    1765      }
    1766     }
    1767   }
    1768
    1769   final public void ReferenceType() throws ParseException {
    1770  /*@bgen(jjtree) ReferenceType */
    1771   ASTReferenceType jjtn000 = new ASTReferenceType(this, JJTREFERENCETYPE);
    1772   boolean jjtc000 = true;
    1773   jjtree.openNodeScope(jjtn000);
    1774     try {
    1775       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1776       case BOOLEAN:
    1777       case BYTE:
    1778       case CHAR:
    1779       case DOUBLE:
    1780       case FLOAT:
    1781       case INT:
    1782       case LONG:
    1783       case SHORT:
    1784         PrimitiveType();
    1785         label_18:
    1786         while (true) {
    1787           jj_consume_token(LBRACKET);
    1788           jj_consume_token(RBRACKET);
    1789                                             jjtn000.bumpArrayDepth();
    1790           if (jj_2_14(2)) {
    1791             ;
    1792           } else {
    1793             break label_18;
    1794           }
    1795         }
    1796         break;
    1797       case IDENTIFIER:
    1798         ClassOrInterfaceType();
    1799         label_19:
    1800         while (true) {
    1801           if (jj_2_15(2)) {
    1802             ;
    1803           } else {
    1804             break label_19;
    1805           }
    1806           jj_consume_token(LBRACKET);
    1807           jj_consume_token(RBRACKET);
    1808                                                        jjtn000.bumpArrayDepth();
    1809         }
    1810         break;
    1811       default:
    1812         jj_la1[52] = jj_gen;
    1813         jj_consume_token(-1);
    1814         throw new ParseException();
    1815       }
    1816     } catch (Throwable jjte000) {
    1817      if (jjtc000) {
    1818        jjtree.clearNodeScope(jjtn000);
    1819        jjtc000 = false;
    1820      } else {
    1821        jjtree.popNode();
    1822      }
    1823      if (jjte000 instanceof RuntimeException) {
    1824        {if (true) throw (RuntimeException)jjte000;}
    1825      }
    1826      if (jjte000 instanceof ParseException) {
    1827        {if (true) throw (ParseException)jjte000;}
    1828      }
    1829      {if (true) throw (Error)jjte000;}
    1830     } finally {
    1831      if (jjtc000) {
    1832        jjtree.closeNodeScope(jjtn000, true);
    1833      }
    1834     }
    1835   }
    1836
    1837   final public void ClassOrInterfaceType() throws ParseException {
    1838  /*@bgen(jjtree) ClassOrInterfaceType */
    1839   ASTClassOrInterfaceType jjtn000 = new ASTClassOrInterfaceType(this, JJTCLASSORINTERFACETYPE);
    1840   boolean jjtc000 = true;
    1841   jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
    1842   Token t;
    1843     try {
    1844       t = jj_consume_token(IDENTIFIER);
    1845                   s.append(t.image);
    1846       if (jj_2_16(2)) {
    1847         TypeArguments();
    1848       } else {
    1849         ;
    1850       }
    1851       label_20:
    1852       while (true) {
    1853         if (jj_2_17(2)) {
    1854           ;
    1855         } else {
    1856           break label_20;
    1857         }
    1858         jj_consume_token(DOT);
    1859         t = jj_consume_token(IDENTIFIER);
    1860                                      s.append('.').append(t.image);
    1861         if (jj_2_18(2)) {
    1862           TypeArguments();
    1863         } else {
    1864           ;
    1865         }
    1866       }
    1867     jjtree.closeNodeScope(jjtn000, true);
    1868     jjtc000 = false;
    1869    jjtn000.setImage(s.toString());
    1870     } catch (Throwable jjte000) {
    1871     if (jjtc000) {
    1872       jjtree.clearNodeScope(jjtn000);
    1873       jjtc000 = false;
    1874     } else {
    1875       jjtree.popNode();
    1876     }
    1877     if (jjte000 instanceof RuntimeException) {
    1878       {if (true) throw (RuntimeException)jjte000;}
    1879     }
    1880     if (jjte000 instanceof ParseException) {
    1881       {if (true) throw (ParseException)jjte000;}
    1882     }
    1883     {if (true) throw (Error)jjte000;}
    1884     } finally {
    1885     if (jjtc000) {
    1886       jjtree.closeNodeScope(jjtn000, true);
    1887     }
    1888     }
    1889   }
    1890
    1891   final public void TypeArguments() throws ParseException {
    1892  /*@bgen(jjtree) TypeArguments */
    1893   ASTTypeArguments jjtn000 = new ASTTypeArguments(this, JJTTYPEARGUMENTS);
    1894   boolean jjtc000 = true;
    1895   jjtree.openNodeScope(jjtn000);
    1896     try {
    1897       jj_consume_token(LT);
    1898       TypeArgument();
    1899       label_21:
    1900       while (true) {
    1901         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1902         case COMMA:
    1903           ;
    1904           break;
    1905         default:
    1906           jj_la1[53] = jj_gen;
    1907           break label_21;
    1908         }
    1909         jj_consume_token(COMMA);
    1910         TypeArgument();
    1911       }
    1912       jj_consume_token(GT);
    1913     } catch (Throwable jjte000) {
    1914      if (jjtc000) {
    1915        jjtree.clearNodeScope(jjtn000);
    1916        jjtc000 = false;
    1917      } else {
    1918        jjtree.popNode();
    1919      }
    1920      if (jjte000 instanceof RuntimeException) {
    1921        {if (true) throw (RuntimeException)jjte000;}
    1922      }
    1923      if (jjte000 instanceof ParseException) {
    1924        {if (true) throw (ParseException)jjte000;}
    1925      }
    1926      {if (true) throw (Error)jjte000;}
    1927     } finally {
    1928      if (jjtc000) {
    1929        jjtree.closeNodeScope(jjtn000, true);
    1930      }
    1931     }
    1932   }
    1933
    1934   final public void TypeArgument() throws ParseException {
    1935  /*@bgen(jjtree) TypeArgument */
    1936   ASTTypeArgument jjtn000 = new ASTTypeArgument(this, JJTTYPEARGUMENT);
    1937   boolean jjtc000 = true;
    1938   jjtree.openNodeScope(jjtn000);
    1939     try {
    1940       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1941       case BOOLEAN:
    1942       case BYTE:
    1943       case CHAR:
    1944       case DOUBLE:
    1945       case FLOAT:
    1946       case INT:
    1947       case LONG:
    1948       case SHORT:
    1949       case IDENTIFIER:
    1950         ReferenceType();
    1951         break;
    1952       case HOOK:
    1953         jj_consume_token(HOOK);
    1954         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1955         case EXTENDS:
    1956         case SUPER:
    1957           WildcardBounds();
    1958           break;
    1959         default:
    1960           jj_la1[54] = jj_gen;
    1961           ;
    1962         }
    1963         break;
    1964       default:
    1965         jj_la1[55] = jj_gen;
    1966         jj_consume_token(-1);
    1967         throw new ParseException();
    1968       }
    1969     } catch (Throwable jjte000) {
    1970      if (jjtc000) {
    1971        jjtree.clearNodeScope(jjtn000);
    1972        jjtc000 = false;
    1973      } else {
    1974        jjtree.popNode();
    1975      }
    1976      if (jjte000 instanceof RuntimeException) {
    1977        {if (true) throw (RuntimeException)jjte000;}
    1978      }
    1979      if (jjte000 instanceof ParseException) {
    1980        {if (true) throw (ParseException)jjte000;}
    1981      }
    1982      {if (true) throw (Error)jjte000;}
    1983     } finally {
    1984      if (jjtc000) {
    1985        jjtree.closeNodeScope(jjtn000, true);
    1986      }
    1987     }
    1988   }
    1989
    1990   final public void WildcardBounds() throws ParseException {
    1991  /*@bgen(jjtree) WildcardBounds */
    1992   ASTWildcardBounds jjtn000 = new ASTWildcardBounds(this, JJTWILDCARDBOUNDS);
    1993   boolean jjtc000 = true;
    1994   jjtree.openNodeScope(jjtn000);
    1995     try {
    1996       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1997       case EXTENDS:
    1998         jj_consume_token(EXTENDS);
    1999         ReferenceType();
    2000         break;
    2001       case SUPER:
    2002         jj_consume_token(SUPER);
    2003         ReferenceType();
    2004         break;
    2005       default:
    2006         jj_la1[56] = jj_gen;
    2007         jj_consume_token(-1);
    2008         throw new ParseException();
    2009       }
    2010     } catch (Throwable jjte000) {
    2011      if (jjtc000) {
    2012        jjtree.clearNodeScope(jjtn000);
    2013        jjtc000 = false;
    2014      } else {
    2015        jjtree.popNode();
    2016      }
    2017      if (jjte000 instanceof RuntimeException) {
    2018        {if (true) throw (RuntimeException)jjte000;}
    2019      }
    2020      if (jjte000 instanceof ParseException) {
    2021        {if (true) throw (ParseException)jjte000;}
    2022      }
    2023      {if (true) throw (Error)jjte000;}
    2024     } finally {
    2025      if (jjtc000) {
    2026        jjtree.closeNodeScope(jjtn000, true);
    2027      }
    2028     }
    2029   }
    2030
    2031   final public void PrimitiveType() throws ParseException {
    2032  /*@bgen(jjtree) PrimitiveType */
    2033   ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE);
    2034   boolean jjtc000 = true;
    2035   jjtree.openNodeScope(jjtn000);
    2036     try {
    2037       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2038       case BOOLEAN:
    2039         jj_consume_token(BOOLEAN);
    2040               jjtree.closeNodeScope(jjtn000, true);
    2041               jjtc000 = false;
    2042              jjtn000.setImage("boolean");
    2043         break;
    2044       case CHAR:
    2045         jj_consume_token(CHAR);
    2046            jjtree.closeNodeScope(jjtn000, true);
    2047            jjtc000 = false;
    2048           jjtn000.setImage("char");
    2049         break;
    2050       case BYTE:
    2051         jj_consume_token(BYTE);
    2052            jjtree.closeNodeScope(jjtn000, true);
    2053            jjtc000 = false;
    2054           jjtn000.setImage("byte");
    2055         break;
    2056       case SHORT:
    2057         jj_consume_token(SHORT);
    2058             jjtree.closeNodeScope(jjtn000, true);
    2059             jjtc000 = false;
    2060            jjtn000.setImage("short");
    2061         break;
    2062       case INT:
    2063         jj_consume_token(INT);
    2064           jjtree.closeNodeScope(jjtn000, true);
    2065           jjtc000 = false;
    2066          jjtn000.setImage("int");
    2067         break;
    2068       case LONG:
    2069         jj_consume_token(LONG);
    2070            jjtree.closeNodeScope(jjtn000, true);
    2071            jjtc000 = false;
    2072           jjtn000.setImage("long");
    2073         break;
    2074       case FLOAT:
    2075         jj_consume_token(FLOAT);
    2076             jjtree.closeNodeScope(jjtn000, true);
    2077             jjtc000 = false;
    2078            jjtn000.setImage("float");
    2079         break;
    2080       case DOUBLE:
    2081         jj_consume_token(DOUBLE);
    2082              jjtree.closeNodeScope(jjtn000, true);
    2083              jjtc000 = false;
    2084             jjtn000.setImage("double");
    2085         break;
    2086       default:
    2087         jj_la1[57] = jj_gen;
    2088         jj_consume_token(-1);
    2089         throw new ParseException();
    2090       }
    2091     } finally {
    2092     if (jjtc000) {
    2093       jjtree.closeNodeScope(jjtn000, true);
    2094     }
    2095     }
    2096   }
    2097
    2098   final public void ResultType() throws ParseException {
    2099  /*@bgen(jjtree) ResultType */
    2100   ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE);
    2101   boolean jjtc000 = true;
    2102   jjtree.openNodeScope(jjtn000);
    2103     try {
    2104       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2105       case VOID:
    2106         jj_consume_token(VOID);
    2107         break;
    2108       case BOOLEAN:
    2109       case BYTE:
    2110       case CHAR:
    2111       case DOUBLE:
    2112       case FLOAT:
    2113       case INT:
    2114       case LONG:
    2115       case SHORT:
    2116       case IDENTIFIER:
    2117         Type();
    2118         break;
    2119       default:
    2120         jj_la1[58] = jj_gen;
    2121         jj_consume_token(-1);
    2122         throw new ParseException();
    2123       }
    2124     } catch (Throwable jjte000) {
    2125     if (jjtc000) {
    2126       jjtree.clearNodeScope(jjtn000);
    2127       jjtc000 = false;
    2128     } else {
    2129       jjtree.popNode();
    2130     }
    2131     if (jjte000 instanceof RuntimeException) {
    2132       {if (true) throw (RuntimeException)jjte000;}
    2133     }
    2134     if (jjte000 instanceof ParseException) {
    2135       {if (true) throw (ParseException)jjte000;}
    2136     }
    2137     {if (true) throw (Error)jjte000;}
    2138     } finally {
    2139     if (jjtc000) {
    2140       jjtree.closeNodeScope(jjtn000, true);
    2141     }
    2142     }
    2143   }
    2144
    2145   final public void Name() throws ParseException {
    2146  /*@bgen(jjtree) Name */
    2147   ASTName jjtn000 = new ASTName(this, JJTNAME);
    2148   boolean jjtc000 = true;
    2149   jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
    2150   Token t;
    2151     try {
    2152       t = jj_consume_token(IDENTIFIER);
    2153     jjtn000.testingOnly__setBeginLine( t.beginLine);
    2154     jjtn000.testingOnly__setBeginColumn( t.beginColumn);
    2155     s.append(t.image);
    2156       label_22:
    2157       while (true) {
    2158         if (jj_2_19(2)) {
    2159           ;
    2160         } else {
    2161           break label_22;
    2162         }
    2163         jj_consume_token(DOT);
    2164         t = jj_consume_token(IDENTIFIER);
    2165      s.append('.').append(t.image);
    2166       }
    2167     jjtree.closeNodeScope(jjtn000, true);
    2168     jjtc000 = false;
    2169    jjtn000.setImage(s.toString());
    2170     } finally {
    2171     if (jjtc000) {
    2172       jjtree.closeNodeScope(jjtn000, true);
    2173     }
    2174     }
    2175   }
    2176
    2177   final public void NameList() throws ParseException {
    2178  /*@bgen(jjtree) NameList */
    2179   ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);
    2180   boolean jjtc000 = true;
    2181   jjtree.openNodeScope(jjtn000);
    2182     try {
    2183       Name();
    2184       label_23:
    2185       while (true) {
    2186         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2187         case COMMA:
    2188           ;
    2189           break;
    2190         default:
    2191           jj_la1[59] = jj_gen;
    2192           break label_23;
    2193         }
    2194         jj_consume_token(COMMA);
    2195         Name();
    2196       }
    2197     } catch (Throwable jjte000) {
    2198     if (jjtc000) {
    2199       jjtree.clearNodeScope(jjtn000);
    2200       jjtc000 = false;
    2201     } else {
    2202       jjtree.popNode();
    2203     }
    2204     if (jjte000 instanceof RuntimeException) {
    2205       {if (true) throw (RuntimeException)jjte000;}
    2206     }
    2207     if (jjte000 instanceof ParseException) {
    2208       {if (true) throw (ParseException)jjte000;}
    2209     }
    2210     {if (true) throw (Error)jjte000;}
    2211     } finally {
    2212     if (jjtc000) {
    2213       jjtree.closeNodeScope(jjtn000, true);
    2214     }
    2215     }
    2216   }
    2217
    2218 /*
    2219  * Expression syntax follows.
    2220  */
    2221   final public void Expression() throws ParseException {
    2222  /*@bgen(jjtree) Expression */
    2223   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
    2224   boolean jjtc000 = true;
    2225   jjtree.openNodeScope(jjtn000);
    2226     try {
    2227       ConditionalExpression();
    2228       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2229       case ASSIGN:
    2230       case PLUSASSIGN:
    2231       case MINUSASSIGN:
    2232       case STARASSIGN:
    2233       case SLASHASSIGN:
    2234       case ANDASSIGN:
    2235       case ORASSIGN:
    2236       case XORASSIGN:
    2237       case REMASSIGN:
    2238       case LSHIFTASSIGN:
    2239       case RSIGNEDSHIFTASSIGN:
    2240       case RUNSIGNEDSHIFTASSIGN:
    2241         AssignmentOperator();
    2242         Expression();
    2243         break;
    2244       default:
    2245         jj_la1[60] = jj_gen;
    2246         ;
    2247       }
    2248     } catch (Throwable jjte000) {
    2249     if (jjtc000) {
    2250       jjtree.clearNodeScope(jjtn000);
    2251       jjtc000 = false;
    2252     } else {
    2253       jjtree.popNode();
    2254     }
    2255     if (jjte000 instanceof RuntimeException) {
    2256       {if (true) throw (RuntimeException)jjte000;}
    2257     }
    2258     if (jjte000 instanceof ParseException) {
    2259       {if (true) throw (ParseException)jjte000;}
    2260     }
    2261     {if (true) throw (Error)jjte000;}
    2262     } finally {
    2263     if (jjtc000) {
    2264       jjtree.closeNodeScope(jjtn000, true);
    2265     }
    2266     }
    2267   }
    2268
    2269   final public void AssignmentOperator() throws ParseException {
    2270  /*@bgen(jjtree) AssignmentOperator */
    2271   ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);
    2272   boolean jjtc000 = true;
    2273   jjtree.openNodeScope(jjtn000);
    2274     try {
    2275       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2276       case ASSIGN:
    2277         jj_consume_token(ASSIGN);
    2278                 jjtree.closeNodeScope(jjtn000, true);
    2279                 jjtc000 = false;
    2280                jjtn000.setImage("=");
    2281         break;
    2282       case STARASSIGN:
    2283         jj_consume_token(STARASSIGN);
    2284                 jjtree.closeNodeScope(jjtn000, true);
    2285                 jjtc000 = false;
    2286                jjtn000.setImage("*="); jjtn000.setCompound();
    2287         break;
    2288       case SLASHASSIGN:
    2289         jj_consume_token(SLASHASSIGN);
    2290                 jjtree.closeNodeScope(jjtn000, true);
    2291                 jjtc000 = false;
    2292                jjtn000.setImage("/="); jjtn000.setCompound();
    2293         break;
    2294       case REMASSIGN:
    2295         jj_consume_token(REMASSIGN);
    2296                 jjtree.closeNodeScope(jjtn000, true);
    2297                 jjtc000 = false;
    2298                jjtn000.setImage("%="); jjtn000.setCompound();
    2299         break;
    2300       case PLUSASSIGN:
    2301         jj_consume_token(PLUSASSIGN);
    2302                 jjtree.closeNodeScope(jjtn000, true);
    2303                 jjtc000 = false;
    2304                jjtn000.setImage("+="); jjtn000.setCompound();
    2305         break;
    2306       case MINUSASSIGN:
    2307         jj_consume_token(MINUSASSIGN);
    2308                 jjtree.closeNodeScope(jjtn000, true);
    2309                 jjtc000 = false;
    2310                jjtn000.setImage("-="); jjtn000.setCompound();
    2311         break;
    2312       case LSHIFTASSIGN:
    2313         jj_consume_token(LSHIFTASSIGN);
    2314                 jjtree.closeNodeScope(jjtn000, true);
    2315                 jjtc000 = false;
    2316                jjtn000.setImage("<<="); jjtn000.setCompound();
    2317         break;
    2318       case RSIGNEDSHIFTASSIGN:
    2319         jj_consume_token(RSIGNEDSHIFTASSIGN);
    2320                 jjtree.closeNodeScope(jjtn000, true);
    2321                 jjtc000 = false;
    2322                jjtn000.setImage(">>="); jjtn000.setCompound();
    2323         break;
    2324       case RUNSIGNEDSHIFTASSIGN:
    2325         jj_consume_token(RUNSIGNEDSHIFTASSIGN);
    2326                 jjtree.closeNodeScope(jjtn000, true);
    2327                 jjtc000 = false;
    2328                jjtn000.setImage(">>>="); jjtn000.setCompound();
    2329         break;
    2330       case ANDASSIGN:
    2331         jj_consume_token(ANDASSIGN);
    2332                 jjtree.closeNodeScope(jjtn000, true);
    2333                 jjtc000 = false;
    2334                jjtn000.setImage("&="); jjtn000.setCompound();
    2335         break;
    2336       case XORASSIGN:
    2337         jj_consume_token(XORASSIGN);
    2338                 jjtree.closeNodeScope(jjtn000, true);
    2339                 jjtc000 = false;
    2340                jjtn000.setImage("^="); jjtn000.setCompound();
    2341         break;
    2342       case ORASSIGN:
    2343         jj_consume_token(ORASSIGN);
    2344                 jjtree.closeNodeScope(jjtn000, true);
    2345                 jjtc000 = false;
    2346                jjtn000.setImage("|="); jjtn000.setCompound();
    2347         break;
    2348       default:
    2349         jj_la1[61] = jj_gen;
    2350         jj_consume_token(-1);
    2351         throw new ParseException();
    2352       }
    2353     } finally {
    2354         if (jjtc000) {
    2355           jjtree.closeNodeScope(jjtn000, true);
    2356         }
    2357     }
    2358   }
    2359
    2360   final public void ConditionalExpression() throws ParseException {
    2361  /*@bgen(jjtree) #ConditionalExpression(> 1) */
    2362   ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);
    2363   boolean jjtc000 = true;
    2364   jjtree.openNodeScope(jjtn000);
    2365     try {
    2366       ConditionalOrExpression();
    2367       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2368       case HOOK:
    2369         jj_consume_token(HOOK);
    2370                                    jjtn000.setTernary();
    2371         Expression();
    2372         jj_consume_token(COLON);
    2373         ConditionalExpression();
    2374         break;
    2375       default:
    2376         jj_la1[62] = jj_gen;
    2377         ;
    2378       }
    2379     } catch (Throwable jjte000) {
    2380     if (jjtc000) {
    2381       jjtree.clearNodeScope(jjtn000);
    2382       jjtc000 = false;
    2383     } else {
    2384       jjtree.popNode();
    2385     }
    2386     if (jjte000 instanceof RuntimeException) {
    2387       {if (true) throw (RuntimeException)jjte000;}
    2388     }
    2389     if (jjte000 instanceof ParseException) {
    2390       {if (true) throw (ParseException)jjte000;}
    2391     }
    2392     {if (true) throw (Error)jjte000;}
    2393     } finally {
    2394     if (jjtc000) {
    2395       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2396     }
    2397     }
    2398   }
    2399
    2400   final public void ConditionalOrExpression() throws ParseException {
    2401  /*@bgen(jjtree) #ConditionalOrExpression(> 1) */
    2402   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
    2403   boolean jjtc000 = true;
    2404   jjtree.openNodeScope(jjtn000);
    2405     try {
    2406       ConditionalAndExpression();
    2407       label_24:
    2408       while (true) {
    2409         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2410         case SC_OR:
    2411           ;
    2412           break;
    2413         default:
    2414           jj_la1[63] = jj_gen;
    2415           break label_24;
    2416         }
    2417         jj_consume_token(SC_OR);
    2418         ConditionalAndExpression();
    2419       }
    2420     } catch (Throwable jjte000) {
    2421     if (jjtc000) {
    2422       jjtree.clearNodeScope(jjtn000);
    2423       jjtc000 = false;
    2424     } else {
    2425       jjtree.popNode();
    2426     }
    2427     if (jjte000 instanceof RuntimeException) {
    2428       {if (true) throw (RuntimeException)jjte000;}
    2429     }
    2430     if (jjte000 instanceof ParseException) {
    2431       {if (true) throw (ParseException)jjte000;}
    2432     }
    2433     {if (true) throw (Error)jjte000;}
    2434     } finally {
    2435     if (jjtc000) {
    2436       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2437     }
    2438     }
    2439   }
    2440
    2441   final public void ConditionalAndExpression() throws ParseException {
    2442  /*@bgen(jjtree) #ConditionalAndExpression(> 1) */
    2443   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
    2444   boolean jjtc000 = true;
    2445   jjtree.openNodeScope(jjtn000);
    2446     try {
    2447       InclusiveOrExpression();
    2448       label_25:
    2449       while (true) {
    2450         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2451         case SC_AND:
    2452           ;
    2453           break;
    2454         default:
    2455           jj_la1[64] = jj_gen;
    2456           break label_25;
    2457         }
    2458         jj_consume_token(SC_AND);
    2459         InclusiveOrExpression();
    2460       }
    2461     } catch (Throwable jjte000) {
    2462     if (jjtc000) {
    2463       jjtree.clearNodeScope(jjtn000);
    2464       jjtc000 = false;
    2465     } else {
    2466       jjtree.popNode();
    2467     }
    2468     if (jjte000 instanceof RuntimeException) {
    2469       {if (true) throw (RuntimeException)jjte000;}
    2470     }
    2471     if (jjte000 instanceof ParseException) {
    2472       {if (true) throw (ParseException)jjte000;}
    2473     }
    2474     {if (true) throw (Error)jjte000;}
    2475     } finally {
    2476     if (jjtc000) {
    2477       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2478     }
    2479     }
    2480   }
    2481
    2482   final public void InclusiveOrExpression() throws ParseException {
    2483  /*@bgen(jjtree) #InclusiveOrExpression(> 1) */
    2484   ASTInclusiveOrExpression jjtn000 = new ASTInclusiveOrExpression(this, JJTINCLUSIVEOREXPRESSION);
    2485   boolean jjtc000 = true;
    2486   jjtree.openNodeScope(jjtn000);
    2487     try {
    2488       ExclusiveOrExpression();
    2489       label_26:
    2490       while (true) {
    2491         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2492         case BIT_OR:
    2493           ;
    2494           break;
    2495         default:
    2496           jj_la1[65] = jj_gen;
    2497           break label_26;
    2498         }
    2499         jj_consume_token(BIT_OR);
    2500         ExclusiveOrExpression();
    2501       }
    2502     } catch (Throwable jjte000) {
    2503     if (jjtc000) {
    2504       jjtree.clearNodeScope(jjtn000);
    2505       jjtc000 = false;
    2506     } else {
    2507       jjtree.popNode();
    2508     }
    2509     if (jjte000 instanceof RuntimeException) {
    2510       {if (true) throw (RuntimeException)jjte000;}
    2511     }
    2512     if (jjte000 instanceof ParseException) {
    2513       {if (true) throw (ParseException)jjte000;}
    2514     }
    2515     {if (true) throw (Error)jjte000;}
    2516     } finally {
    2517     if (jjtc000) {
    2518       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2519     }
    2520     }
    2521   }
    2522
    2523   final public void ExclusiveOrExpression() throws ParseException {
    2524  /*@bgen(jjtree) #ExclusiveOrExpression(> 1) */
    2525   ASTExclusiveOrExpression jjtn000 = new ASTExclusiveOrExpression(this, JJTEXCLUSIVEOREXPRESSION);
    2526   boolean jjtc000 = true;
    2527   jjtree.openNodeScope(jjtn000);
    2528     try {
    2529       AndExpression();
    2530       label_27:
    2531       while (true) {
    2532         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2533         case XOR:
    2534           ;
    2535           break;
    2536         default:
    2537           jj_la1[66] = jj_gen;
    2538           break label_27;
    2539         }
    2540         jj_consume_token(XOR);
    2541         AndExpression();
    2542       }
    2543     } catch (Throwable jjte000) {
    2544     if (jjtc000) {
    2545       jjtree.clearNodeScope(jjtn000);
    2546       jjtc000 = false;
    2547     } else {
    2548       jjtree.popNode();
    2549     }
    2550     if (jjte000 instanceof RuntimeException) {
    2551       {if (true) throw (RuntimeException)jjte000;}
    2552     }
    2553     if (jjte000 instanceof ParseException) {
    2554       {if (true) throw (ParseException)jjte000;}
    2555     }
    2556     {if (true) throw (Error)jjte000;}
    2557     } finally {
    2558     if (jjtc000) {
    2559       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2560     }
    2561     }
    2562   }
    2563
    2564   final public void AndExpression() throws ParseException {
    2565  /*@bgen(jjtree) #AndExpression(> 1) */
    2566   ASTAndExpression jjtn000 = new ASTAndExpression(this, JJTANDEXPRESSION);
    2567   boolean jjtc000 = true;
    2568   jjtree.openNodeScope(jjtn000);
    2569     try {
    2570       EqualityExpression();
    2571       label_28:
    2572       while (true) {
    2573         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2574         case BIT_AND:
    2575           ;
    2576           break;
    2577         default:
    2578           jj_la1[67] = jj_gen;
    2579           break label_28;
    2580         }
    2581         jj_consume_token(BIT_AND);
    2582         EqualityExpression();
    2583       }
    2584     } catch (Throwable jjte000) {
    2585     if (jjtc000) {
    2586       jjtree.clearNodeScope(jjtn000);
    2587       jjtc000 = false;
    2588     } else {
    2589       jjtree.popNode();
    2590     }
    2591     if (jjte000 instanceof RuntimeException) {
    2592       {if (true) throw (RuntimeException)jjte000;}
    2593     }
    2594     if (jjte000 instanceof ParseException) {
    2595       {if (true) throw (ParseException)jjte000;}
    2596     }
    2597     {if (true) throw (Error)jjte000;}
    2598     } finally {
    2599     if (jjtc000) {
    2600       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2601     }
    2602     }
    2603   }
    2604
    2605   final public void EqualityExpression() throws ParseException {
    2606  /*@bgen(jjtree) #EqualityExpression(> 1) */
    2607   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
    2608   boolean jjtc000 = true;
    2609   jjtree.openNodeScope(jjtn000);
    2610     try {
    2611       InstanceOfExpression();
    2612       label_29:
    2613       while (true) {
    2614         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2615         case EQ:
    2616         case NE:
    2617           ;
    2618           break;
    2619         default:
    2620           jj_la1[68] = jj_gen;
    2621           break label_29;
    2622         }
    2623         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2624         case EQ:
    2625           jj_consume_token(EQ);
    2626                                     jjtn000.setImage("==");
    2627           break;
    2628         case NE:
    2629           jj_consume_token(NE);
    2630                                                                      jjtn000.setImage("!=");
    2631           break;
    2632         default:
    2633           jj_la1[69] = jj_gen;
    2634           jj_consume_token(-1);
    2635           throw new ParseException();
    2636         }
    2637         InstanceOfExpression();
    2638       }
    2639     } catch (Throwable jjte000) {
    2640     if (jjtc000) {
    2641       jjtree.clearNodeScope(jjtn000);
    2642       jjtc000 = false;
    2643     } else {
    2644       jjtree.popNode();
    2645     }
    2646     if (jjte000 instanceof RuntimeException) {
    2647       {if (true) throw (RuntimeException)jjte000;}
    2648     }
    2649     if (jjte000 instanceof ParseException) {
    2650       {if (true) throw (ParseException)jjte000;}
    2651     }
    2652     {if (true) throw (Error)jjte000;}
    2653     } finally {
    2654     if (jjtc000) {
    2655       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2656     }
    2657     }
    2658   }
    2659
    2660   final public void InstanceOfExpression() throws ParseException {
    2661  /*@bgen(jjtree) #InstanceOfExpression(> 1) */
    2662   ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);
    2663   boolean jjtc000 = true;
    2664   jjtree.openNodeScope(jjtn000);
    2665     try {
    2666       RelationalExpression();
    2667       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2668       case INSTANCEOF:
    2669         jj_consume_token(INSTANCEOF);
    2670         Type();
    2671         break;
    2672       default:
    2673         jj_la1[70] = jj_gen;
    2674         ;
    2675       }
    2676     } catch (Throwable jjte000) {
    2677     if (jjtc000) {
    2678       jjtree.clearNodeScope(jjtn000);
    2679       jjtc000 = false;
    2680     } else {
    2681       jjtree.popNode();
    2682     }
    2683     if (jjte000 instanceof RuntimeException) {
    2684       {if (true) throw (RuntimeException)jjte000;}
    2685     }
    2686     if (jjte000 instanceof ParseException) {
    2687       {if (true) throw (ParseException)jjte000;}
    2688     }
    2689     {if (true) throw (Error)jjte000;}
    2690     } finally {
    2691     if (jjtc000) {
    2692       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2693     }
    2694     }
    2695   }
    2696
    2697   final public void RelationalExpression() throws ParseException {
    2698  /*@bgen(jjtree) #RelationalExpression(> 1) */
    2699   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
    2700   boolean jjtc000 = true;
    2701   jjtree.openNodeScope(jjtn000);
    2702     try {
    2703       ShiftExpression();
    2704       label_30:
    2705       while (true) {
    2706         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2707         case LT:
    2708         case LE:
    2709         case GE:
    2710         case GT:
    2711           ;
    2712           break;
    2713         default:
    2714           jj_la1[71] = jj_gen;
    2715           break label_30;
    2716         }
    2717         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2718         case LT:
    2719           jj_consume_token(LT);
    2720            jjtn000.setImage("<");
    2721           break;
    2722         case GT:
    2723           jj_consume_token(GT);
    2724             jjtn000.setImage(">");
    2725           break;
    2726         case LE:
    2727           jj_consume_token(LE);
    2728              jjtn000.setImage("<=");
    2729           break;
    2730         case GE:
    2731           jj_consume_token(GE);
    2732              jjtn000.setImage(">=");
    2733           break;
    2734         default:
    2735           jj_la1[72] = jj_gen;
    2736           jj_consume_token(-1);
    2737           throw new ParseException();
    2738         }
    2739         ShiftExpression();
    2740       }
    2741     } catch (Throwable jjte000) {
    2742     if (jjtc000) {
    2743       jjtree.clearNodeScope(jjtn000);
    2744       jjtc000 = false;
    2745     } else {
    2746       jjtree.popNode();
    2747     }
    2748     if (jjte000 instanceof RuntimeException) {
    2749       {if (true) throw (RuntimeException)jjte000;}
    2750     }
    2751     if (jjte000 instanceof ParseException) {
    2752       {if (true) throw (ParseException)jjte000;}
    2753     }
    2754     {if (true) throw (Error)jjte000;}
    2755     } finally {
    2756     if (jjtc000) {
    2757       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2758     }
    2759     }
    2760   }
    2761
    2762   final public void ShiftExpression() throws ParseException {
    2763  /*@bgen(jjtree) #ShiftExpression(> 1) */
    2764   ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);
    2765   boolean jjtc000 = true;
    2766   jjtree.openNodeScope(jjtn000);
    2767     try {
    2768       AdditiveExpression();
    2769       label_31:
    2770       while (true) {
    2771         if (jj_2_20(1)) {
    2772           ;
    2773         } else {
    2774           break label_31;
    2775         }
    2776         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2777         case LSHIFT:
    2778           jj_consume_token(LSHIFT);
    2779              jjtn000.setImage("<<");
    2780           break;
    2781         default:
    2782           jj_la1[73] = jj_gen;
    2783           if (jj_2_21(1)) {
    2784             RSIGNEDSHIFT();
    2785           } else if (jj_2_22(1)) {
    2786             RUNSIGNEDSHIFT();
    2787           } else {
    2788             jj_consume_token(-1);
    2789             throw new ParseException();
    2790           }
    2791         }
    2792         AdditiveExpression();
    2793       }
    2794     } catch (Throwable jjte000) {
    2795     if (jjtc000) {
    2796       jjtree.clearNodeScope(jjtn000);
    2797       jjtc000 = false;
    2798     } else {
    2799       jjtree.popNode();
    2800     }
    2801     if (jjte000 instanceof RuntimeException) {
    2802       {if (true) throw (RuntimeException)jjte000;}
    2803     }
    2804     if (jjte000 instanceof ParseException) {
    2805       {if (true) throw (ParseException)jjte000;}
    2806     }
    2807     {if (true) throw (Error)jjte000;}
    2808     } finally {
    2809     if (jjtc000) {
    2810       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2811     }
    2812     }
    2813   }
    2814
    2815   final public void AdditiveExpression() throws ParseException {
    2816  /*@bgen(jjtree) #AdditiveExpression(> 1) */
    2817   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
    2818   boolean jjtc000 = true;
    2819   jjtree.openNodeScope(jjtn000);
    2820     try {
    2821       MultiplicativeExpression();
    2822       label_32:
    2823       while (true) {
    2824         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2825         case PLUS:
    2826         case MINUS:
    2827           ;
    2828           break;
    2829         default:
    2830           jj_la1[74] = jj_gen;
    2831           break label_32;
    2832         }
    2833         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2834         case PLUS:
    2835           jj_consume_token(PLUS);
    2836                                       jjtn000.setImage("+");
    2837           break;
    2838         case MINUS:
    2839           jj_consume_token(MINUS);
    2840                                                                      jjtn000.setImage("-");
    2841           break;
    2842         default:
    2843           jj_la1[75] = jj_gen;
    2844           jj_consume_token(-1);
    2845           throw new ParseException();
    2846         }
    2847         MultiplicativeExpression();
    2848       }
    2849     } catch (Throwable jjte000) {
    2850     if (jjtc000) {
    2851       jjtree.clearNodeScope(jjtn000);
    2852       jjtc000 = false;
    2853     } else {
    2854       jjtree.popNode();
    2855     }
    2856     if (jjte000 instanceof RuntimeException) {
    2857       {if (true) throw (RuntimeException)jjte000;}
    2858     }
    2859     if (jjte000 instanceof ParseException) {
    2860       {if (true) throw (ParseException)jjte000;}
    2861     }
    2862     {if (true) throw (Error)jjte000;}
    2863     } finally {
    2864     if (jjtc000) {
    2865       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2866     }
    2867     }
    2868   }
    2869
    2870   final public void MultiplicativeExpression() throws ParseException {
    2871  /*@bgen(jjtree) #MultiplicativeExpression(> 1) */
    2872   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
    2873   boolean jjtc000 = true;
    2874   jjtree.openNodeScope(jjtn000);
    2875     try {
    2876       UnaryExpression();
    2877       label_33:
    2878       while (true) {
    2879         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2880         case STAR:
    2881         case SLASH:
    2882         case REM:
    2883           ;
    2884           break;
    2885         default:
    2886           jj_la1[76] = jj_gen;
    2887           break label_33;
    2888         }
    2889         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2890         case STAR:
    2891           jj_consume_token(STAR);
    2892                              jjtn000.setImage("*");
    2893           break;
    2894         case SLASH:
    2895           jj_consume_token(SLASH);
    2896                                                             jjtn000.setImage("/");
    2897           break;
    2898         case REM:
    2899           jj_consume_token(REM);
    2900                                                                                            jjtn000.setImage("%");
    2901           break;
    2902         default:
    2903           jj_la1[77] = jj_gen;
    2904           jj_consume_token(-1);
    2905           throw new ParseException();
    2906         }
    2907         UnaryExpression();
    2908       }
    2909     } catch (Throwable jjte000) {
    2910     if (jjtc000) {
    2911       jjtree.clearNodeScope(jjtn000);
    2912       jjtc000 = false;
    2913     } else {
    2914       jjtree.popNode();
    2915     }
    2916     if (jjte000 instanceof RuntimeException) {
    2917       {if (true) throw (RuntimeException)jjte000;}
    2918     }
    2919     if (jjte000 instanceof ParseException) {
    2920       {if (true) throw (ParseException)jjte000;}
    2921     }
    2922     {if (true) throw (Error)jjte000;}
    2923     } finally {
    2924     if (jjtc000) {
    2925       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    2926     }
    2927     }
    2928   }
    2929
    2930   final public void UnaryExpression() throws ParseException {
    2931  /*@bgen(jjtree) #UnaryExpression( ( jjtn000 . getImage ( ) != null )) */
    2932   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
    2933   boolean jjtc000 = true;
    2934   jjtree.openNodeScope(jjtn000);
    2935     try {
    2936       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2937       case PLUS:
    2938       case MINUS:
    2939         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2940         case PLUS:
    2941           jj_consume_token(PLUS);
    2942         jjtn000.setImage("+");
    2943           break;
    2944         case MINUS:
    2945           jj_consume_token(MINUS);
    2946                                        jjtn000.setImage("-");
    2947           break;
    2948         default:
    2949           jj_la1[78] = jj_gen;
    2950           jj_consume_token(-1);
    2951           throw new ParseException();
    2952         }
    2953         UnaryExpression();
    2954         break;
    2955       case INCR:
    2956         PreIncrementExpression();
    2957         break;
    2958       case DECR:
    2959         PreDecrementExpression();
    2960         break;
    2961       case BOOLEAN:
    2962       case BYTE:
    2963       case CHAR:
    2964       case DOUBLE:
    2965       case FALSE:
    2966       case FLOAT:
    2967       case INT:
    2968       case LONG:
    2969       case NEW:
    2970       case NULL:
    2971       case SHORT:
    2972       case SUPER:
    2973       case THIS:
    2974       case TRUE:
    2975       case VOID:
    2976       case INTEGER_LITERAL:
    2977       case FLOATING_POINT_LITERAL:
    2978       case CHARACTER_LITERAL:
    2979       case STRING_LITERAL:
    2980       case IDENTIFIER:
    2981       case LPAREN:
    2982       case BANG:
    2983       case TILDE:
    2984         UnaryExpressionNotPlusMinus();
    2985         break;
    2986       default:
    2987         jj_la1[79] = jj_gen;
    2988         jj_consume_token(-1);
    2989         throw new ParseException();
    2990       }
    2991     } catch (Throwable jjte000) {
    2992     if (jjtc000) {
    2993       jjtree.clearNodeScope(jjtn000);
    2994       jjtc000 = false;
    2995     } else {
    2996       jjtree.popNode();
    2997     }
    2998     if (jjte000 instanceof RuntimeException) {
    2999       {if (true) throw (RuntimeException)jjte000;}
    3000     }
    3001     if (jjte000 instanceof ParseException) {
    3002       {if (true) throw (ParseException)jjte000;}
    3003     }
    3004     {if (true) throw (Error)jjte000;}
    3005     } finally {
    3006     if (jjtc000) {
    3007       jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    3008     }
    3009     }
    3010   }
    3011
    3012   final public void PreIncrementExpression() throws ParseException {
    3013  /*@bgen(jjtree) PreIncrementExpression */
    3014   ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION);
    3015   boolean jjtc000 = true;
    3016   jjtree.openNodeScope(jjtn000);
    3017     try {
    3018       jj_consume_token(INCR);
    3019       PrimaryExpression();
    3020     } catch (Throwable jjte000) {
    3021     if (jjtc000) {
    3022       jjtree.clearNodeScope(jjtn000);
    3023       jjtc000 = false;
    3024     } else {
    3025       jjtree.popNode();
    3026     }
    3027     if (jjte000 instanceof RuntimeException) {
    3028       {if (true) throw (RuntimeException)jjte000;}
    3029     }
    3030     if (jjte000 instanceof ParseException) {
    3031       {if (true) throw (ParseException)jjte000;}
    3032     }
    3033     {if (true) throw (Error)jjte000;}
    3034     } finally {
    3035     if (jjtc000) {
    3036       jjtree.closeNodeScope(jjtn000, true);
    3037     }
    3038     }
    3039   }
    3040
    3041   final public void PreDecrementExpression() throws ParseException {
    3042  /*@bgen(jjtree) PreDecrementExpression */
    3043   ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION);
    3044   boolean jjtc000 = true;
    3045   jjtree.openNodeScope(jjtn000);
    3046     try {
    3047       jj_consume_token(DECR);
    3048       PrimaryExpression();
    3049     } catch (Throwable jjte000) {
    3050     if (jjtc000) {
    3051       jjtree.clearNodeScope(jjtn000);
    3052       jjtc000 = false;
    3053     } else {
    3054       jjtree.popNode();
    3055     }
    3056     if (jjte000 instanceof RuntimeException) {
    3057       {if (true) throw (RuntimeException)jjte000;}
    3058     }
    3059     if (jjte000 instanceof ParseException) {
    3060       {if (true) throw (ParseException)jjte000;}
    3061     }
    3062     {if (true) throw (Error)jjte000;}
    3063     } finally {
    3064     if (jjtc000) {
    3065       jjtree.closeNodeScope(jjtn000, true);
    3066     }
    3067     }
    3068   }
    3069
    3070   final public void UnaryExpressionNotPlusMinus() throws ParseException {
    3071  /*@bgen(jjtree) #UnaryExpressionNotPlusMinus( ( jjtn000 . getImage ( ) != null )) */
    3072   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
    3073   boolean jjtc000 = true;
    3074   jjtree.openNodeScope(jjtn000);
    3075     try {
    3076       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3077       case BANG:
    3078       case TILDE:
    3079         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3080         case TILDE:
    3081           jj_consume_token(TILDE);
    3082         jjtn000.setImage("~");
    3083           break;
    3084         case BANG:
    3085           jj_consume_token(BANG);
    3086                                        jjtn000.setImage("!");
    3087           break;
    3088         default:
    3089           jj_la1[80] = jj_gen;
    3090           jj_consume_token(-1);
    3091           throw new ParseException();
    3092         }
    3093         UnaryExpression();
    3094         break;
    3095       default:
    3096         jj_la1[81] = jj_gen;
    3097         if (jj_2_23(2147483647)) {
    3098           CastExpression();
    3099         } else {
    3100           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3101           case BOOLEAN:
    3102           case BYTE:
    3103           case CHAR:
    3104           case DOUBLE:
    3105           case FALSE:
    3106           case FLOAT:
    3107           case INT:
    3108           case LONG:
    3109           case NEW:
    3110           case NULL:
    3111           case SHORT:
    3112           case SUPER:
    3113           case THIS:
    3114           case TRUE:
    3115           case VOID:
    3116           case INTEGER_LITERAL:
    3117           case FLOATING_POINT_LITERAL:
    3118           case CHARACTER_LITERAL:
    3119           case STRING_LITERAL:
    3120           case IDENTIFIER:
    3121           case LPAREN:
    3122             PostfixExpression();
    3123             break;
    3124           default:
    3125             jj_la1[82] = jj_gen;
    3126             jj_consume_token(-1);
    3127             throw new ParseException();
    3128           }
    3129         }
    3130       }
    3131     } catch (Throwable jjte000) {
    3132    if (jjtc000) {
    3133      jjtree.clearNodeScope(jjtn000);
    3134      jjtc000 = false;
    3135    } else {
    3136      jjtree.popNode();
    3137    }
    3138    if (jjte000 instanceof RuntimeException) {
    3139      {if (true) throw (RuntimeException)jjte000;}
    3140    }
    3141    if (jjte000 instanceof ParseException) {
    3142      {if (true) throw (ParseException)jjte000;}
    3143    }
    3144    {if (true) throw (Error)jjte000;}
    3145     } finally {
    3146    if (jjtc000) {
    3147      jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    3148    }
    3149     }
    3150   }
    3151
    3152 // This production is to determine lookahead only.  The LOOKAHEAD specifications
    3153 // below are not used, but they are there just to indicate that we know about
    3154 // this.
    3155   final public void CastLookahead() throws ParseException {
    3156  /*@bgen(jjtree) CastLookahead */
    3157   ASTCastLookahead jjtn000 = new ASTCastLookahead(this, JJTCASTLOOKAHEAD);
    3158   boolean jjtc000 = true;
    3159   jjtree.openNodeScope(jjtn000);
    3160     try {
    3161       if (jj_2_24(2)) {
    3162         jj_consume_token(LPAREN);
    3163         PrimitiveType();
    3164       } else if (jj_2_25(2147483647)) {
    3165         jj_consume_token(LPAREN);
    3166         Type();
    3167         jj_consume_token(LBRACKET);
    3168         jj_consume_token(RBRACKET);
    3169       } else {
    3170         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3171         case LPAREN:
    3172           jj_consume_token(LPAREN);
    3173           Type();
    3174           jj_consume_token(RPAREN);
    3175           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3176           case TILDE:
    3177             jj_consume_token(TILDE);
    3178             break;
    3179           case BANG:
    3180             jj_consume_token(BANG);
    3181             break;
    3182           case LPAREN:
    3183             jj_consume_token(LPAREN);
    3184             break;
    3185           case IDENTIFIER:
    3186             jj_consume_token(IDENTIFIER);
    3187             break;
    3188           case THIS:
    3189             jj_consume_token(THIS);
    3190             break;
    3191           case SUPER:
    3192             jj_consume_token(SUPER);
    3193             break;
    3194           case NEW:
    3195             jj_consume_token(NEW);
    3196             break;
    3197           case FALSE:
    3198           case NULL:
    3199           case TRUE:
    3200           case INTEGER_LITERAL:
    3201           case FLOATING_POINT_LITERAL:
    3202           case CHARACTER_LITERAL:
    3203           case STRING_LITERAL:
    3204             Literal();
    3205             break;
    3206           default:
    3207             jj_la1[83] = jj_gen;
    3208             jj_consume_token(-1);
    3209             throw new ParseException();
    3210           }
    3211           break;
    3212         default:
    3213           jj_la1[84] = jj_gen;
    3214           jj_consume_token(-1);
    3215           throw new ParseException();
    3216         }
    3217       }
    3218     } catch (Throwable jjte000) {
    3219     if (jjtc000) {
    3220       jjtree.clearNodeScope(jjtn000);
    3221       jjtc000 = false;
    3222     } else {
    3223       jjtree.popNode();
    3224     }
    3225     if (jjte000 instanceof RuntimeException) {
    3226       {if (true) throw (RuntimeException)jjte000;}
    3227     }
    3228     if (jjte000 instanceof ParseException) {
    3229       {if (true) throw (ParseException)jjte000;}
    3230     }
    3231     {if (true) throw (Error)jjte000;}
    3232     } finally {
    3233     if (jjtc000) {
    3234       jjtree.closeNodeScope(jjtn000, true);
    3235     }
    3236     }
    3237   }
    3238
    3239   final public void PostfixExpression() throws ParseException {
    3240  /*@bgen(jjtree) #PostfixExpression( ( jjtn000 . getImage ( ) != null )) */
    3241   ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);
    3242   boolean jjtc000 = true;
    3243   jjtree.openNodeScope(jjtn000);
    3244     try {
    3245       PrimaryExpression();
    3246       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3247       case INCR:
    3248       case DECR:
    3249         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3250         case INCR:
    3251           jj_consume_token(INCR);
    3252                               jjtn000.setImage("++");
    3253           break;
    3254         case DECR:
    3255           jj_consume_token(DECR);
    3256                                                                jjtn000.setImage("--");
    3257           break;
    3258         default:
    3259           jj_la1[85] = jj_gen;
    3260           jj_consume_token(-1);
    3261           throw new ParseException();
    3262         }
    3263         break;
    3264       default:
    3265         jj_la1[86] = jj_gen;
    3266         ;
    3267       }
    3268     } catch (Throwable jjte000) {
    3269     if (jjtc000) {
    3270       jjtree.clearNodeScope(jjtn000);
    3271       jjtc000 = false;
    3272     } else {
    3273       jjtree.popNode();
    3274     }
    3275     if (jjte000 instanceof RuntimeException) {
    3276       {if (true) throw (RuntimeException)jjte000;}
    3277     }
    3278     if (jjte000 instanceof ParseException) {
    3279       {if (true) throw (ParseException)jjte000;}
    3280     }
    3281     {if (true) throw (Error)jjte000;}
    3282     } finally {
    3283     if (jjtc000) {
    3284       jjtree.closeNodeScope(jjtn000,  ( jjtn000 . getImage ( ) != null ));
    3285     }
    3286     }
    3287   }
    3288
    3289   final public void CastExpression() throws ParseException {
    3290  /*@bgen(jjtree) #CastExpression(> 1) */
    3291   ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION);
    3292   boolean jjtc000 = true;
    3293   jjtree.openNodeScope(jjtn000);
    3294     try {
    3295       if (jj_2_26(2147483647)) {
    3296         jj_consume_token(LPAREN);
    3297         Type();
    3298         jj_consume_token(RPAREN);
    3299         UnaryExpression();
    3300       } else {
    3301         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3302         case LPAREN:
    3303           jj_consume_token(LPAREN);
    3304           Type();
    3305           jj_consume_token(RPAREN);
    3306           UnaryExpressionNotPlusMinus();
    3307           break;
    3308         default:
    3309           jj_la1[87] = jj_gen;
    3310           jj_consume_token(-1);
    3311           throw new ParseException();
    3312         }
    3313       }
    3314     } catch (Throwable jjte000) {
    3315     if (jjtc000) {
    3316       jjtree.clearNodeScope(jjtn000);
    3317       jjtc000 = false;
    3318     } else {
    3319       jjtree.popNode();
    3320     }
    3321     if (jjte000 instanceof RuntimeException) {
    3322       {if (true) throw (RuntimeException)jjte000;}
    3323     }
    3324     if (jjte000 instanceof ParseException) {
    3325       {if (true) throw (ParseException)jjte000;}
    3326     }
    3327     {if (true) throw (Error)jjte000;}
    3328     } finally {
    3329     if (jjtc000) {
    3330       jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    3331     }
    3332     }
    3333   }
    3334
    3335   final public void PrimaryExpression() throws ParseException {
    3336  /*@bgen(jjtree) PrimaryExpression */
    3337   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
    3338   boolean jjtc000 = true;
    3339   jjtree.openNodeScope(jjtn000);
    3340     try {
    3341       PrimaryPrefix();
    3342       label_34:
    3343       while (true) {
    3344         if (jj_2_27(2)) {
    3345           ;
    3346         } else {
    3347           break label_34;
    3348         }
    3349         PrimarySuffix();
    3350       }
    3351     } catch (Throwable jjte000) {
    3352     if (jjtc000) {
    3353       jjtree.clearNodeScope(jjtn000);
    3354       jjtc000 = false;
    3355     } else {
    3356       jjtree.popNode();
    3357     }
    3358     if (jjte000 instanceof RuntimeException) {
    3359       {if (true) throw (RuntimeException)jjte000;}
    3360     }
    3361     if (jjte000 instanceof ParseException) {
    3362       {if (true) throw (ParseException)jjte000;}
    3363     }
    3364     {if (true) throw (Error)jjte000;}
    3365     } finally {
    3366     if (jjtc000) {
    3367       jjtree.closeNodeScope(jjtn000, true);
    3368     }
    3369     }
    3370   }
    3371
    3372   final public void MemberSelector() throws ParseException {
    3373  /*@bgen(jjtree) MemberSelector */
    3374 ASTMemberSelector jjtn000 = new ASTMemberSelector(this, JJTMEMBERSELECTOR);
    3375 boolean jjtc000 = true;
    3376 jjtree.openNodeScope(jjtn000);Token t;
    3377     try {
    3378       jj_consume_token(DOT);
    3379       TypeArguments();
    3380       t = jj_consume_token(IDENTIFIER);
    3381                                        jjtree.closeNodeScope(jjtn000, true);
    3382                                        jjtc000 = false;
    3383                                       jjtn000.setImage(t.image);
    3384     } catch (Throwable jjte000) {
    3385     if (jjtc000) {
    3386       jjtree.clearNodeScope(jjtn000);
    3387       jjtc000 = false;
    3388     } else {
    3389       jjtree.popNode();
    3390     }
    3391     if (jjte000 instanceof RuntimeException) {
    3392       {if (true) throw (RuntimeException)jjte000;}
    3393     }
    3394     if (jjte000 instanceof ParseException) {
    3395       {if (true) throw (ParseException)jjte000;}
    3396     }
    3397     {if (true) throw (Error)jjte000;}
    3398     } finally {
    3399     if (jjtc000) {
    3400       jjtree.closeNodeScope(jjtn000, true);
    3401     }
    3402     }
    3403   }
    3404
    3405   final public void PrimaryPrefix() throws ParseException {
    3406  /*@bgen(jjtree) PrimaryPrefix */
    3407  ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
    3408  boolean jjtc000 = true;
    3409  jjtree.openNodeScope(jjtn000);Token t;
    3410     try {
    3411       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3412       case FALSE:
    3413       case NULL:
    3414       case TRUE:
    3415       case INTEGER_LITERAL:
    3416       case FLOATING_POINT_LITERAL:
    3417       case CHARACTER_LITERAL:
    3418       case STRING_LITERAL:
    3419         Literal();
    3420         break;
    3421       case THIS:
    3422         jj_consume_token(THIS);
    3423            jjtree.closeNodeScope(jjtn000, true);
    3424            jjtc000 = false;
    3425           jjtn000.setUsesThisModifier();
    3426         break;
    3427       case SUPER:
    3428         jj_consume_token(SUPER);
    3429            jjtn000.setUsesSuperModifier();
    3430         jj_consume_token(DOT);
    3431         t = jj_consume_token(IDENTIFIER);
    3432                                                                  jjtree.closeNodeScope(jjtn000, true);
    3433                                                                  jjtc000 = false;
    3434                                                                 jjtn000.setImage(t.image);
    3435         break;
    3436       case LPAREN:
    3437         jj_consume_token(LPAREN);
    3438         Expression();
    3439         jj_consume_token(RPAREN);
    3440         break;
    3441       case NEW:
    3442         AllocationExpression();
    3443         break;
    3444       default:
    3445         jj_la1[88] = jj_gen;
    3446         if (jj_2_28(2147483647)) {
    3447           ResultType();
    3448           jj_consume_token(DOT);
    3449           jj_consume_token(CLASS);
    3450         } else {
    3451           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3452           case IDENTIFIER:
    3453             Name();
    3454             break;
    3455           default:
    3456             jj_la1[89] = jj_gen;
    3457             jj_consume_token(-1);
    3458             throw new ParseException();
    3459           }
    3460         }
    3461       }
    3462     } catch (Throwable jjte000) {
    3463     if (jjtc000) {
    3464       jjtree.clearNodeScope(jjtn000);
    3465       jjtc000 = false;
    3466     } else {
    3467       jjtree.popNode();
    3468     }
    3469     if (jjte000 instanceof RuntimeException) {
    3470       {if (true) throw (RuntimeException)jjte000;}
    3471     }
    3472     if (jjte000 instanceof ParseException) {
    3473       {if (true) throw (ParseException)jjte000;}
    3474     }
    3475     {if (true) throw (Error)jjte000;}
    3476     } finally {
    3477     if (jjtc000) {
    3478       jjtree.closeNodeScope(jjtn000, true);
    3479     }
    3480     }
    3481   }
    3482
    3483   final public void PrimarySuffix() throws ParseException {
    3484  /*@bgen(jjtree) PrimarySuffix */
    3485  ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
    3486  boolean jjtc000 = true;
    3487  jjtree.openNodeScope(jjtn000);Token t;
    3488     try {
    3489       if (jj_2_29(2)) {
    3490         jj_consume_token(DOT);
    3491         jj_consume_token(THIS);
    3492       } else if (jj_2_30(2)) {
    3493         jj_consume_token(DOT);
    3494         jj_consume_token(SUPER);
    3495       } else if (jj_2_31(2)) {
    3496         jj_consume_token(DOT);
    3497         AllocationExpression();
    3498       } else if (jj_2_32(3)) {
    3499         MemberSelector();
    3500       } else {
    3501         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3502         case LBRACKET:
    3503           jj_consume_token(LBRACKET);
    3504           Expression();
    3505           jj_consume_token(RBRACKET);
    3506                          jjtree.closeNodeScope(jjtn000, true);
    3507                          jjtc000 = false;
    3508                         jjtn000.setIsArrayDereference();
    3509           break;
    3510         case DOT:
    3511           jj_consume_token(DOT);
    3512           t = jj_consume_token(IDENTIFIER);
    3513                        jjtree.closeNodeScope(jjtn000, true);
    3514                        jjtc000 = false;
    3515                       jjtn000.setImage(t.image);
    3516           break;
    3517         case LPAREN:
    3518           Arguments();
    3519                 jjtree.closeNodeScope(jjtn000, true);
    3520                 jjtc000 = false;
    3521                jjtn000.setIsArguments();
    3522           break;
    3523         default:
    3524           jj_la1[90] = jj_gen;
    3525           jj_consume_token(-1);
    3526           throw new ParseException();
    3527         }
    3528       }
    3529     } catch (Throwable jjte000) {
    3530     if (jjtc000) {
    3531       jjtree.clearNodeScope(jjtn000);
    3532       jjtc000 = false;
    3533     } else {
    3534       jjtree.popNode();
    3535     }
    3536     if (jjte000 instanceof RuntimeException) {
    3537       {if (true) throw (RuntimeException)jjte000;}
    3538     }
    3539     if (jjte000 instanceof ParseException) {
    3540       {if (true) throw (ParseException)jjte000;}
    3541     }
    3542     {if (true) throw (Error)jjte000;}
    3543     } finally {
    3544     if (jjtc000) {
    3545       jjtree.closeNodeScope(jjtn000, true);
    3546     }
    3547     }
    3548   }
    3549
    3550   final public void Literal() throws ParseException {
    3551  /*@bgen(jjtree) Literal */
    3552   ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
    3553   boolean jjtc000 = true;
    3554   jjtree.openNodeScope(jjtn000);
    3555     try {
    3556       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3557       case INTEGER_LITERAL:
    3558   Token t;
    3559         t = jj_consume_token(INTEGER_LITERAL);
    3560                         jjtree.closeNodeScope(jjtn000, true);
    3561                         jjtc000 = false;
    3562                        jjtn000.setImage(t.image);
    3563         break;
    3564       case FLOATING_POINT_LITERAL:
    3565         t = jj_consume_token(FLOATING_POINT_LITERAL);
    3566                                jjtree.closeNodeScope(jjtn000, true);
    3567                                jjtc000 = false;
    3568                               jjtn000.setImage(t.image);
    3569         break;
    3570       case CHARACTER_LITERAL:
    3571         t = jj_consume_token(CHARACTER_LITERAL);
    3572                           jjtree.closeNodeScope(jjtn000, true);
    3573                           jjtc000 = false;
    3574                          jjtn000.setImage(t.image);
    3575         break;
    3576       case STRING_LITERAL:
    3577         t = jj_consume_token(STRING_LITERAL);
    3578                        jjtree.closeNodeScope(jjtn000, true);
    3579                        jjtc000 = false;
    3580                       jjtn000.setImage(t.image);
    3581         break;
    3582       case FALSE:
    3583       case TRUE:
    3584         BooleanLiteral();
    3585         break;
    3586       case NULL:
    3587         NullLiteral();
    3588         break;
    3589       default:
    3590         jj_la1[91] = jj_gen;
    3591         jj_consume_token(-1);
    3592         throw new ParseException();
    3593       }
    3594     } catch (Throwable jjte000) {
    3595   if (jjtc000) {
    3596     jjtree.clearNodeScope(jjtn000);
    3597     jjtc000 = false;
    3598   } else {
    3599     jjtree.popNode();
    3600   }
    3601   if (jjte000 instanceof RuntimeException) {
    3602     {if (true) throw (RuntimeException)jjte000;}
    3603   }
    3604   if (jjte000 instanceof ParseException) {
    3605     {if (true) throw (ParseException)jjte000;}
    3606   }
    3607   {if (true) throw (Error)jjte000;}
    3608     } finally {
    3609   if (jjtc000) {
    3610     jjtree.closeNodeScope(jjtn000, true);
    3611   }
    3612     }
    3613   }
    3614
    3615   final public void BooleanLiteral() throws ParseException {
    3616  /*@bgen(jjtree) BooleanLiteral */
    3617   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
    3618   boolean jjtc000 = true;
    3619   jjtree.openNodeScope(jjtn000);
    3620     try {
    3621       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3622       case TRUE:
    3623         jj_consume_token(TRUE);
    3624            jjtree.closeNodeScope(jjtn000, true);
    3625            jjtc000 = false;
    3626            jjtn000.setTrue();
    3627         break;
    3628       case FALSE:
    3629         jj_consume_token(FALSE);
    3630         break;
    3631       default:
    3632         jj_la1[92] = jj_gen;
    3633         jj_consume_token(-1);
    3634         throw new ParseException();
    3635       }
    3636     } finally {
    3637     if (jjtc000) {
    3638       jjtree.closeNodeScope(jjtn000, true);
    3639     }
    3640     }
    3641   }
    3642
    3643   final public void NullLiteral() throws ParseException {
    3644  /*@bgen(jjtree) NullLiteral */
    3645   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
    3646   boolean jjtc000 = true;
    3647   jjtree.openNodeScope(jjtn000);
    3648     try {
    3649       jj_consume_token(NULL);
    3650     } finally {
    3651     if (jjtc000) {
    3652       jjtree.closeNodeScope(jjtn000, true);
    3653     }
    3654     }
    3655   }
    3656
    3657   final public void Arguments() throws ParseException {
    3658  /*@bgen(jjtree) Arguments */
    3659   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
    3660   boolean jjtc000 = true;
    3661   jjtree.openNodeScope(jjtn000);
    3662     try {
    3663       jj_consume_token(LPAREN);
    3664       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3665       case BOOLEAN:
    3666       case BYTE:
    3667       case CHAR:
    3668       case DOUBLE:
    3669       case FALSE:
    3670       case FLOAT:
    3671       case INT:
    3672       case LONG:
    3673       case NEW:
    3674       case NULL:
    3675       case SHORT:
    3676       case SUPER:
    3677       case THIS:
    3678       case TRUE:
    3679       case VOID:
    3680       case INTEGER_LITERAL:
    3681       case FLOATING_POINT_LITERAL:
    3682       case CHARACTER_LITERAL:
    3683       case STRING_LITERAL:
    3684       case IDENTIFIER:
    3685       case LPAREN:
    3686       case BANG:
    3687       case TILDE:
    3688       case INCR:
    3689       case DECR:
    3690       case PLUS:
    3691       case MINUS:
    3692         ArgumentList();
    3693         break;
    3694       default:
    3695         jj_la1[93] = jj_gen;
    3696         ;
    3697       }
    3698       jj_consume_token(RPAREN);
    3699     } catch (Throwable jjte000) {
    3700     if (jjtc000) {
    3701       jjtree.clearNodeScope(jjtn000);
    3702       jjtc000 = false;
    3703     } else {
    3704       jjtree.popNode();
    3705     }
    3706     if (jjte000 instanceof RuntimeException) {
    3707       {if (true) throw (RuntimeException)jjte000;}
    3708     }
    3709     if (jjte000 instanceof ParseException) {
    3710       {if (true) throw (ParseException)jjte000;}
    3711     }
    3712     {if (true) throw (Error)jjte000;}
    3713     } finally {
    3714     if (jjtc000) {
    3715       jjtree.closeNodeScope(jjtn000, true);
    3716     }
    3717     }
    3718   }
    3719
    3720   final public void ArgumentList() throws ParseException {
    3721  /*@bgen(jjtree) ArgumentList */
    3722   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
    3723   boolean jjtc000 = true;
    3724   jjtree.openNodeScope(jjtn000);
    3725     try {
    3726       Expression();
    3727       label_35:
    3728       while (true) {
    3729         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3730         case COMMA:
    3731           ;
    3732           break;
    3733         default:
    3734           jj_la1[94] = jj_gen;
    3735           break label_35;
    3736         }
    3737         jj_consume_token(COMMA);
    3738         Expression();
    3739       }
    3740     } catch (Throwable jjte000) {
    3741     if (jjtc000) {
    3742       jjtree.clearNodeScope(jjtn000);
    3743       jjtc000 = false;
    3744     } else {
    3745       jjtree.popNode();
    3746     }
    3747     if (jjte000 instanceof RuntimeException) {
    3748       {if (true) throw (RuntimeException)jjte000;}
    3749     }
    3750     if (jjte000 instanceof ParseException) {
    3751       {if (true) throw (ParseException)jjte000;}
    3752     }
    3753     {if (true) throw (Error)jjte000;}
    3754     } finally {
    3755     if (jjtc000) {
    3756       jjtree.closeNodeScope(jjtn000, true);
    3757     }
    3758     }
    3759   }
    3760
    3761   final public void AllocationExpression() throws ParseException {
    3762  /*@bgen(jjtree) AllocationExpression */
    3763   ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
    3764   boolean jjtc000 = true;
    3765   jjtree.openNodeScope(jjtn000);
    3766     try {
    3767       if (jj_2_33(2)) {
    3768         jj_consume_token(NEW);
    3769         PrimitiveType();
    3770         ArrayDimsAndInits();
    3771       } else {
    3772         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3773         case NEW:
    3774           jj_consume_token(NEW);
    3775           ClassOrInterfaceType();
    3776           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3777           case LT:
    3778             TypeArguments();
    3779             break;
    3780           default:
    3781             jj_la1[95] = jj_gen;
    3782             ;
    3783           }
    3784           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3785           case LBRACKET:
    3786             ArrayDimsAndInits();
    3787             break;
    3788           case LPAREN:
    3789             Arguments();
    3790             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3791             case LBRACE:
    3792               ClassOrInterfaceBody();
    3793               break;
    3794             default:
    3795               jj_la1[96] = jj_gen;
    3796               ;
    3797             }
    3798             break;
    3799           default:
    3800             jj_la1[97] = jj_gen;
    3801             jj_consume_token(-1);
    3802             throw new ParseException();
    3803           }
    3804           break;
    3805         default:
    3806           jj_la1[98] = jj_gen;
    3807           jj_consume_token(-1);
    3808           throw new ParseException();
    3809         }
    3810       }
    3811     } catch (Throwable jjte000) {
    3812     if (jjtc000) {
    3813       jjtree.clearNodeScope(jjtn000);
    3814       jjtc000 = false;
    3815     } else {
    3816       jjtree.popNode();
    3817     }
    3818     if (jjte000 instanceof RuntimeException) {
    3819       {if (true) throw (RuntimeException)jjte000;}
    3820     }
    3821     if (jjte000 instanceof ParseException) {
    3822       {if (true) throw (ParseException)jjte000;}
    3823     }
    3824     {if (true) throw (Error)jjte000;}
    3825     } finally {
    3826     if (jjtc000) {
    3827       jjtree.closeNodeScope(jjtn000, true);
    3828     }
    3829     }
    3830   }
    3831
    3832 /*
    3833  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
    3834  * if there is an expression between the "[...]".
    3835  */
    3836   final public void ArrayDimsAndInits() throws ParseException {
    3837  /*@bgen(jjtree) ArrayDimsAndInits */
    3838   ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
    3839   boolean jjtc000 = true;
    3840   jjtree.openNodeScope(jjtn000);
    3841     try {
    3842       if (jj_2_36(2)) {
    3843         label_36:
    3844         while (true) {
    3845           jj_consume_token(LBRACKET);
    3846           Expression();
    3847           jj_consume_token(RBRACKET);
    3848           if (jj_2_34(2)) {
    3849             ;
    3850           } else {
    3851             break label_36;
    3852           }
    3853         }
    3854         label_37:
    3855         while (true) {
    3856           if (jj_2_35(2)) {
    3857             ;
    3858           } else {
    3859             break label_37;
    3860           }
    3861           jj_consume_token(LBRACKET);
    3862           jj_consume_token(RBRACKET);
    3863         }
    3864       } else {
    3865         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3866         case LBRACKET:
    3867           label_38:
    3868           while (true) {
    3869             jj_consume_token(LBRACKET);
    3870             jj_consume_token(RBRACKET);
    3871             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3872             case LBRACKET:
    3873               ;
    3874               break;
    3875             default:
    3876               jj_la1[99] = jj_gen;
    3877               break label_38;
    3878             }
    3879           }
    3880           ArrayInitializer();
    3881           break;
    3882         default:
    3883           jj_la1[100] = jj_gen;
    3884           jj_consume_token(-1);
    3885           throw new ParseException();
    3886         }
    3887       }
    3888     } catch (Throwable jjte000) {
    3889     if (jjtc000) {
    3890       jjtree.clearNodeScope(jjtn000);
    3891       jjtc000 = false;
    3892     } else {
    3893       jjtree.popNode();
    3894     }
    3895     if (jjte000 instanceof RuntimeException) {
    3896       {if (true) throw (RuntimeException)jjte000;}
    3897     }
    3898     if (jjte000 instanceof ParseException) {
    3899       {if (true) throw (ParseException)jjte000;}
    3900     }
    3901     {if (true) throw (Error)jjte000;}
    3902     } finally {
    3903     if (jjtc000) {
    3904       jjtree.closeNodeScope(jjtn000, true);
    3905     }
    3906     }
    3907   }
    3908
    3909 /*
    3910  * Statement syntax follows.
    3911  */
    3912   final public void Statement() throws ParseException {
    3913  /*@bgen(jjtree) Statement */
    3914   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
    3915   boolean jjtc000 = true;
    3916   jjtree.openNodeScope(jjtn000);
    3917     try {
    3918       if (isNextTokenAnAssert()) {
    3919         AssertStatement();
    3920       } else if (jj_2_37(2)) {
    3921         LabeledStatement();
    3922       } else {
    3923         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    3924         case LBRACE:
    3925           Block();
    3926           break;
    3927         case SEMICOLON:
    3928           EmptyStatement();
    3929           break;
    3930         case BOOLEAN:
    3931         case BYTE:
    3932         case CHAR:
    3933         case DOUBLE:
    3934         case FALSE:
    3935         case FLOAT:
    3936         case INT:
    3937         case LONG:
    3938         case NEW:
    3939         case NULL:
    3940         case SHORT:
    3941         case SUPER:
    3942         case THIS:
    3943         case TRUE:
    3944         case VOID:
    3945         case INTEGER_LITERAL:
    3946         case FLOATING_POINT_LITERAL:
    3947         case CHARACTER_LITERAL:
    3948         case STRING_LITERAL:
    3949         case IDENTIFIER:
    3950         case LPAREN:
    3951         case INCR:
    3952         case DECR:
    3953           StatementExpression();
    3954           jj_consume_token(SEMICOLON);
    3955           break;
    3956         case SWITCH:
    3957           SwitchStatement();
    3958           break;
    3959         case IF:
    3960           IfStatement();
    3961           break;
    3962         case WHILE:
    3963           WhileStatement();
    3964           break;
    3965         case DO:
    3966           DoStatement();
    3967           break;
    3968         case FOR:
    3969           ForStatement();
    3970           break;
    3971         case BREAK:
    3972           BreakStatement();
    3973           break;
    3974         case CONTINUE:
    3975           ContinueStatement();
    3976           break;
    3977         case RETURN:
    3978           ReturnStatement();
    3979           break;
    3980         case THROW:
    3981           ThrowStatement();
    3982           break;
    3983         case SYNCHRONIZED:
    3984           SynchronizedStatement();
    3985           break;
    3986         case TRY:
    3987           TryStatement();
    3988           break;
    3989         default:
    3990           jj_la1[101] = jj_gen;
    3991           jj_consume_token(-1);
    3992           throw new ParseException();
    3993         }
    3994       }
    3995     } catch (Throwable jjte000) {
    3996     if (jjtc000) {
    3997       jjtree.clearNodeScope(jjtn000);
    3998       jjtc000 = false;
    3999     } else {
    4000       jjtree.popNode();
    4001     }
    4002     if (jjte000 instanceof RuntimeException) {
    4003       {if (true) throw (RuntimeException)jjte000;}
    4004     }
    4005     if (jjte000 instanceof ParseException) {
    4006       {if (true) throw (ParseException)jjte000;}
    4007     }
    4008     {if (true) throw (Error)jjte000;}
    4009     } finally {
    4010     if (jjtc000) {
    4011       jjtree.closeNodeScope(jjtn000, true);
    4012     }
    4013     }
    4014   }
    4015
    4016   final public void LabeledStatement() throws ParseException {
    4017  /*@bgen(jjtree) LabeledStatement */
    4018  ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
    4019  boolean jjtc000 = true;
    4020  jjtree.openNodeScope(jjtn000);Token t;
    4021     try {
    4022       t = jj_consume_token(IDENTIFIER);
    4023                   jjtn000.setImage(t.image);
    4024       jj_consume_token(COLON);
    4025       Statement();
    4026     } catch (Throwable jjte000) {
    4027     if (jjtc000) {
    4028       jjtree.clearNodeScope(jjtn000);
    4029       jjtc000 = false;
    4030     } else {
    4031       jjtree.popNode();
    4032     }
    4033     if (jjte000 instanceof RuntimeException) {
    4034       {if (true) throw (RuntimeException)jjte000;}
    4035     }
    4036     if (jjte000 instanceof ParseException) {
    4037       {if (true) throw (ParseException)jjte000;}
    4038     }
    4039     {if (true) throw (Error)jjte000;}
    4040     } finally {
    4041     if (jjtc000) {
    4042       jjtree.closeNodeScope(jjtn000, true);
    4043     }
    4044     }
    4045   }
    4046
    4047   final public void Block() throws ParseException {
    4048  /*@bgen(jjtree) Block */
    4049  ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
    4050  boolean jjtc000 = true;
    4051  jjtree.openNodeScope(jjtn000);Token t;
    4052     try {
    4053       jj_consume_token(LBRACE);
    4054       label_39:
    4055       while (true) {
    4056         if (jj_2_38(1)) {
    4057           ;
    4058         } else {
    4059           break label_39;
    4060         }
    4061         BlockStatement();
    4062       }
    4063       t = jj_consume_token(RBRACE);
    4064                                       jjtree.closeNodeScope(jjtn000, true);
    4065                                       jjtc000 = false;
    4066                                       if (isPrecededByComment(t)) { jjtn000.setContainsComment(); };
    4067     } catch (Throwable jjte000) {
    4068     if (jjtc000) {
    4069       jjtree.clearNodeScope(jjtn000);
    4070       jjtc000 = false;
    4071     } else {
    4072       jjtree.popNode();
    4073     }
    4074     if (jjte000 instanceof RuntimeException) {
    4075       {if (true) throw (RuntimeException)jjte000;}
    4076     }
    4077     if (jjte000 instanceof ParseException) {
    4078       {if (true) throw (ParseException)jjte000;}
    4079     }
    4080     {if (true) throw (Error)jjte000;}
    4081     } finally {
    4082     if (jjtc000) {
    4083       jjtree.closeNodeScope(jjtn000, true);
    4084     }
    4085     }
    4086   }
    4087
    4088   final public void BlockStatement() throws ParseException {
    4089  /*@bgen(jjtree) BlockStatement */
    4090   ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
    4091   boolean jjtc000 = true;
    4092   jjtree.openNodeScope(jjtn000);
    4093     try {
    4094       if (isNextTokenAnAssert()) {
    4095         AssertStatement();
    4096       } else if (jj_2_39(2147483647)) {
    4097         LocalVariableDeclaration();
    4098         jj_consume_token(SEMICOLON);
    4099       } else if (jj_2_40(1)) {
    4100         Statement();
    4101       } else if (jj_2_41(2147483647)) {
    4102         ClassOrInterfaceDeclaration(0);
    4103       } else {
    4104         jj_consume_token(-1);
    4105         throw new ParseException();
    4106       }
    4107     } catch (Throwable jjte000) {
    4108     if (jjtc000) {
    4109       jjtree.clearNodeScope(jjtn000);
    4110       jjtc000 = false;
    4111     } else {
    4112       jjtree.popNode();
    4113     }
    4114     if (jjte000 instanceof RuntimeException) {
    4115       {if (true) throw (RuntimeException)jjte000;}
    4116     }
    4117     if (jjte000 instanceof ParseException) {
    4118       {if (true) throw (ParseException)jjte000;}
    4119     }
    4120     {if (true) throw (Error)jjte000;}
    4121     } finally {
    4122     if (jjtc000) {
    4123       jjtree.closeNodeScope(jjtn000, true);
    4124     }
    4125     }
    4126   }
    4127
    4128   final public void LocalVariableDeclaration() throws ParseException {
    4129  /*@bgen(jjtree) LocalVariableDeclaration */
    4130   ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
    4131   boolean jjtc000 = true;
    4132   jjtree.openNodeScope(jjtn000);
    4133     try {
    4134       label_40:
    4135       while (true) {
    4136         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4137         case FINAL:
    4138         case AT:
    4139           ;
    4140           break;
    4141         default:
    4142           jj_la1[102] = jj_gen;
    4143           break label_40;
    4144         }
    4145         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4146         case FINAL:
    4147           jj_consume_token(FINAL);
    4148              jjtn000.setFinal();
    4149           break;
    4150         case AT:
    4151           Annotation();
    4152           break;
    4153         default:
    4154           jj_la1[103] = jj_gen;
    4155           jj_consume_token(-1);
    4156           throw new ParseException();
    4157         }
    4158       }
    4159       Type();
    4160       VariableDeclarator();
    4161       label_41:
    4162       while (true) {
    4163         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4164         case COMMA:
    4165           ;
    4166           break;
    4167         default:
    4168           jj_la1[104] = jj_gen;
    4169           break label_41;
    4170         }
    4171         jj_consume_token(COMMA);
    4172         VariableDeclarator();
    4173       }
    4174     } catch (Throwable jjte000) {
    4175     if (jjtc000) {
    4176       jjtree.clearNodeScope(jjtn000);
    4177       jjtc000 = false;
    4178     } else {
    4179       jjtree.popNode();
    4180     }
    4181     if (jjte000 instanceof RuntimeException) {
    4182       {if (true) throw (RuntimeException)jjte000;}
    4183     }
    4184     if (jjte000 instanceof ParseException) {
    4185       {if (true) throw (ParseException)jjte000;}
    4186     }
    4187     {if (true) throw (Error)jjte000;}
    4188     } finally {
    4189     if (jjtc000) {
    4190       jjtree.closeNodeScope(jjtn000, true);
    4191     }
    4192     }
    4193   }
    4194
    4195   final public void EmptyStatement() throws ParseException {
    4196  /*@bgen(jjtree) EmptyStatement */
    4197   ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
    4198   boolean jjtc000 = true;
    4199   jjtree.openNodeScope(jjtn000);
    4200     try {
    4201       jj_consume_token(SEMICOLON);
    4202     } finally {
    4203     if (jjtc000) {
    4204       jjtree.closeNodeScope(jjtn000, true);
    4205     }
    4206     }
    4207   }
    4208
    4209   final public void StatementExpression() throws ParseException {
    4210  /*@bgen(jjtree) StatementExpression */
    4211   ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
    4212   boolean jjtc000 = true;
    4213   jjtree.openNodeScope(jjtn000);
    4214     try {
    4215       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4216       case INCR:
    4217         PreIncrementExpression();
    4218         break;
    4219       case DECR:
    4220         PreDecrementExpression();
    4221         break;
    4222       default:
    4223         jj_la1[106] = jj_gen;
    4224         if (jj_2_42(2147483647)) {
    4225           PostfixExpression();
    4226         } else {
    4227           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4228           case BOOLEAN:
    4229           case BYTE:
    4230           case CHAR:
    4231           case DOUBLE:
    4232           case FALSE:
    4233           case FLOAT:
    4234           case INT:
    4235           case LONG:
    4236           case NEW:
    4237           case NULL:
    4238           case SHORT:
    4239           case SUPER:
    4240           case THIS:
    4241           case TRUE:
    4242           case VOID:
    4243           case INTEGER_LITERAL:
    4244           case FLOATING_POINT_LITERAL:
    4245           case CHARACTER_LITERAL:
    4246           case STRING_LITERAL:
    4247           case IDENTIFIER:
    4248           case LPAREN:
    4249             PrimaryExpression();
    4250             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4251             case ASSIGN:
    4252             case PLUSASSIGN:
    4253             case MINUSASSIGN:
    4254             case STARASSIGN:
    4255             case SLASHASSIGN:
    4256             case ANDASSIGN:
    4257             case ORASSIGN:
    4258             case XORASSIGN:
    4259             case REMASSIGN:
    4260             case LSHIFTASSIGN:
    4261             case RSIGNEDSHIFTASSIGN:
    4262             case RUNSIGNEDSHIFTASSIGN:
    4263               AssignmentOperator();
    4264               Expression();
    4265               break;
    4266             default:
    4267               jj_la1[105] = jj_gen;
    4268               ;
    4269             }
    4270             break;
    4271           default:
    4272             jj_la1[107] = jj_gen;
    4273             jj_consume_token(-1);
    4274             throw new ParseException();
    4275           }
    4276         }
    4277       }
    4278     } catch (Throwable jjte000) {
    4279     if (jjtc000) {
    4280       jjtree.clearNodeScope(jjtn000);
    4281       jjtc000 = false;
    4282     } else {
    4283       jjtree.popNode();
    4284     }
    4285     if (jjte000 instanceof RuntimeException) {
    4286       {if (true) throw (RuntimeException)jjte000;}
    4287     }
    4288     if (jjte000 instanceof ParseException) {
    4289       {if (true) throw (ParseException)jjte000;}
    4290     }
    4291     {if (true) throw (Error)jjte000;}
    4292     } finally {
    4293     if (jjtc000) {
    4294       jjtree.closeNodeScope(jjtn000, true);
    4295     }
    4296     }
    4297   }
    4298
    4299   final public void SwitchStatement() throws ParseException {
    4300  /*@bgen(jjtree) SwitchStatement */
    4301   ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
    4302   boolean jjtc000 = true;
    4303   jjtree.openNodeScope(jjtn000);
    4304     try {
    4305       jj_consume_token(SWITCH);
    4306       jj_consume_token(LPAREN);
    4307       Expression();
    4308       jj_consume_token(RPAREN);
    4309       jj_consume_token(LBRACE);
    4310       label_42:
    4311       while (true) {
    4312         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4313         case CASE:
    4314         case _DEFAULT:
    4315           ;
    4316           break;
    4317         default:
    4318           jj_la1[108] = jj_gen;
    4319           break label_42;
    4320         }
    4321         SwitchLabel();
    4322         label_43:
    4323         while (true) {
    4324           if (jj_2_43(1)) {
    4325             ;
    4326           } else {
    4327             break label_43;
    4328           }
    4329           BlockStatement();
    4330         }
    4331       }
    4332       jj_consume_token(RBRACE);
    4333     } catch (Throwable jjte000) {
    4334     if (jjtc000) {
    4335       jjtree.clearNodeScope(jjtn000);
    4336       jjtc000 = false;
    4337     } else {
    4338       jjtree.popNode();
    4339     }
    4340     if (jjte000 instanceof RuntimeException) {
    4341       {if (true) throw (RuntimeException)jjte000;}
    4342     }
    4343     if (jjte000 instanceof ParseException) {
    4344       {if (true) throw (ParseException)jjte000;}
    4345     }
    4346     {if (true) throw (Error)jjte000;}
    4347     } finally {
    4348     if (jjtc000) {
    4349       jjtree.closeNodeScope(jjtn000, true);
    4350     }
    4351     }
    4352   }
    4353
    4354   final public void SwitchLabel() throws ParseException {
    4355  /*@bgen(jjtree) SwitchLabel */
    4356   ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
    4357   boolean jjtc000 = true;
    4358   jjtree.openNodeScope(jjtn000);
    4359     try {
    4360       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4361       case CASE:
    4362         jj_consume_token(CASE);
    4363         Expression();
    4364         jj_consume_token(COLON);
    4365         break;
    4366       case _DEFAULT:
    4367         jj_consume_token(_DEFAULT);
    4368              jjtn000.setDefault();
    4369         jj_consume_token(COLON);
    4370         break;
    4371       default:
    4372         jj_la1[109] = jj_gen;
    4373         jj_consume_token(-1);
    4374         throw new ParseException();
    4375       }
    4376     } catch (Throwable jjte000) {
    4377     if (jjtc000) {
    4378       jjtree.clearNodeScope(jjtn000);
    4379       jjtc000 = false;
    4380     } else {
    4381       jjtree.popNode();
    4382     }
    4383     if (jjte000 instanceof RuntimeException) {
    4384       {if (true) throw (RuntimeException)jjte000;}
    4385     }
    4386     if (jjte000 instanceof ParseException) {
    4387       {if (true) throw (ParseException)jjte000;}
    4388     }
    4389     {if (true) throw (Error)jjte000;}
    4390     } finally {
    4391     if (jjtc000) {
    4392       jjtree.closeNodeScope(jjtn000, true);
    4393     }
    4394     }
    4395   }
    4396
    4397   final public void IfStatement() throws ParseException {
    4398  /*@bgen(jjtree) IfStatement */
    4399   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
    4400   boolean jjtc000 = true;
    4401   jjtree.openNodeScope(jjtn000);
    4402     try {
    4403       jj_consume_token(IF);
    4404       jj_consume_token(LPAREN);
    4405       Expression();
    4406       jj_consume_token(RPAREN);
    4407       Statement();
    4408       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4409       case ELSE:
    4410         jj_consume_token(ELSE);
    4411                                                                jjtn000.setHasElse();
    4412         Statement();
    4413         break;
    4414       default:
    4415         jj_la1[110] = jj_gen;
    4416         ;
    4417       }
    4418   jjtree.closeNodeScope(jjtn000, true);
    4419   jjtc000 = false;
    4420
    4421     } catch (Throwable jjte000) {
    4422     if (jjtc000) {
    4423       jjtree.clearNodeScope(jjtn000);
    4424       jjtc000 = false;
    4425     } else {
    4426       jjtree.popNode();
    4427     }
    4428     if (jjte000 instanceof RuntimeException) {
    4429       {if (true) throw (RuntimeException)jjte000;}
    4430     }
    4431     if (jjte000 instanceof ParseException) {
    4432       {if (true) throw (ParseException)jjte000;}
    4433     }
    4434     {if (true) throw (Error)jjte000;}
    4435     } finally {
    4436     if (jjtc000) {
    4437       jjtree.closeNodeScope(jjtn000, true);
    4438     }
    4439     }
    4440   }
    4441
    4442   final public void WhileStatement() throws ParseException {
    4443  /*@bgen(jjtree) WhileStatement */
    4444   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
    4445   boolean jjtc000 = true;
    4446   jjtree.openNodeScope(jjtn000);
    4447     try {
    4448       jj_consume_token(WHILE);
    4449       jj_consume_token(LPAREN);
    4450       Expression();
    4451       jj_consume_token(RPAREN);
    4452       Statement();
    4453     } catch (Throwable jjte000) {
    4454     if (jjtc000) {
    4455       jjtree.clearNodeScope(jjtn000);
    4456       jjtc000 = false;
    4457     } else {
    4458       jjtree.popNode();
    4459     }
    4460     if (jjte000 instanceof RuntimeException) {
    4461       {if (true) throw (RuntimeException)jjte000;}
    4462     }
    4463     if (jjte000 instanceof ParseException) {
    4464       {if (true) throw (ParseException)jjte000;}
    4465     }
    4466     {if (true) throw (Error)jjte000;}
    4467     } finally {
    4468     if (jjtc000) {
    4469       jjtree.closeNodeScope(jjtn000, true);
    4470     }
    4471     }
    4472   }
    4473
    4474   final public void DoStatement() throws ParseException {
    4475  /*@bgen(jjtree) DoStatement */
    4476   ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
    4477   boolean jjtc000 = true;
    4478   jjtree.openNodeScope(jjtn000);
    4479     try {
    4480       jj_consume_token(DO);
    4481       Statement();
    4482       jj_consume_token(WHILE);
    4483       jj_consume_token(LPAREN);
    4484       Expression();
    4485       jj_consume_token(RPAREN);
    4486       jj_consume_token(SEMICOLON);
    4487     } catch (Throwable jjte000) {
    4488     if (jjtc000) {
    4489       jjtree.clearNodeScope(jjtn000);
    4490       jjtc000 = false;
    4491     } else {
    4492       jjtree.popNode();
    4493     }
    4494     if (jjte000 instanceof RuntimeException) {
    4495       {if (true) throw (RuntimeException)jjte000;}
    4496     }
    4497     if (jjte000 instanceof ParseException) {
    4498       {if (true) throw (ParseException)jjte000;}
    4499     }
    4500     {if (true) throw (Error)jjte000;}
    4501     } finally {
    4502     if (jjtc000) {
    4503       jjtree.closeNodeScope(jjtn000, true);
    4504     }
    4505     }
    4506   }
    4507
    4508   final public void ForStatement() throws ParseException {
    4509  /*@bgen(jjtree) ForStatement */
    4510   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
    4511   boolean jjtc000 = true;
    4512   jjtree.openNodeScope(jjtn000);
    4513     try {
    4514       jj_consume_token(FOR);
    4515       jj_consume_token(LPAREN);
    4516       if (jj_2_44(2147483647)) {
    4517        checkForBadJDK15ForLoopSyntaxArgumentsUsage();
    4518         Modifiers();
    4519         Type();
    4520         jj_consume_token(IDENTIFIER);
    4521         jj_consume_token(COLON);
    4522         Expression();
    4523       } else {
    4524         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4525         case BOOLEAN:
    4526         case BYTE:
    4527         case CHAR:
    4528         case DOUBLE:
    4529         case FALSE:
    4530         case FINAL:
    4531         case FLOAT:
    4532         case INT:
    4533         case LONG:
    4534         case NEW:
    4535         case NULL:
    4536         case SHORT:
    4537         case SUPER:
    4538         case THIS:
    4539         case TRUE:
    4540         case VOID:
    4541         case INTEGER_LITERAL:
    4542         case FLOATING_POINT_LITERAL:
    4543         case CHARACTER_LITERAL:
    4544         case STRING_LITERAL:
    4545         case IDENTIFIER:
    4546         case LPAREN:
    4547         case SEMICOLON:
    4548         case AT:
    4549         case INCR:
    4550         case DECR:
    4551           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4552           case BOOLEAN:
    4553           case BYTE:
    4554           case CHAR:
    4555           case DOUBLE:
    4556           case FALSE:
    4557           case FINAL:
    4558           case FLOAT:
    4559           case INT:
    4560           case LONG:
    4561           case NEW:
    4562           case NULL:
    4563           case SHORT:
    4564           case SUPER:
    4565           case THIS:
    4566           case TRUE:
    4567           case VOID:
    4568           case INTEGER_LITERAL:
    4569           case FLOATING_POINT_LITERAL:
    4570           case CHARACTER_LITERAL:
    4571           case STRING_LITERAL:
    4572           case IDENTIFIER:
    4573           case LPAREN:
    4574           case AT:
    4575           case INCR:
    4576           case DECR:
    4577             ForInit();
    4578             break;
    4579           default:
    4580             jj_la1[111] = jj_gen;
    4581             ;
    4582           }
    4583           jj_consume_token(SEMICOLON);
    4584           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4585           case BOOLEAN:
    4586           case BYTE:
    4587           case CHAR:
    4588           case DOUBLE:
    4589           case FALSE:
    4590           case FLOAT:
    4591           case INT:
    4592           case LONG:
    4593           case NEW:
    4594           case NULL:
    4595           case SHORT:
    4596           case SUPER:
    4597           case THIS:
    4598           case TRUE:
    4599           case VOID:
    4600           case INTEGER_LITERAL:
    4601           case FLOATING_POINT_LITERAL:
    4602           case CHARACTER_LITERAL:
    4603           case STRING_LITERAL:
    4604           case IDENTIFIER:
    4605           case LPAREN:
    4606           case BANG:
    4607           case TILDE:
    4608           case INCR:
    4609           case DECR:
    4610           case PLUS:
    4611           case MINUS:
    4612             Expression();
    4613             break;
    4614           default:
    4615             jj_la1[112] = jj_gen;
    4616             ;
    4617           }
    4618           jj_consume_token(SEMICOLON);
    4619           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4620           case BOOLEAN:
    4621           case BYTE:
    4622           case CHAR:
    4623           case DOUBLE:
    4624           case FALSE:
    4625           case FLOAT:
    4626           case INT:
    4627           case LONG:
    4628           case NEW:
    4629           case NULL:
    4630           case SHORT:
    4631           case SUPER:
    4632           case THIS:
    4633           case TRUE:
    4634           case VOID:
    4635           case INTEGER_LITERAL:
    4636           case FLOATING_POINT_LITERAL:
    4637           case CHARACTER_LITERAL:
    4638           case STRING_LITERAL:
    4639           case IDENTIFIER:
    4640           case LPAREN:
    4641           case INCR:
    4642           case DECR:
    4643             ForUpdate();
    4644             break;
    4645           default:
    4646             jj_la1[113] = jj_gen;
    4647             ;
    4648           }
    4649           break;
    4650         default:
    4651           jj_la1[114] = jj_gen;
    4652           jj_consume_token(-1);
    4653           throw new ParseException();
    4654         }
    4655       }
    4656       jj_consume_token(RPAREN);
    4657       Statement();
    4658     } catch (Throwable jjte000) {
    4659     if (jjtc000) {
    4660       jjtree.clearNodeScope(jjtn000);
    4661       jjtc000 = false;
    4662     } else {
    4663       jjtree.popNode();
    4664     }
    4665     if (jjte000 instanceof RuntimeException) {
    4666       {if (true) throw (RuntimeException)jjte000;}
    4667     }
    4668     if (jjte000 instanceof ParseException) {
    4669       {if (true) throw (ParseException)jjte000;}
    4670     }
    4671     {if (true) throw (Error)jjte000;}
    4672     } finally {
    4673     if (jjtc000) {
    4674       jjtree.closeNodeScope(jjtn000, true);
    4675     }
    4676     }
    4677   }
    4678
    4679   final public void ForInit() throws ParseException {
    4680  /*@bgen(jjtree) ForInit */
    4681   ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
    4682   boolean jjtc000 = true;
    4683   jjtree.openNodeScope(jjtn000);
    4684     try {
    4685       if (jj_2_45(2147483647)) {
    4686         LocalVariableDeclaration();
    4687       } else {
    4688         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4689         case BOOLEAN:
    4690         case BYTE:
    4691         case CHAR:
    4692         case DOUBLE:
    4693         case FALSE:
    4694         case FLOAT:
    4695         case INT:
    4696         case LONG:
    4697         case NEW:
    4698         case NULL:
    4699         case SHORT:
    4700         case SUPER:
    4701         case THIS:
    4702         case TRUE:
    4703         case VOID:
    4704         case INTEGER_LITERAL:
    4705         case FLOATING_POINT_LITERAL:
    4706         case CHARACTER_LITERAL:
    4707         case STRING_LITERAL:
    4708         case IDENTIFIER:
    4709         case LPAREN:
    4710         case INCR:
    4711         case DECR:
    4712           StatementExpressionList();
    4713           break;
    4714         default:
    4715           jj_la1[115] = jj_gen;
    4716           jj_consume_token(-1);
    4717           throw new ParseException();
    4718         }
    4719       }
    4720     } catch (Throwable jjte000) {
    4721     if (jjtc000) {
    4722       jjtree.clearNodeScope(jjtn000);
    4723       jjtc000 = false;
    4724     } else {
    4725       jjtree.popNode();
    4726     }
    4727     if (jjte000 instanceof RuntimeException) {
    4728       {if (true) throw (RuntimeException)jjte000;}
    4729     }
    4730     if (jjte000 instanceof ParseException) {
    4731       {if (true) throw (ParseException)jjte000;}
    4732     }
    4733     {if (true) throw (Error)jjte000;}
    4734     } finally {
    4735     if (jjtc000) {
    4736       jjtree.closeNodeScope(jjtn000, true);
    4737     }
    4738     }
    4739   }
    4740
    4741   final public void StatementExpressionList() throws ParseException {
    4742  /*@bgen(jjtree) StatementExpressionList */
    4743   ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
    4744   boolean jjtc000 = true;
    4745   jjtree.openNodeScope(jjtn000);
    4746     try {
    4747       StatementExpression();
    4748       label_44:
    4749       while (true) {
    4750         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4751         case COMMA:
    4752           ;
    4753           break;
    4754         default:
    4755           jj_la1[116] = jj_gen;
    4756           break label_44;
    4757         }
    4758         jj_consume_token(COMMA);
    4759         StatementExpression();
    4760       }
    4761     } catch (Throwable jjte000) {
    4762     if (jjtc000) {
    4763       jjtree.clearNodeScope(jjtn000);
    4764       jjtc000 = false;
    4765     } else {
    4766       jjtree.popNode();
    4767     }
    4768     if (jjte000 instanceof RuntimeException) {
    4769       {if (true) throw (RuntimeException)jjte000;}
    4770     }
    4771     if (jjte000 instanceof ParseException) {
    4772       {if (true) throw (ParseException)jjte000;}
    4773     }
    4774     {if (true) throw (Error)jjte000;}
    4775     } finally {
    4776     if (jjtc000) {
    4777       jjtree.closeNodeScope(jjtn000, true);
    4778     }
    4779     }
    4780   }
    4781
    4782   final public void ForUpdate() throws ParseException {
    4783  /*@bgen(jjtree) ForUpdate */
    4784   ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
    4785   boolean jjtc000 = true;
    4786   jjtree.openNodeScope(jjtn000);
    4787     try {
    4788       StatementExpressionList();
    4789     } catch (Throwable jjte000) {
    4790     if (jjtc000) {
    4791       jjtree.clearNodeScope(jjtn000);
    4792       jjtc000 = false;
    4793     } else {
    4794       jjtree.popNode();
    4795     }
    4796     if (jjte000 instanceof RuntimeException) {
    4797       {if (true) throw (RuntimeException)jjte000;}
    4798     }
    4799     if (jjte000 instanceof ParseException) {
    4800       {if (true) throw (ParseException)jjte000;}
    4801     }
    4802     {if (true) throw (Error)jjte000;}
    4803     } finally {
    4804     if (jjtc000) {
    4805       jjtree.closeNodeScope(jjtn000, true);
    4806     }
    4807     }
    4808   }
    4809
    4810   final public void BreakStatement() throws ParseException {
    4811  /*@bgen(jjtree) BreakStatement */
    4812  ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
    4813  boolean jjtc000 = true;
    4814  jjtree.openNodeScope(jjtn000);Token t;
    4815     try {
    4816       jj_consume_token(BREAK);
    4817       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4818       case IDENTIFIER:
    4819         t = jj_consume_token(IDENTIFIER);
    4820                             jjtn000.setImage(t.image);
    4821         break;
    4822       default:
    4823         jj_la1[117] = jj_gen;
    4824         ;
    4825       }
    4826       jj_consume_token(SEMICOLON);
    4827     } finally {
    4828     if (jjtc000) {
    4829       jjtree.closeNodeScope(jjtn000, true);
    4830     }
    4831     }
    4832   }
    4833
    4834   final public void ContinueStatement() throws ParseException {
    4835  /*@bgen(jjtree) ContinueStatement */
    4836  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
    4837  boolean jjtc000 = true;
    4838  jjtree.openNodeScope(jjtn000);Token t;
    4839     try {
    4840       jj_consume_token(CONTINUE);
    4841       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4842       case IDENTIFIER:
    4843         t = jj_consume_token(IDENTIFIER);
    4844                                jjtn000.setImage(t.image);
    4845         break;
    4846       default:
    4847         jj_la1[118] = jj_gen;
    4848         ;
    4849       }
    4850       jj_consume_token(SEMICOLON);
    4851     } finally {
    4852     if (jjtc000) {
    4853       jjtree.closeNodeScope(jjtn000, true);
    4854     }
    4855     }
    4856   }
    4857
    4858   final public void ReturnStatement() throws ParseException {
    4859  /*@bgen(jjtree) ReturnStatement */
    4860   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
    4861   boolean jjtc000 = true;
    4862   jjtree.openNodeScope(jjtn000);
    4863     try {
    4864       jj_consume_token(RETURN);
    4865       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4866       case BOOLEAN:
    4867       case BYTE:
    4868       case CHAR:
    4869       case DOUBLE:
    4870       case FALSE:
    4871       case FLOAT:
    4872       case INT:
    4873       case LONG:
    4874       case NEW:
    4875       case NULL:
    4876       case SHORT:
    4877       case SUPER:
    4878       case THIS:
    4879       case TRUE:
    4880       case VOID:
    4881       case INTEGER_LITERAL:
    4882       case FLOATING_POINT_LITERAL:
    4883       case CHARACTER_LITERAL:
    4884       case STRING_LITERAL:
    4885       case IDENTIFIER:
    4886       case LPAREN:
    4887       case BANG:
    4888       case TILDE:
    4889       case INCR:
    4890       case DECR:
    4891       case PLUS:
    4892       case MINUS:
    4893         Expression();
    4894         break;
    4895       default:
    4896         jj_la1[119] = jj_gen;
    4897         ;
    4898       }
    4899       jj_consume_token(SEMICOLON);
    4900     } catch (Throwable jjte000) {
    4901     if (jjtc000) {
    4902       jjtree.clearNodeScope(jjtn000);
    4903       jjtc000 = false;
    4904     } else {
    4905       jjtree.popNode();
    4906     }
    4907     if (jjte000 instanceof RuntimeException) {
    4908       {if (true) throw (RuntimeException)jjte000;}
    4909     }
    4910     if (jjte000 instanceof ParseException) {
    4911       {if (true) throw (ParseException)jjte000;}
    4912     }
    4913     {if (true) throw (Error)jjte000;}
    4914     } finally {
    4915     if (jjtc000) {
    4916       jjtree.closeNodeScope(jjtn000, true);
    4917     }
    4918     }
    4919   }
    4920
    4921   final public void ThrowStatement() throws ParseException {
    4922  /*@bgen(jjtree) ThrowStatement */
    4923   ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
    4924   boolean jjtc000 = true;
    4925   jjtree.openNodeScope(jjtn000);
    4926     try {
    4927       jj_consume_token(THROW);
    4928       Expression();
    4929       jj_consume_token(SEMICOLON);
    4930     } catch (Throwable jjte000) {
    4931     if (jjtc000) {
    4932       jjtree.clearNodeScope(jjtn000);
    4933       jjtc000 = false;
    4934     } else {
    4935       jjtree.popNode();
    4936     }
    4937     if (jjte000 instanceof RuntimeException) {
    4938       {if (true) throw (RuntimeException)jjte000;}
    4939     }
    4940     if (jjte000 instanceof ParseException) {
    4941       {if (true) throw (ParseException)jjte000;}
    4942     }
    4943     {if (true) throw (Error)jjte000;}
    4944     } finally {
    4945     if (jjtc000) {
    4946       jjtree.closeNodeScope(jjtn000, true);
    4947     }
    4948     }
    4949   }
    4950
    4951   final public void SynchronizedStatement() throws ParseException {
    4952  /*@bgen(jjtree) SynchronizedStatement */
    4953   ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
    4954   boolean jjtc000 = true;
    4955   jjtree.openNodeScope(jjtn000);
    4956     try {
    4957       jj_consume_token(SYNCHRONIZED);
    4958       jj_consume_token(LPAREN);
    4959       Expression();
    4960       jj_consume_token(RPAREN);
    4961       Block();
    4962     } catch (Throwable jjte000) {
    4963     if (jjtc000) {
    4964       jjtree.clearNodeScope(jjtn000);
    4965       jjtc000 = false;
    4966     } else {
    4967       jjtree.popNode();
    4968     }
    4969     if (jjte000 instanceof RuntimeException) {
    4970       {if (true) throw (RuntimeException)jjte000;}
    4971     }
    4972     if (jjte000 instanceof ParseException) {
    4973       {if (true) throw (ParseException)jjte000;}
    4974     }
    4975     {if (true) throw (Error)jjte000;}
    4976     } finally {
    4977     if (jjtc000) {
    4978       jjtree.closeNodeScope(jjtn000, true);
    4979     }
    4980     }
    4981   }
    4982
    4983   final public void TryStatement() throws ParseException {
    4984  /*@bgen(jjtree) TryStatement */
    4985   ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
    4986   boolean jjtc000 = true;
    4987   jjtree.openNodeScope(jjtn000);
    4988     try {
    4989       jj_consume_token(TRY);
    4990       Block();
    4991       label_45:
    4992       while (true) {
    4993         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    4994         case CATCH:
    4995           ;
    4996           break;
    4997         default:
    4998           jj_la1[120] = jj_gen;
    4999           break label_45;
    5000         }
    5001         CatchStatement();
    5002       }
    5003       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5004       case FINALLY:
    5005         FinallyStatement();
    5006         break;
    5007       default:
    5008         jj_la1[121] = jj_gen;
    5009         ;
    5010       }
    5011     } catch (Throwable jjte000) {
    5012     if (jjtc000) {
    5013       jjtree.clearNodeScope(jjtn000);
    5014       jjtc000 = false;
    5015     } else {
    5016       jjtree.popNode();
    5017     }
    5018     if (jjte000 instanceof RuntimeException) {
    5019       {if (true) throw (RuntimeException)jjte000;}
    5020     }
    5021     if (jjte000 instanceof ParseException) {
    5022       {if (true) throw (ParseException)jjte000;}
    5023     }
    5024     {if (true) throw (Error)jjte000;}
    5025     } finally {
    5026     if (jjtc000) {
    5027       jjtree.closeNodeScope(jjtn000, true);
    5028     }
    5029     }
    5030   }
    5031
    5032   final public void CatchStatement() throws ParseException {
    5033  /*@bgen(jjtree) CatchStatement */
    5034   ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
    5035   boolean jjtc000 = true;
    5036   jjtree.openNodeScope(jjtn000);
    5037     try {
    5038       jj_consume_token(CATCH);
    5039       jj_consume_token(LPAREN);
    5040       FormalParameter();
    5041       jj_consume_token(RPAREN);
    5042       Block();
    5043     } catch (Throwable jjte000) {
    5044     if (jjtc000) {
    5045       jjtree.clearNodeScope(jjtn000);
    5046       jjtc000 = false;
    5047     } else {
    5048       jjtree.popNode();
    5049     }
    5050     if (jjte000 instanceof RuntimeException) {
    5051       {if (true) throw (RuntimeException)jjte000;}
    5052     }
    5053     if (jjte000 instanceof ParseException) {
    5054       {if (true) throw (ParseException)jjte000;}
    5055     }
    5056     {if (true) throw (Error)jjte000;}
    5057     } finally {
    5058     if (jjtc000) {
    5059       jjtree.closeNodeScope(jjtn000, true);
    5060     }
    5061     }
    5062   }
    5063
    5064   final public void FinallyStatement() throws ParseException {
    5065  /*@bgen(jjtree) FinallyStatement */
    5066   ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
    5067   boolean jjtc000 = true;
    5068   jjtree.openNodeScope(jjtn000);
    5069     try {
    5070       jj_consume_token(FINALLY);
    5071       Block();
    5072     } catch (Throwable jjte000) {
    5073       if (jjtc000) {
    5074         jjtree.clearNodeScope(jjtn000);
    5075         jjtc000 = false;
    5076       } else {
    5077         jjtree.popNode();
    5078       }
    5079       if (jjte000 instanceof RuntimeException) {
    5080         {if (true) throw (RuntimeException)jjte000;}
    5081       }
    5082       if (jjte000 instanceof ParseException) {
    5083         {if (true) throw (ParseException)jjte000;}
    5084       }
    5085       {if (true) throw (Error)jjte000;}
    5086     } finally {
    5087       if (jjtc000) {
    5088         jjtree.closeNodeScope(jjtn000, true);
    5089       }
    5090     }
    5091   }
    5092
    5093   final public void AssertStatement() throws ParseException {
    5094  /*@bgen(jjtree) AssertStatement */
    5095     ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
    5096     boolean jjtc000 = true;
    5097     jjtree.openNodeScope(jjtn000);if (isJDK13) {
    5098         throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
    5099     }
    5100     try {
    5101       jj_consume_token(IDENTIFIER);
    5102       Expression();
    5103       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5104       case COLON:
    5105         jj_consume_token(COLON);
    5106         Expression();
    5107         break;
    5108       default:
    5109         jj_la1[122] = jj_gen;
    5110         ;
    5111       }
    5112       jj_consume_token(SEMICOLON);
    5113     } catch (Throwable jjte000) {
    5114     if (jjtc000) {
    5115       jjtree.clearNodeScope(jjtn000);
    5116       jjtc000 = false;
    5117     } else {
    5118       jjtree.popNode();
    5119     }
    5120     if (jjte000 instanceof RuntimeException) {
    5121       {if (true) throw (RuntimeException)jjte000;}
    5122     }
    5123     if (jjte000 instanceof ParseException) {
    5124       {if (true) throw (ParseException)jjte000;}
    5125     }
    5126     {if (true) throw (Error)jjte000;}
    5127     } finally {
    5128     if (jjtc000) {
    5129       jjtree.closeNodeScope(jjtn000, true);
    5130     }
    5131     }
    5132   }
    5133
    5134 /* We use productions to match >>>, >> and > so that we can keep the
    5135  * type declaration syntax with generics clean
    5136  */
    5137   final public void RUNSIGNEDSHIFT() throws ParseException {
    5138  /*@bgen(jjtree) RUNSIGNEDSHIFT */
    5139   ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
    5140   boolean jjtc000 = true;
    5141   jjtree.openNodeScope(jjtn000);
    5142     try {
    5143       if (getToken(1).kind == GT &&
    5144                       ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
    5145
    5146       } else {
    5147         jj_consume_token(-1);
    5148         throw new ParseException();
    5149       }
    5150       jj_consume_token(GT);
    5151       jj_consume_token(GT);
    5152       jj_consume_token(GT);
    5153     } finally {
    5154     if (jjtc000) {
    5155       jjtree.closeNodeScope(jjtn000, true);
    5156     }
    5157     }
    5158   }
    5159
    5160   final public void RSIGNEDSHIFT() throws ParseException {
    5161  /*@bgen(jjtree) RSIGNEDSHIFT */
    5162   ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
    5163   boolean jjtc000 = true;
    5164   jjtree.openNodeScope(jjtn000);
    5165     try {
    5166       if (getToken(1).kind == GT &&
    5167                       ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
    5168
    5169       } else {
    5170         jj_consume_token(-1);
    5171         throw new ParseException();
    5172       }
    5173       jj_consume_token(GT);
    5174       jj_consume_token(GT);
    5175     } finally {
    5176     if (jjtc000) {
    5177       jjtree.closeNodeScope(jjtn000, true);
    5178     }
    5179     }
    5180   }
    5181
    5182 /* Annotation syntax follows. */
    5183   final public void Annotation() throws ParseException {
    5184  /*@bgen(jjtree) Annotation */
    5185   ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
    5186   boolean jjtc000 = true;
    5187   jjtree.openNodeScope(jjtn000);
    5188     try {
    5189       if (jj_2_46(2147483647)) {
    5190         NormalAnnotation();
    5191       } else if (jj_2_47(2147483647)) {
    5192         SingleMemberAnnotation();
    5193       } else {
    5194         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5195         case AT:
    5196           MarkerAnnotation();
    5197           break;
    5198         default:
    5199           jj_la1[123] = jj_gen;
    5200           jj_consume_token(-1);
    5201           throw new ParseException();
    5202         }
    5203       }
    5204     } catch (Throwable jjte000) {
    5205      if (jjtc000) {
    5206        jjtree.clearNodeScope(jjtn000);
    5207        jjtc000 = false;
    5208      } else {
    5209        jjtree.popNode();
    5210      }
    5211      if (jjte000 instanceof RuntimeException) {
    5212        {if (true) throw (RuntimeException)jjte000;}
    5213      }
    5214      if (jjte000 instanceof ParseException) {
    5215        {if (true) throw (ParseException)jjte000;}
    5216      }
    5217      {if (true) throw (Error)jjte000;}
    5218     } finally {
    5219      if (jjtc000) {
    5220        jjtree.closeNodeScope(jjtn000, true);
    5221      }
    5222     }
    5223   }
    5224
    5225   final public void NormalAnnotation() throws ParseException {
    5226  /*@bgen(jjtree) NormalAnnotation */
    5227   ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
    5228   boolean jjtc000 = true;
    5229   jjtree.openNodeScope(jjtn000);
    5230     try {
    5231       jj_consume_token(AT);
    5232       Name();
    5233       jj_consume_token(LPAREN);
    5234       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5235       case IDENTIFIER:
    5236         MemberValuePairs();
    5237         break;
    5238       default:
    5239         jj_la1[124] = jj_gen;
    5240         ;
    5241       }
    5242       jj_consume_token(RPAREN);
    5243     } catch (Throwable jjte000) {
    5244      if (jjtc000) {
    5245        jjtree.clearNodeScope(jjtn000);
    5246        jjtc000 = false;
    5247      } else {
    5248        jjtree.popNode();
    5249      }
    5250      if (jjte000 instanceof RuntimeException) {
    5251        {if (true) throw (RuntimeException)jjte000;}
    5252      }
    5253      if (jjte000 instanceof ParseException) {
    5254        {if (true) throw (ParseException)jjte000;}
    5255      }
    5256      {if (true) throw (Error)jjte000;}
    5257     } finally {
    5258      if (jjtc000) {
    5259        jjtree.closeNodeScope(jjtn000, true);
    5260      }
    5261     }
    5262   }
    5263
    5264   final public void MarkerAnnotation() throws ParseException {
    5265  /*@bgen(jjtree) MarkerAnnotation */
    5266   ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
    5267   boolean jjtc000 = true;
    5268   jjtree.openNodeScope(jjtn000);
    5269     try {
    5270       jj_consume_token(AT);
    5271       Name();
    5272     } catch (Throwable jjte000) {
    5273     if (jjtc000) {
    5274       jjtree.clearNodeScope(jjtn000);
    5275       jjtc000 = false;
    5276     } else {
    5277       jjtree.popNode();
    5278     }
    5279     if (jjte000 instanceof RuntimeException) {
    5280       {if (true) throw (RuntimeException)jjte000;}
    5281     }
    5282     if (jjte000 instanceof ParseException) {
    5283       {if (true) throw (ParseException)jjte000;}
    5284     }
    5285     {if (true) throw (Error)jjte000;}
    5286     } finally {
    5287     if (jjtc000) {
    5288       jjtree.closeNodeScope(jjtn000, true);
    5289     }
    5290     }
    5291   }
    5292
    5293   final public void SingleMemberAnnotation() throws ParseException {
    5294  /*@bgen(jjtree) SingleMemberAnnotation */
    5295   ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
    5296   boolean jjtc000 = true;
    5297   jjtree.openNodeScope(jjtn000);
    5298     try {
    5299       jj_consume_token(AT);
    5300       Name();
    5301       jj_consume_token(LPAREN);
    5302       MemberValue();
    5303       jj_consume_token(RPAREN);
    5304     } catch (Throwable jjte000) {
    5305     if (jjtc000) {
    5306       jjtree.clearNodeScope(jjtn000);
    5307       jjtc000 = false;
    5308     } else {
    5309       jjtree.popNode();
    5310     }
    5311     if (jjte000 instanceof RuntimeException) {
    5312       {if (true) throw (RuntimeException)jjte000;}
    5313     }
    5314     if (jjte000 instanceof ParseException) {
    5315       {if (true) throw (ParseException)jjte000;}
    5316     }
    5317     {if (true) throw (Error)jjte000;}
    5318     } finally {
    5319     if (jjtc000) {
    5320       jjtree.closeNodeScope(jjtn000, true);
    5321     }
    5322     }
    5323   }
    5324
    5325   final public void MemberValuePairs() throws ParseException {
    5326  /*@bgen(jjtree) MemberValuePairs */
    5327   ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
    5328   boolean jjtc000 = true;
    5329   jjtree.openNodeScope(jjtn000);
    5330     try {
    5331       MemberValuePair();
    5332       label_46:
    5333       while (true) {
    5334         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5335         case COMMA:
    5336           ;
    5337           break;
    5338         default:
    5339           jj_la1[125] = jj_gen;
    5340           break label_46;
    5341         }
    5342         jj_consume_token(COMMA);
    5343         MemberValuePair();
    5344       }
    5345     } catch (Throwable jjte000) {
    5346      if (jjtc000) {
    5347        jjtree.clearNodeScope(jjtn000);
    5348        jjtc000 = false;
    5349      } else {
    5350        jjtree.popNode();
    5351      }
    5352      if (jjte000 instanceof RuntimeException) {
    5353        {if (true) throw (RuntimeException)jjte000;}
    5354      }
    5355      if (jjte000 instanceof ParseException) {
    5356        {if (true) throw (ParseException)jjte000;}
    5357      }
    5358      {if (true) throw (Error)jjte000;}
    5359     } finally {
    5360      if (jjtc000) {
    5361        jjtree.closeNodeScope(jjtn000, true);
    5362      }
    5363     }
    5364   }
    5365
    5366   final public void MemberValuePair() throws ParseException {
    5367  /*@bgen(jjtree) MemberValuePair */
    5368  ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
    5369  boolean jjtc000 = true;
    5370  jjtree.openNodeScope(jjtn000);Token t;
    5371     try {
    5372       t = jj_consume_token(IDENTIFIER);
    5373                      jjtn000.setImage(t.image);
    5374       jj_consume_token(ASSIGN);
    5375       MemberValue();
    5376     } catch (Throwable jjte000) {
    5377       if (jjtc000) {
    5378         jjtree.clearNodeScope(jjtn000);
    5379         jjtc000 = false;
    5380       } else {
    5381         jjtree.popNode();
    5382       }
    5383       if (jjte000 instanceof RuntimeException) {
    5384         {if (true) throw (RuntimeException)jjte000;}
    5385       }
    5386       if (jjte000 instanceof ParseException) {
    5387         {if (true) throw (ParseException)jjte000;}
    5388       }
    5389       {if (true) throw (Error)jjte000;}
    5390     } finally {
    5391       if (jjtc000) {
    5392         jjtree.closeNodeScope(jjtn000, true);
    5393       }
    5394     }
    5395   }
    5396
    5397   final public void MemberValue() throws ParseException {
    5398  /*@bgen(jjtree) MemberValue */
    5399   ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
    5400   boolean jjtc000 = true;
    5401   jjtree.openNodeScope(jjtn000);
    5402     try {
    5403       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5404       case AT:
    5405         Annotation();
    5406         break;
    5407       case LBRACE:
    5408         MemberValueArrayInitializer();
    5409         break;
    5410       case BOOLEAN:
    5411       case BYTE:
    5412       case CHAR:
    5413       case DOUBLE:
    5414       case FALSE:
    5415       case FLOAT:
    5416       case INT:
    5417       case LONG:
    5418       case NEW:
    5419       case NULL:
    5420       case SHORT:
    5421       case SUPER:
    5422       case THIS:
    5423       case TRUE:
    5424       case VOID:
    5425       case INTEGER_LITERAL:
    5426       case FLOATING_POINT_LITERAL:
    5427       case CHARACTER_LITERAL:
    5428       case STRING_LITERAL:
    5429       case IDENTIFIER:
    5430       case LPAREN:
    5431       case BANG:
    5432       case TILDE:
    5433       case INCR:
    5434       case DECR:
    5435       case PLUS:
    5436       case MINUS:
    5437         ConditionalExpression();
    5438         break;
    5439       default:
    5440         jj_la1[126] = jj_gen;
    5441         jj_consume_token(-1);
    5442         throw new ParseException();
    5443       }
    5444     } catch (Throwable jjte000) {
    5445      if (jjtc000) {
    5446        jjtree.clearNodeScope(jjtn000);
    5447        jjtc000 = false;
    5448      } else {
    5449        jjtree.popNode();
    5450      }
    5451      if (jjte000 instanceof RuntimeException) {
    5452        {if (true) throw (RuntimeException)jjte000;}
    5453      }
    5454      if (jjte000 instanceof ParseException) {
    5455        {if (true) throw (ParseException)jjte000;}
    5456      }
    5457      {if (true) throw (Error)jjte000;}
    5458     } finally {
    5459      if (jjtc000) {
    5460        jjtree.closeNodeScope(jjtn000, true);
    5461      }
    5462     }
    5463   }
    5464
    5465   final public void MemberValueArrayInitializer() throws ParseException {
    5466  /*@bgen(jjtree) MemberValueArrayInitializer */
    5467   ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
    5468   boolean jjtc000 = true;
    5469   jjtree.openNodeScope(jjtn000);
    5470     try {
    5471       jj_consume_token(LBRACE);
    5472       MemberValue();
    5473       label_47:
    5474       while (true) {
    5475         if (jj_2_48(2)) {
    5476           ;
    5477         } else {
    5478           break label_47;
    5479         }
    5480         jj_consume_token(COMMA);
    5481         MemberValue();
    5482       }
    5483       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5484       case COMMA:
    5485         jj_consume_token(COMMA);
    5486         break;
    5487       default:
    5488         jj_la1[127] = jj_gen;
    5489         ;
    5490       }
    5491       jj_consume_token(RBRACE);
    5492     } catch (Throwable jjte000) {
    5493     if (jjtc000) {
    5494       jjtree.clearNodeScope(jjtn000);
    5495       jjtc000 = false;
    5496     } else {
    5497       jjtree.popNode();
    5498     }
    5499     if (jjte000 instanceof RuntimeException) {
    5500       {if (true) throw (RuntimeException)jjte000;}
    5501     }
    5502     if (jjte000 instanceof ParseException) {
    5503       {if (true) throw (ParseException)jjte000;}
    5504     }
    5505     {if (true) throw (Error)jjte000;}
    5506     } finally {
    5507     if (jjtc000) {
    5508       jjtree.closeNodeScope(jjtn000, true);
    5509     }
    5510     }
    5511   }
    5512
    5513 /* Annotation Types. */
    5514   final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
    5515  /*@bgen(jjtree) AnnotationTypeDeclaration */
    5516 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
    5517 boolean jjtc000 = true;
    5518 jjtree.openNodeScope(jjtn000);Token t;
    5519 jjtn000.setModifiers(modifiers);
    5520     try {
    5521       jj_consume_token(AT);
    5522       jj_consume_token(INTERFACE);
    5523       t = jj_consume_token(IDENTIFIER);
    5524                                   jjtn000.setImage(t.image);
    5525       AnnotationTypeBody();
    5526     } catch (Throwable jjte000) {
    5527     if (jjtc000) {
    5528       jjtree.clearNodeScope(jjtn000);
    5529       jjtc000 = false;
    5530     } else {
    5531       jjtree.popNode();
    5532     }
    5533     if (jjte000 instanceof RuntimeException) {
    5534       {if (true) throw (RuntimeException)jjte000;}
    5535     }
    5536     if (jjte000 instanceof ParseException) {
    5537       {if (true) throw (ParseException)jjte000;}
    5538     }
    5539     {if (true) throw (Error)jjte000;}
    5540     } finally {
    5541     if (jjtc000) {
    5542       jjtree.closeNodeScope(jjtn000, true);
    5543     }
    5544     }
    5545   }
    5546
    5547   final public void AnnotationTypeBody() throws ParseException {
    5548  /*@bgen(jjtree) AnnotationTypeBody */
    5549   ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
    5550   boolean jjtc000 = true;
    5551   jjtree.openNodeScope(jjtn000);
    5552     try {
    5553       jj_consume_token(LBRACE);
    5554       label_48:
    5555       while (true) {
    5556         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5557         case ABSTRACT:
    5558         case BOOLEAN:
    5559         case BYTE:
    5560         case CHAR:
    5561         case CLASS:
    5562         case DOUBLE:
    5563         case FINAL:
    5564         case FLOAT:
    5565         case INT:
    5566         case INTERFACE:
    5567         case LONG:
    5568         case NATIVE:
    5569         case PRIVATE:
    5570         case PROTECTED:
    5571         case PUBLIC:
    5572         case SHORT:
    5573         case STATIC:
    5574         case SYNCHRONIZED:
    5575         case TRANSIENT:
    5576         case VOLATILE:
    5577         case STRICTFP:
    5578         case IDENTIFIER:
    5579         case SEMICOLON:
    5580         case AT:
    5581           ;
    5582           break;
    5583         default:
    5584           jj_la1[128] = jj_gen;
    5585           break label_48;
    5586         }
    5587         AnnotationTypeMemberDeclaration();
    5588       }
    5589       jj_consume_token(RBRACE);
    5590     } catch (Throwable jjte000) {
    5591     if (jjtc000) {
    5592       jjtree.clearNodeScope(jjtn000);
    5593       jjtc000 = false;
    5594     } else {
    5595       jjtree.popNode();
    5596     }
    5597     if (jjte000 instanceof RuntimeException) {
    5598       {if (true) throw (RuntimeException)jjte000;}
    5599     }
    5600     if (jjte000 instanceof ParseException) {
    5601       {if (true) throw (ParseException)jjte000;}
    5602     }
    5603     {if (true) throw (Error)jjte000;}
    5604     } finally {
    5605     if (jjtc000) {
    5606       jjtree.closeNodeScope(jjtn000, true);
    5607     }
    5608     }
    5609   }
    5610
    5611   final public void AnnotationTypeMemberDeclaration() throws ParseException {
    5612  /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
    5613    ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
    5614    boolean jjtc000 = true;
    5615    jjtree.openNodeScope(jjtn000);int modifiers;
    5616     try {
    5617       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5618       case ABSTRACT:
    5619       case BOOLEAN:
    5620       case BYTE:
    5621       case CHAR:
    5622       case CLASS:
    5623       case DOUBLE:
    5624       case FINAL:
    5625       case FLOAT:
    5626       case INT:
    5627       case INTERFACE:
    5628       case LONG:
    5629       case NATIVE:
    5630       case PRIVATE:
    5631       case PROTECTED:
    5632       case PUBLIC:
    5633       case SHORT:
    5634       case STATIC:
    5635       case SYNCHRONIZED:
    5636       case TRANSIENT:
    5637       case VOLATILE:
    5638       case STRICTFP:
    5639       case IDENTIFIER:
    5640       case AT:
    5641         modifiers = Modifiers();
    5642         if (jj_2_49(2147483647)) {
    5643           Type();
    5644           jj_consume_token(IDENTIFIER);
    5645           jj_consume_token(LPAREN);
    5646           jj_consume_token(RPAREN);
    5647           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5648           case _DEFAULT:
    5649             DefaultValue();
    5650             break;
    5651           default:
    5652             jj_la1[129] = jj_gen;
    5653             ;
    5654           }
    5655           jj_consume_token(SEMICOLON);
    5656         } else {
    5657           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5658           case ABSTRACT:
    5659           case CLASS:
    5660           case FINAL:
    5661           case INTERFACE:
    5662             ClassOrInterfaceDeclaration(modifiers);
    5663             break;
    5664           default:
    5665             jj_la1[130] = jj_gen;
    5666             if (jj_2_50(2147483647)) {
    5667               EnumDeclaration(modifiers);
    5668             } else {
    5669               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    5670               case AT:
    5671                 AnnotationTypeDeclaration(modifiers);
    5672                 break;
    5673               case BOOLEAN:
    5674               case BYTE:
    5675               case CHAR:
    5676               case DOUBLE:
    5677               case FLOAT:
    5678               case INT:
    5679               case LONG:
    5680               case SHORT:
    5681               case IDENTIFIER:
    5682                 FieldDeclaration(modifiers);
    5683                 break;
    5684               default:
    5685                 jj_la1[131] = jj_gen;
    5686                 jj_consume_token(-1);
    5687                 throw new ParseException();
    5688               }
    5689             }
    5690           }
    5691         }
    5692         break;
    5693       case SEMICOLON:
    5694         jj_consume_token(SEMICOLON);
    5695         break;
    5696       default:
    5697         jj_la1[132] = jj_gen;
    5698         jj_consume_token(-1);
    5699         throw new ParseException();
    5700       }
    5701     } catch (Throwable jjte000) {
    5702    if (jjtc000) {
    5703      jjtree.clearNodeScope(jjtn000);
    5704      jjtc000 = false;
    5705    } else {
    5706      jjtree.popNode();
    5707    }
    5708    if (jjte000 instanceof RuntimeException) {
    5709      {if (true) throw (RuntimeException)jjte000;}
    5710    }
    5711    if (jjte000 instanceof ParseException) {
    5712      {if (true) throw (ParseException)jjte000;}
    5713    }
    5714    {if (true) throw (Error)jjte000;}
    5715     } finally {
    5716    if (jjtc000) {
    5717      jjtree.closeNodeScope(jjtn000, true);
    5718    }
    5719     }
    5720   }
    5721
    5722   final public void DefaultValue() throws ParseException {
    5723  /*@bgen(jjtree) DefaultValue */
    5724   ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
    5725   boolean jjtc000 = true;
    5726   jjtree.openNodeScope(jjtn000);
    5727     try {
    5728       jj_consume_token(_DEFAULT);
    5729       MemberValue();
    5730     } catch (Throwable jjte000) {
    5731     if (jjtc000) {
    5732       jjtree.clearNodeScope(jjtn000);
    5733       jjtc000 = false;
    5734     } else {
    5735       jjtree.popNode();
    5736     }
    5737     if (jjte000 instanceof RuntimeException) {
    5738       {if (true) throw (RuntimeException)jjte000;}
    5739     }
    5740     if (jjte000 instanceof ParseException) {
    5741       {if (true) throw (ParseException)jjte000;}
    5742     }
    5743     {if (true) throw (Error)jjte000;}
    5744     } finally {
    5745     if (jjtc000) {
    5746       jjtree.closeNodeScope(jjtn000, true);
    5747     }
    5748     }
    5749   }
    5750
    5751   final private boolean jj_2_1(int xla) {
    5752     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5753     try { return !jj_3_1(); }
    5754     catch(LookaheadSuccess ls) { return true; }
    5755     finally { jj_save(0, xla); }
    5756   }
    5757
    5758   final private boolean jj_2_2(int xla) {
    5759     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5760     try { return !jj_3_2(); }
    5761     catch(LookaheadSuccess ls) { return true; }
    5762     finally { jj_save(1, xla); }
    5763   }
    5764
    5765   final private boolean jj_2_3(int xla) {
    5766     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5767     try { return !jj_3_3(); }
    5768     catch(LookaheadSuccess ls) { return true; }
    5769     finally { jj_save(2, xla); }
    5770   }
    5771
    5772   final private boolean jj_2_4(int xla) {
    5773     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5774     try { return !jj_3_4(); }
    5775     catch(LookaheadSuccess ls) { return true; }
    5776     finally { jj_save(3, xla); }
    5777   }
    5778
    5779   final private boolean jj_2_5(int xla) {
    5780     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5781     try { return !jj_3_5(); }
    5782     catch(LookaheadSuccess ls) { return true; }
    5783     finally { jj_save(4, xla); }
    5784   }
    5785
    5786   final private boolean jj_2_6(int xla) {
    5787     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5788     try { return !jj_3_6(); }
    5789     catch(LookaheadSuccess ls) { return true; }
    5790     finally { jj_save(5, xla); }
    5791   }
    5792
    5793   final private boolean jj_2_7(int xla) {
    5794     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5795     try { return !jj_3_7(); }
    5796     catch(LookaheadSuccess ls) { return true; }
    5797     finally { jj_save(6, xla); }
    5798   }
    5799
    5800   final private boolean jj_2_8(int xla) {
    5801     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5802     try { return !jj_3_8(); }
    5803     catch(LookaheadSuccess ls) { return true; }
    5804     finally { jj_save(7, xla); }
    5805   }
    5806
    5807   final private boolean jj_2_9(int xla) {
    5808     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5809     try { return !jj_3_9(); }
    5810     catch(LookaheadSuccess ls) { return true; }
    5811     finally { jj_save(8, xla); }
    5812   }
    5813
    5814   final private boolean jj_2_10(int xla) {
    5815     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5816     try { return !jj_3_10(); }
    5817     catch(LookaheadSuccess ls) { return true; }
    5818     finally { jj_save(9, xla); }
    5819   }
    5820
    5821   final private boolean jj_2_11(int xla) {
    5822     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5823     try { return !jj_3_11(); }
    5824     catch(LookaheadSuccess ls) { return true; }
    5825     finally { jj_save(10, xla); }
    5826   }
    5827
    5828   final private boolean jj_2_12(int xla) {
    5829     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5830     try { return !jj_3_12(); }
    5831     catch(LookaheadSuccess ls) { return true; }
    5832     finally { jj_save(11, xla); }
    5833   }
    5834
    5835   final private boolean jj_2_13(int xla) {
    5836     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5837     try { return !jj_3_13(); }
    5838     catch(LookaheadSuccess ls) { return true; }
    5839     finally { jj_save(12, xla); }
    5840   }
    5841
    5842   final private boolean jj_2_14(int xla) {
    5843     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5844     try { return !jj_3_14(); }
    5845     catch(LookaheadSuccess ls) { return true; }
    5846     finally { jj_save(13, xla); }
    5847   }
    5848
    5849   final private boolean jj_2_15(int xla) {
    5850     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5851     try { return !jj_3_15(); }
    5852     catch(LookaheadSuccess ls) { return true; }
    5853     finally { jj_save(14, xla); }
    5854   }
    5855
    5856   final private boolean jj_2_16(int xla) {
    5857     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5858     try { return !jj_3_16(); }
    5859     catch(LookaheadSuccess ls) { return true; }
    5860     finally { jj_save(15, xla); }
    5861   }
    5862
    5863   final private boolean jj_2_17(int xla) {
    5864     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5865     try { return !jj_3_17(); }
    5866     catch(LookaheadSuccess ls) { return true; }
    5867     finally { jj_save(16, xla); }
    5868   }
    5869
    5870   final private boolean jj_2_18(int xla) {
    5871     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5872     try { return !jj_3_18(); }
    5873     catch(LookaheadSuccess ls) { return true; }
    5874     finally { jj_save(17, xla); }
    5875   }
    5876
    5877   final private boolean jj_2_19(int xla) {
    5878     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5879     try { return !jj_3_19(); }
    5880     catch(LookaheadSuccess ls) { return true; }
    5881     finally { jj_save(18, xla); }
    5882   }
    5883
    5884   final private boolean jj_2_20(int xla) {
    5885     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5886     try { return !jj_3_20(); }
    5887     catch(LookaheadSuccess ls) { return true; }
    5888     finally { jj_save(19, xla); }
    5889   }
    5890
    5891   final private boolean jj_2_21(int xla) {
    5892     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5893     try { return !jj_3_21(); }
    5894     catch(LookaheadSuccess ls) { return true; }
    5895     finally { jj_save(20, xla); }
    5896   }
    5897
    5898   final private boolean jj_2_22(int xla) {
    5899     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5900     try { return !jj_3_22(); }
    5901     catch(LookaheadSuccess ls) { return true; }
    5902     finally { jj_save(21, xla); }
    5903   }
    5904
    5905   final private boolean jj_2_23(int xla) {
    5906     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5907     try { return !jj_3_23(); }
    5908     catch(LookaheadSuccess ls) { return true; }
    5909     finally { jj_save(22, xla); }
    5910   }
    5911
    5912   final private boolean jj_2_24(int xla) {
    5913     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5914     try { return !jj_3_24(); }
    5915     catch(LookaheadSuccess ls) { return true; }
    5916     finally { jj_save(23, xla); }
    5917   }
    5918
    5919   final private boolean jj_2_25(int xla) {
    5920     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5921     try { return !jj_3_25(); }
    5922     catch(LookaheadSuccess ls) { return true; }
    5923     finally { jj_save(24, xla); }
    5924   }
    5925
    5926   final private boolean jj_2_26(int xla) {
    5927     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5928     try { return !jj_3_26(); }
    5929     catch(LookaheadSuccess ls) { return true; }
    5930     finally { jj_save(25, xla); }
    5931   }
    5932
    5933   final private boolean jj_2_27(int xla) {
    5934     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5935     try { return !jj_3_27(); }
    5936     catch(LookaheadSuccess ls) { return true; }
    5937     finally { jj_save(26, xla); }
    5938   }
    5939
    5940   final private boolean jj_2_28(int xla) {
    5941     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5942     try { return !jj_3_28(); }
    5943     catch(LookaheadSuccess ls) { return true; }
    5944     finally { jj_save(27, xla); }
    5945   }
    5946
    5947   final private boolean jj_2_29(int xla) {
    5948     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5949     try { return !jj_3_29(); }
    5950     catch(LookaheadSuccess ls) { return true; }
    5951     finally { jj_save(28, xla); }
    5952   }
    5953
    5954   final private boolean jj_2_30(int xla) {
    5955     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5956     try { return !jj_3_30(); }
    5957     catch(LookaheadSuccess ls) { return true; }
    5958     finally { jj_save(29, xla); }
    5959   }
    5960
    5961   final private boolean jj_2_31(int xla) {
    5962     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5963     try { return !jj_3_31(); }
    5964     catch(LookaheadSuccess ls) { return true; }
    5965     finally { jj_save(30, xla); }
    5966   }
    5967
    5968   final private boolean jj_2_32(int xla) {
    5969     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5970     try { return !jj_3_32(); }
    5971     catch(LookaheadSuccess ls) { return true; }
    5972     finally { jj_save(31, xla); }
    5973   }
    5974
    5975   final private boolean jj_2_33(int xla) {
    5976     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5977     try { return !jj_3_33(); }
    5978     catch(LookaheadSuccess ls) { return true; }
    5979     finally { jj_save(32, xla); }
    5980   }
    5981
    5982   final private boolean jj_2_34(int xla) {
    5983     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5984     try { return !jj_3_34(); }
    5985     catch(LookaheadSuccess ls) { return true; }
    5986     finally { jj_save(33, xla); }
    5987   }
    5988
    5989   final private boolean jj_2_35(int xla) {
    5990     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5991     try { return !jj_3_35(); }
    5992     catch(LookaheadSuccess ls) { return true; }
    5993     finally { jj_save(34, xla); }
    5994   }
    5995
    5996   final private boolean jj_2_36(int xla) {
    5997     jj_la = xla; jj_lastpos = jj_scanpos = token;
    5998     try { return !jj_3_36(); }
    5999     catch(LookaheadSuccess ls) { return true; }
    6000     finally { jj_save(35, xla); }
    6001   }
    6002
    6003   final private boolean jj_2_37(int xla) {
    6004     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6005     try { return !jj_3_37(); }
    6006     catch(LookaheadSuccess ls) { return true; }
    6007     finally { jj_save(36, xla); }
    6008   }
    6009
    6010   final private boolean jj_2_38(int xla) {
    6011     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6012     try { return !jj_3_38(); }
    6013     catch(LookaheadSuccess ls) { return true; }
    6014     finally { jj_save(37, xla); }
    6015   }
    6016
    6017   final private boolean jj_2_39(int xla) {
    6018     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6019     try { return !jj_3_39(); }
    6020     catch(LookaheadSuccess ls) { return true; }
    6021     finally { jj_save(38, xla); }
    6022   }
    6023
    6024   final private boolean jj_2_40(int xla) {
    6025     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6026     try { return !jj_3_40(); }
    6027     catch(LookaheadSuccess ls) { return true; }
    6028     finally { jj_save(39, xla); }
    6029   }
    6030
    6031   final private boolean jj_2_41(int xla) {
    6032     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6033     try { return !jj_3_41(); }
    6034     catch(LookaheadSuccess ls) { return true; }
    6035     finally { jj_save(40, xla); }
    6036   }
    6037
    6038   final private boolean jj_2_42(int xla) {
    6039     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6040     try { return !jj_3_42(); }
    6041     catch(LookaheadSuccess ls) { return true; }
    6042     finally { jj_save(41, xla); }
    6043   }
    6044
    6045   final private boolean jj_2_43(int xla) {
    6046     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6047     try { return !jj_3_43(); }
    6048     catch(LookaheadSuccess ls) { return true; }
    6049     finally { jj_save(42, xla); }
    6050   }
    6051
    6052   final private boolean jj_2_44(int xla) {
    6053     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6054     try { return !jj_3_44(); }
    6055     catch(LookaheadSuccess ls) { return true; }
    6056     finally { jj_save(43, xla); }
    6057   }
    6058
    6059   final private boolean jj_2_45(int xla) {
    6060     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6061     try { return !jj_3_45(); }
    6062     catch(LookaheadSuccess ls) { return true; }
    6063     finally { jj_save(44, xla); }
    6064   }
    6065
    6066   final private boolean jj_2_46(int xla) {
    6067     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6068     try { return !jj_3_46(); }
    6069     catch(LookaheadSuccess ls) { return true; }
    6070     finally { jj_save(45, xla); }
    6071   }
    6072
    6073   final private boolean jj_2_47(int xla) {
    6074     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6075     try { return !jj_3_47(); }
    6076     catch(LookaheadSuccess ls) { return true; }
    6077     finally { jj_save(46, xla); }
    6078   }
    6079
    6080   final private boolean jj_2_48(int xla) {
    6081     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6082     try { return !jj_3_48(); }
    6083     catch(LookaheadSuccess ls) { return true; }
    6084     finally { jj_save(47, xla); }
    6085   }
    6086
    6087   final private boolean jj_2_49(int xla) {
    6088     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6089     try { return !jj_3_49(); }
    6090     catch(LookaheadSuccess ls) { return true; }
    6091     finally { jj_save(48, xla); }
    6092   }
    6093
    6094   final private boolean jj_2_50(int xla) {
    6095     jj_la = xla; jj_lastpos = jj_scanpos = token;
    6096     try { return !jj_3_50(); }
    6097     catch(LookaheadSuccess ls) { return true; }
    6098     finally { jj_save(49, xla); }
    6099   }
    6100
    6101   final private boolean jj_3R_309() {
    6102     if (jj_scan_token(PLUS)) return true;
    6103     return false;
    6104   }
    6105
    6106   final private boolean jj_3R_297() {
    6107     Token xsp;
    6108     xsp = jj_scanpos;
    6109     if (jj_3R_309()) {
    6110     jj_scanpos = xsp;
    6111     if (jj_3R_310()) return true;
    6112     }
    6113     if (jj_3R_282()) return true;
    6114     return false;
    6115   }
    6116
    6117   final private boolean jj_3R_282() {
    6118     Token xsp;
    6119     xsp = jj_scanpos;
    6120     if (jj_3R_297()) {
    6121     jj_scanpos = xsp;
    6122     if (jj_3R_298()) {
    6123     jj_scanpos = xsp;
    6124     if (jj_3R_299()) {
    6125     jj_scanpos = xsp;
    6126     if (jj_3R_300()) return true;
    6127     }
    6128     }
    6129     }
    6130     return false;
    6131   }
    6132
    6133   final private boolean jj_3R_276() {
    6134     if (jj_3R_282()) return true;
    6135     Token xsp;
    6136     while (true) {
    6137       xsp = jj_scanpos;
    6138       if (jj_3R_319()) { jj_scanpos = xsp; break; }
    6139     }
    6140     return false;
    6141   }
    6142
    6143   final private boolean jj_3R_268() {
    6144     if (jj_3R_276()) return true;
    6145     Token xsp;
    6146     while (true) {
    6147       xsp = jj_scanpos;
    6148       if (jj_3R_308()) { jj_scanpos = xsp; break; }
    6149     }
    6150     return false;
    6151   }
    6152
    6153   final private boolean jj_3_22() {
    6154     if (jj_3R_76()) return true;
    6155     return false;
    6156   }
    6157
    6158   final private boolean jj_3_21() {
    6159     if (jj_3R_75()) return true;
    6160     return false;
    6161   }
    6162
    6163   final private boolean jj_3R_273() {
    6164     if (jj_scan_token(INSTANCEOF)) return true;
    6165     if (jj_3R_65()) return true;
    6166     return false;
    6167   }
    6168
    6169   final private boolean jj_3R_74() {
    6170     if (jj_scan_token(LSHIFT)) return true;
    6171     return false;
    6172   }
    6173
    6174   final private boolean jj_3_20() {
    6175     Token xsp;
    6176     xsp = jj_scanpos;
    6177     if (jj_3R_74()) {
    6178     jj_scanpos = xsp;
    6179     if (jj_3_21()) {
    6180     jj_scanpos = xsp;
    6181     if (jj_3_22()) return true;
    6182     }
    6183     }
    6184     if (jj_3R_268()) return true;
    6185     return false;
    6186   }
    6187
    6188   final private boolean jj_3R_274() {
    6189     if (jj_scan_token(EQ)) return true;
    6190     return false;
    6191   }
    6192
    6193   final private boolean jj_3R_267() {
    6194     Token xsp;
    6195     xsp = jj_scanpos;
    6196     if (jj_3R_274()) {
    6197     jj_scanpos = xsp;
    6198     if (jj_3R_275()) return true;
    6199     }
    6200     if (jj_3R_253()) return true;
    6201     return false;
    6202   }
    6203
    6204   final private boolean jj_3R_262() {
    6205     if (jj_3R_268()) return true;
    6206     Token xsp;
    6207     while (true) {
    6208       xsp = jj_scanpos;
    6209       if (jj_3_20()) { jj_scanpos = xsp; break; }
    6210     }
    6211     return false;
    6212   }
    6213
    6214   final private boolean jj_3R_296() {
    6215     if (jj_scan_token(GE)) return true;
    6216     return false;
    6217   }
    6218
    6219   final private boolean jj_3R_295() {
    6220     if (jj_scan_token(LE)) return true;
    6221     return false;
    6222   }
    6223
    6224   final private boolean jj_3R_294() {
    6225     if (jj_scan_token(GT)) return true;
    6226     return false;
    6227   }
    6228
    6229   final private boolean jj_3R_293() {
    6230     if (jj_scan_token(LT)) return true;
    6231     return false;
    6232   }
    6233
    6234   final private boolean jj_3R_261() {
    6235     if (jj_scan_token(BIT_AND)) return true;
    6236     if (jj_3R_248()) return true;
    6237     return false;
    6238   }
    6239
    6240   final private boolean jj_3R_281() {
    6241     Token xsp;
    6242     xsp = jj_scanpos;
    6243     if (jj_3R_293()) {
    6244     jj_scanpos = xsp;
    6245     if (jj_3R_294()) {
    6246     jj_scanpos = xsp;
    6247     if (jj_3R_295()) {
    6248     jj_scanpos = xsp;
    6249     if (jj_3R_296()) return true;
    6250     }
    6251     }
    6252     }
    6253     if (jj_3R_262()) return true;
    6254     return false;
    6255   }
    6256
    6257   final private boolean jj_3R_258() {
    6258     if (jj_3R_262()) return true;
    6259     Token xsp;
    6260     while (true) {
    6261       xsp = jj_scanpos;
    6262       if (jj_3R_281()) { jj_scanpos = xsp; break; }
    6263     }
    6264     return false;
    6265   }
    6266
    6267   final private boolean jj_3R_252() {
    6268     if (jj_scan_token(BIT_OR)) return true;
    6269     if (jj_3R_222()) return true;
    6270     return false;
    6271   }
    6272
    6273   final private boolean jj_3R_257() {
    6274     if (jj_scan_token(XOR)) return true;
    6275     if (jj_3R_242()) return true;
    6276     return false;
    6277   }
    6278
    6279   final private boolean jj_3R_253() {
    6280     if (jj_3R_258()) return true;
    6281     Token xsp;
    6282     xsp = jj_scanpos;
    6283     if (jj_3R_273()) jj_scanpos = xsp;
    6284     return false;
    6285   }
    6286
    6287   final private boolean jj_3R_247() {
    6288     if (jj_scan_token(SC_AND)) return true;
    6289     if (jj_3R_213()) return true;
    6290     return false;
    6291   }
    6292
    6293   final private boolean jj_3R_248() {
    6294     if (jj_3R_253()) return true;
    6295     Token xsp;
    6296     while (true) {
    6297       xsp = jj_scanpos;
    6298       if (jj_3R_267()) { jj_scanpos = xsp; break; }
    6299     }
    6300     return false;
    6301   }
    6302
    6303   final private boolean jj_3R_229() {
    6304     if (jj_scan_token(SC_OR)) return true;
    6305     if (jj_3R_198()) return true;
    6306     return false;
    6307   }
    6308
    6309   final private boolean jj_3R_242() {
    6310     if (jj_3R_248()) return true;
    6311     Token xsp;
    6312     while (true) {
    6313       xsp = jj_scanpos;
    6314       if (jj_3R_261()) { jj_scanpos = xsp; break; }
    6315     }
    6316     return false;
    6317   }
    6318
    6319   final private boolean jj_3R_220() {
    6320     if (jj_scan_token(HOOK)) return true;
    6321     if (jj_3R_83()) return true;
    6322     if (jj_scan_token(COLON)) return true;
    6323     if (jj_3R_132()) return true;
    6324     return false;
    6325   }
    6326
    6327   final private boolean jj_3R_222() {
    6328     if (jj_3R_242()) return true;
    6329     Token xsp;
    6330     while (true) {
    6331       xsp = jj_scanpos;
    6332       if (jj_3R_257()) { jj_scanpos = xsp; break; }
    6333     }
    6334     return false;
    6335   }
    6336
    6337   final private boolean jj_3R_213() {
    6338     if (jj_3R_222()) return true;
    6339     Token xsp;
    6340     while (true) {
    6341       xsp = jj_scanpos;
    6342       if (jj_3R_252()) { jj_scanpos = xsp; break; }
    6343     }
    6344     return false;
    6345   }
    6346
    6347   final private boolean jj_3R_198() {
    6348     if (jj_3R_213()) return true;
    6349     Token xsp;
    6350     while (true) {
    6351       xsp = jj_scanpos;
    6352       if (jj_3R_247()) { jj_scanpos = xsp; break; }
    6353     }
    6354     return false;
    6355   }
    6356
    6357   final private boolean jj_3R_175() {
    6358     if (jj_3R_198()) return true;
    6359     Token xsp;
    6360     while (true) {
    6361       xsp = jj_scanpos;
    6362       if (jj_3R_229()) { jj_scanpos = xsp; break; }
    6363     }
    6364     return false;
    6365   }
    6366
    6367   final private boolean jj_3R_132() {
    6368     if (jj_3R_175()) return true;
    6369     Token xsp;
    6370     xsp = jj_scanpos;
    6371     if (jj_3R_220()) jj_scanpos = xsp;
    6372     return false;
    6373   }
    6374
    6375   final private boolean jj_3R_241() {
    6376     if (jj_scan_token(ORASSIGN)) return true;
    6377     return false;
    6378   }
    6379
    6380   final private boolean jj_3R_240() {
    6381     if (jj_scan_token(XORASSIGN)) return true;
    6382     return false;
    6383   }
    6384
    6385   final private boolean jj_3R_239() {
    6386     if (jj_scan_token(ANDASSIGN)) return true;
    6387     return false;
    6388   }
    6389
    6390   final private boolean jj_3R_238() {
    6391     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
    6392     return false;
    6393   }
    6394
    6395   final private boolean jj_3R_237() {
    6396     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
    6397     return false;
    6398   }
    6399
    6400   final private boolean jj_3R_236() {
    6401     if (jj_scan_token(LSHIFTASSIGN)) return true;
    6402     return false;
    6403   }
    6404
    6405   final private boolean jj_3R_235() {
    6406     if (jj_scan_token(MINUSASSIGN)) return true;
    6407     return false;
    6408   }
    6409
    6410   final private boolean jj_3R_234() {
    6411     if (jj_scan_token(PLUSASSIGN)) return true;
    6412     return false;
    6413   }
    6414
    6415   final private boolean jj_3R_233() {
    6416     if (jj_scan_token(REMASSIGN)) return true;
    6417     return false;
    6418   }
    6419
    6420   final private boolean jj_3R_232() {
    6421     if (jj_scan_token(SLASHASSIGN)) return true;
    6422     return false;
    6423   }
    6424
    6425   final private boolean jj_3R_231() {
    6426     if (jj_scan_token(STARASSIGN)) return true;
    6427     return false;
    6428   }
    6429
    6430   final private boolean jj_3R_221() {
    6431     Token xsp;
    6432     xsp = jj_scanpos;
    6433     if (jj_3R_230()) {
    6434     jj_scanpos = xsp;
    6435     if (jj_3R_231()) {
    6436     jj_scanpos = xsp;
    6437     if (jj_3R_232()) {
    6438     jj_scanpos = xsp;
    6439     if (jj_3R_233()) {
    6440     jj_scanpos = xsp;
    6441     if (jj_3R_234()) {
    6442     jj_scanpos = xsp;
    6443     if (jj_3R_235()) {
    6444     jj_scanpos = xsp;
    6445     if (jj_3R_236()) {
    6446     jj_scanpos = xsp;
    6447     if (jj_3R_237()) {
    6448     jj_scanpos = xsp;
    6449     if (jj_3R_238()) {
    6450     jj_scanpos = xsp;
    6451     if (jj_3R_239()) {
    6452     jj_scanpos = xsp;
    6453     if (jj_3R_240()) {
    6454     jj_scanpos = xsp;
    6455     if (jj_3R_241()) return true;
    6456     }
    6457     }
    6458     }
    6459     }
    6460     }
    6461     }
    6462     }
    6463     }
    6464     }
    6465     }
    6466     }
    6467     return false;
    6468   }
    6469
    6470   final private boolean jj_3R_230() {
    6471     if (jj_scan_token(ASSIGN)) return true;
    6472     return false;
    6473   }
    6474
    6475   final private boolean jj_3R_212() {
    6476     if (jj_3R_221()) return true;
    6477     if (jj_3R_83()) return true;
    6478     return false;
    6479   }
    6480
    6481   final private boolean jj_3R_83() {
    6482     if (jj_3R_132()) return true;
    6483     Token xsp;
    6484     xsp = jj_scanpos;
    6485     if (jj_3R_212()) jj_scanpos = xsp;
    6486     return false;
    6487   }
    6488
    6489   final private boolean jj_3R_317() {
    6490     if (jj_scan_token(COMMA)) return true;
    6491     if (jj_3R_89()) return true;
    6492     return false;
    6493   }
    6494
    6495   final private boolean jj_3R_304() {
    6496     if (jj_3R_89()) return true;
    6497     Token xsp;
    6498     while (true) {
    6499       xsp = jj_scanpos;
    6500       if (jj_3R_317()) { jj_scanpos = xsp; break; }
    6501     }
    6502     return false;
    6503   }
    6504
    6505   final private boolean jj_3_18() {
    6506     if (jj_3R_73()) return true;
    6507     return false;
    6508   }
    6509
    6510   final private boolean jj_3_19() {
    6511     if (jj_scan_token(DOT)) return true;
    6512     if (jj_scan_token(IDENTIFIER)) return true;
    6513     return false;
    6514   }
    6515
    6516   final private boolean jj_3R_89() {
    6517     if (jj_scan_token(IDENTIFIER)) return true;
    6518     Token xsp;
    6519     while (true) {
    6520       xsp = jj_scanpos;
    6521       if (jj_3_19()) { jj_scanpos = xsp; break; }
    6522     }
    6523     return false;
    6524   }
    6525
    6526   final private boolean jj_3R_130() {
    6527     if (jj_3R_65()) return true;
    6528     return false;
    6529   }
    6530
    6531   final private boolean jj_3R_80() {
    6532     Token xsp;
    6533     xsp = jj_scanpos;
    6534     if (jj_scan_token(59)) {
    6535     jj_scanpos = xsp;
    6536     if (jj_3R_130()) return true;
    6537     }
    6538     return false;
    6539   }
    6540
    6541   final private boolean jj_3R_126() {
    6542     if (jj_scan_token(DOUBLE)) return true;
    6543     return false;
    6544   }
    6545
    6546   final private boolean jj_3R_125() {
    6547     if (jj_scan_token(FLOAT)) return true;
    6548     return false;
    6549   }
    6550
    6551   final private boolean jj_3R_124() {
    6552     if (jj_scan_token(LONG)) return true;
    6553     return false;
    6554   }
    6555
    6556   final private boolean jj_3R_123() {
    6557     if (jj_scan_token(INT)) return true;
    6558     return false;
    6559   }
    6560
    6561   final private boolean jj_3R_122() {
    6562     if (jj_scan_token(SHORT)) return true;
    6563     return false;
    6564   }
    6565
    6566   final private boolean jj_3R_121() {
    6567     if (jj_scan_token(BYTE)) return true;
    6568     return false;
    6569   }
    6570
    6571   final private boolean jj_3R_120() {
    6572     if (jj_scan_token(CHAR)) return true;
    6573     return false;
    6574   }
    6575
    6576   final private boolean jj_3R_119() {
    6577     if (jj_scan_token(BOOLEAN)) return true;
    6578     return false;
    6579   }
    6580
    6581   final private boolean jj_3R_78() {
    6582     Token xsp;
    6583     xsp = jj_scanpos;
    6584     if (jj_3R_119()) {
    6585     jj_scanpos = xsp;
    6586     if (jj_3R_120()) {
    6587     jj_scanpos = xsp;
    6588     if (jj_3R_121()) {
    6589     jj_scanpos = xsp;
    6590     if (jj_3R_122()) {
    6591     jj_scanpos = xsp;
    6592     if (jj_3R_123()) {
    6593     jj_scanpos = xsp;
    6594     if (jj_3R_124()) {
    6595     jj_scanpos = xsp;
    6596     if (jj_3R_125()) {
    6597     jj_scanpos = xsp;
    6598     if (jj_3R_126()) return true;
    6599     }
    6600     }
    6601     }
    6602     }
    6603     }
    6604     }
    6605     }
    6606     return false;
    6607   }
    6608
    6609   final private boolean jj_3R_246() {
    6610     if (jj_scan_token(COMMA)) return true;
    6611     if (jj_3R_114()) return true;
    6612     return false;
    6613   }
    6614
    6615   final private boolean jj_3R_266() {
    6616     if (jj_scan_token(SUPER)) return true;
    6617     if (jj_3R_72()) return true;
    6618     return false;
    6619   }
    6620
    6621   final private boolean jj_3R_256() {
    6622     if (jj_3R_260()) return true;
    6623     return false;
    6624   }
    6625
    6626   final private boolean jj_3R_260() {
    6627     Token xsp;
    6628     xsp = jj_scanpos;
    6629     if (jj_3R_265()) {
    6630     jj_scanpos = xsp;
    6631     if (jj_3R_266()) return true;
    6632     }
    6633     return false;
    6634   }
    6635
    6636   final private boolean jj_3R_265() {
    6637     if (jj_scan_token(EXTENDS)) return true;
    6638     if (jj_3R_72()) return true;
    6639     return false;
    6640   }
    6641
    6642   final private boolean jj_3_15() {
    6643     if (jj_scan_token(LBRACKET)) return true;
    6644     if (jj_scan_token(RBRACKET)) return true;
    6645     return false;
    6646   }
    6647
    6648   final private boolean jj_3R_173() {
    6649     if (jj_scan_token(HOOK)) return true;
    6650     Token xsp;
    6651     xsp = jj_scanpos;
    6652     if (jj_3R_256()) jj_scanpos = xsp;
    6653     return false;
    6654   }
    6655
    6656   final private boolean jj_3R_114() {
    6657     Token xsp;
    6658     xsp = jj_scanpos;
    6659     if (jj_3R_172()) {
    6660     jj_scanpos = xsp;
    6661     if (jj_3R_173()) return true;
    6662     }
    6663     return false;
    6664   }
    6665
    6666   final private boolean jj_3R_172() {
    6667     if (jj_3R_72()) return true;
    6668     return false;
    6669   }
    6670
    6671   final private boolean jj_3R_73() {
    6672     if (jj_scan_token(LT)) return true;
    6673     if (jj_3R_114()) return true;
    6674     Token xsp;
    6675     while (true) {
    6676       xsp = jj_scanpos;
    6677       if (jj_3R_246()) { jj_scanpos = xsp; break; }
    6678     }
    6679     if (jj_scan_token(GT)) return true;
    6680     return false;
    6681   }
    6682
    6683   final private boolean jj_3_14() {
    6684     if (jj_scan_token(LBRACKET)) return true;
    6685     if (jj_scan_token(RBRACKET)) return true;
    6686     return false;
    6687   }
    6688
    6689   final private boolean jj_3_17() {
    6690     if (jj_scan_token(DOT)) return true;
    6691     if (jj_scan_token(IDENTIFIER)) return true;
    6692     Token xsp;
    6693     xsp = jj_scanpos;
    6694     if (jj_3_18()) jj_scanpos = xsp;
    6695     return false;
    6696   }
    6697
    6698   final private boolean jj_3_16() {
    6699     if (jj_3R_73()) return true;
    6700     return false;
    6701   }
    6702
    6703   final private boolean jj_3R_171() {
    6704     if (jj_scan_token(IDENTIFIER)) return true;
    6705     Token xsp;
    6706     xsp = jj_scanpos;
    6707     if (jj_3_16()) jj_scanpos = xsp;
    6708     while (true) {
    6709       xsp = jj_scanpos;
    6710       if (jj_3_17()) { jj_scanpos = xsp; break; }
    6711     }
    6712     return false;
    6713   }
    6714
    6715   final private boolean jj_3R_113() {
    6716     if (jj_3R_171()) return true;
    6717     Token xsp;
    6718     while (true) {
    6719       xsp = jj_scanpos;
    6720       if (jj_3_15()) { jj_scanpos = xsp; break; }
    6721     }
    6722     return false;
    6723   }
    6724
    6725   final private boolean jj_3R_112() {
    6726     if (jj_3R_78()) return true;
    6727     Token xsp;
    6728     if (jj_3_14()) return true;
    6729     while (true) {
    6730       xsp = jj_scanpos;
    6731       if (jj_3_14()) { jj_scanpos = xsp; break; }
    6732     }
    6733     return false;
    6734   }
    6735
    6736   final private boolean jj_3R_72() {
    6737     Token xsp;
    6738     xsp = jj_scanpos;
    6739     if (jj_3R_112()) {
    6740     jj_scanpos = xsp;
    6741     if (jj_3R_113()) return true;
    6742     }
    6743     return false;
    6744   }
    6745
    6746   final private boolean jj_3R_285() {
    6747     if (jj_scan_token(THROWS)) return true;
    6748     if (jj_3R_304()) return true;
    6749     return false;
    6750   }
    6751
    6752   final private boolean jj_3R_102() {
    6753     if (jj_3R_78()) return true;
    6754     return false;
    6755   }
    6756
    6757   final private boolean jj_3_13() {
    6758     if (jj_3R_72()) return true;
    6759     return false;
    6760   }
    6761
    6762   final private boolean jj_3R_65() {
    6763     Token xsp;
    6764     xsp = jj_scanpos;
    6765     if (jj_3_13()) {
    6766     jj_scanpos = xsp;
    6767     if (jj_3R_102()) return true;
    6768     }
    6769     return false;
    6770   }
    6771
    6772   final private boolean jj_3R_338() {
    6773     if (jj_3R_92()) return true;
    6774     return false;
    6775   }
    6776
    6777   final private boolean jj_3_12() {
    6778     if (jj_scan_token(THIS)) return true;
    6779     if (jj_3R_71()) return true;
    6780     if (jj_scan_token(SEMICOLON)) return true;
    6781     return false;
    6782   }
    6783
    6784   final private boolean jj_3R_277() {
    6785     if (jj_scan_token(STATIC)) return true;
    6786     return false;
    6787   }
    6788
    6789   final private boolean jj_3R_269() {
    6790     Token xsp;
    6791     xsp = jj_scanpos;
    6792     if (jj_3R_277()) jj_scanpos = xsp;
    6793     if (jj_3R_176()) return true;
    6794     return false;
    6795   }
    6796
    6797   final private boolean jj_3_9() {
    6798     if (jj_3R_68()) return true;
    6799     return false;
    6800   }
    6801
    6802   final private boolean jj_3_11() {
    6803     if (jj_3R_70()) return true;
    6804     if (jj_scan_token(DOT)) return true;
    6805     if (jj_scan_token(SUPER)) return true;
    6806     if (jj_scan_token(LPAREN)) return true;
    6807     return false;
    6808   }
    6809
    6810   final private boolean jj_3R_106() {
    6811     Token xsp;
    6812     xsp = jj_scanpos;
    6813     if (jj_3_11()) jj_scanpos = xsp;
    6814     xsp = jj_scanpos;
    6815     if (jj_scan_token(50)) {
    6816     jj_scanpos = xsp;
    6817     if (jj_scan_token(53)) return true;
    6818     }
    6819     if (jj_3R_71()) return true;
    6820     if (jj_scan_token(SEMICOLON)) return true;
    6821     return false;
    6822   }
    6823
    6824   final private boolean jj_3R_105() {
    6825     if (jj_scan_token(THIS)) return true;
    6826     if (jj_3R_71()) return true;
    6827     if (jj_scan_token(SEMICOLON)) return true;
    6828     return false;
    6829   }
    6830
    6831   final private boolean jj_3R_68() {
    6832     Token xsp;
    6833     xsp = jj_scanpos;
    6834     if (jj_3R_105()) {
    6835     jj_scanpos = xsp;
    6836     if (jj_3R_106()) return true;
    6837     }
    6838     return false;
    6839   }
    6840
    6841   final private boolean jj_3R_316() {
    6842     if (jj_scan_token(COMMA)) return true;
    6843     if (jj_3R_315()) return true;
    6844     return false;
    6845   }
    6846
    6847   final private boolean jj_3_10() {
    6848     if (jj_3R_69()) return true;
    6849     return false;
    6850   }
    6851
    6852   final private boolean jj_3R_286() {
    6853     if (jj_3R_68()) return true;
    6854     return false;
    6855   }
    6856
    6857   final private boolean jj_3R_283() {
    6858     if (jj_3R_101()) return true;
    6859     return false;
    6860   }
    6861
    6862   final private boolean jj_3R_278() {
    6863     Token xsp;
    6864     xsp = jj_scanpos;
    6865     if (jj_3R_283()) jj_scanpos = xsp;
    6866     if (jj_scan_token(IDENTIFIER)) return true;
    6867     if (jj_3R_284()) return true;
    6868     xsp = jj_scanpos;
    6869     if (jj_3R_285()) jj_scanpos = xsp;
    6870     if (jj_scan_token(LBRACE)) return true;
    6871     xsp = jj_scanpos;
    6872     if (jj_3R_286()) jj_scanpos = xsp;
    6873     while (true) {
    6874       xsp = jj_scanpos;
    6875       if (jj_3_10()) { jj_scanpos = xsp; break; }
    6876     }
    6877     if (jj_scan_token(RBRACE)) return true;
    6878     return false;
    6879   }
    6880
    6881   final private boolean jj_3R_307() {
    6882     if (jj_scan_token(LBRACKET)) return true;
    6883     if (jj_scan_token(RBRACKET)) return true;
    6884     return false;
    6885   }
    6886
    6887   final private boolean jj_3R_291() {
    6888     if (jj_scan_token(THROWS)) return true;
    6889     if (jj_3R_304()) return true;
    6890     return false;
    6891   }
    6892
    6893   final private boolean jj_3R_328() {
    6894     if (jj_scan_token(ELLIPSIS)) return true;
    6895     return false;
    6896   }
    6897
    6898   final private boolean jj_3R_337() {
    6899     if (jj_scan_token(FINAL)) return true;
    6900     return false;
    6901   }
    6902
    6903   final private boolean jj_3R_327() {
    6904     Token xsp;
    6905     xsp = jj_scanpos;
    6906     if (jj_3R_337()) {
    6907     jj_scanpos = xsp;
    6908     if (jj_3R_338()) return true;
    6909     }
    6910     return false;
    6911   }
    6912
    6913   final private boolean jj_3R_315() {
    6914     Token xsp;
    6915     while (true) {
    6916       xsp = jj_scanpos;
    6917       if (jj_3R_327()) { jj_scanpos = xsp; break; }
    6918     }
    6919     if (jj_3R_65()) return true;
    6920     xsp = jj_scanpos;
    6921     if (jj_3R_328()) jj_scanpos = xsp;
    6922     if (jj_3R_305()) return true;
    6923     return false;
    6924   }
    6925
    6926   final private boolean jj_3R_303() {
    6927     if (jj_3R_315()) return true;
    6928     Token xsp;
    6929     while (true) {
    6930       xsp = jj_scanpos;
    6931       if (jj_3R_316()) { jj_scanpos = xsp; break; }
    6932     }
    6933     return false;
    6934   }
    6935
    6936   final private boolean jj_3_8() {
    6937     if (jj_scan_token(COMMA)) return true;
    6938     if (jj_3R_67()) return true;
    6939     return false;
    6940   }
    6941
    6942   final private boolean jj_3_50() {
    6943     if (jj_scan_token(IDENTIFIER)) return true;
    6944     if (jj_scan_token(IDENTIFIER)) return true;
    6945     return false;
    6946   }
    6947
    6948   final private boolean jj_3R_284() {
    6949     if (jj_scan_token(LPAREN)) return true;
    6950     Token xsp;
    6951     xsp = jj_scanpos;
    6952     if (jj_3R_303()) jj_scanpos = xsp;
    6953     if (jj_scan_token(RPAREN)) return true;
    6954     return false;
    6955   }
    6956
    6957   final private boolean jj_3_49() {
    6958     if (jj_3R_65()) return true;
    6959     if (jj_scan_token(IDENTIFIER)) return true;
    6960     if (jj_scan_token(LPAREN)) return true;
    6961     return false;
    6962   }
    6963
    6964   final private boolean jj_3R_290() {
    6965     if (jj_scan_token(IDENTIFIER)) return true;
    6966     if (jj_3R_284()) return true;
    6967     Token xsp;
    6968     while (true) {
    6969       xsp = jj_scanpos;
    6970       if (jj_3R_307()) { jj_scanpos = xsp; break; }
    6971     }
    6972     return false;
    6973   }
    6974
    6975   final private boolean jj_3R_292() {
    6976     if (jj_3R_176()) return true;
    6977     return false;
    6978   }
    6979
    6980   final private boolean jj_3R_289() {
    6981     if (jj_3R_101()) return true;
    6982     return false;
    6983   }
    6984
    6985   final private boolean jj_3R_254() {
    6986     if (jj_3R_67()) return true;
    6987     Token xsp;
    6988     while (true) {
    6989       xsp = jj_scanpos;
    6990       if (jj_3_8()) { jj_scanpos = xsp; break; }
    6991     }
    6992     return false;
    6993   }
    6994
    6995   final private boolean jj_3R_280() {
    6996     Token xsp;
    6997     xsp = jj_scanpos;
    6998     if (jj_3R_289()) jj_scanpos = xsp;
    6999     if (jj_3R_80()) return true;
    7000     if (jj_3R_290()) return true;
    7001     xsp = jj_scanpos;
    7002     if (jj_3R_291()) jj_scanpos = xsp;
    7003     xsp = jj_scanpos;
    7004     if (jj_3R_292()) {
    7005     jj_scanpos = xsp;
    7006     if (jj_scan_token(80)) return true;
    7007     }
    7008     return false;
    7009   }
    7010
    7011   final private boolean jj_3_48() {
    7012     if (jj_scan_token(COMMA)) return true;
    7013     if (jj_3R_91()) return true;
    7014     return false;
    7015   }
    7016
    7017   final private boolean jj_3R_306() {
    7018     if (jj_scan_token(ASSIGN)) return true;
    7019     if (jj_3R_67()) return true;
    7020     return false;
    7021   }
    7022
    7023   final private boolean jj_3R_160() {
    7024     if (jj_scan_token(LBRACE)) return true;
    7025     Token xsp;
    7026     xsp = jj_scanpos;
    7027     if (jj_3R_254()) jj_scanpos = xsp;
    7028     xsp = jj_scanpos;
    7029     if (jj_scan_token(81)) jj_scanpos = xsp;
    7030     if (jj_scan_token(RBRACE)) return true;
    7031     return false;
    7032   }
    7033
    7034   final private boolean jj_3R_288() {
    7035     if (jj_scan_token(COMMA)) return true;
    7036     if (jj_3R_287()) return true;
    7037     return false;
    7038   }
    7039
    7040   final private boolean jj_3R_66() {
    7041     if (jj_scan_token(LBRACKET)) return true;
    7042     if (jj_scan_token(RBRACKET)) return true;
    7043     return false;
    7044   }
    7045
    7046   final private boolean jj_3R_104() {
    7047     if (jj_3R_83()) return true;
    7048     return false;
    7049   }
    7050
    7051   final private boolean jj_3R_103() {
    7052     if (jj_3R_160()) return true;
    7053     return false;
    7054   }
    7055
    7056   final private boolean jj_3R_67() {
    7057     Token xsp;
    7058     xsp = jj_scanpos;
    7059     if (jj_3R_103()) {
    7060     jj_scanpos = xsp;
    7061     if (jj_3R_104()) return true;
    7062     }
    7063     return false;
    7064   }
    7065
    7066   final private boolean jj_3R_190() {
    7067     if (jj_scan_token(LBRACE)) return true;
    7068     if (jj_3R_91()) return true;
    7069     Token xsp;
    7070     while (true) {
    7071       xsp = jj_scanpos;
    7072       if (jj_3_48()) { jj_scanpos = xsp; break; }
    7073     }
    7074     xsp = jj_scanpos;
    7075     if (jj_scan_token(81)) jj_scanpos = xsp;
    7076     if (jj_scan_token(RBRACE)) return true;
    7077     return false;
    7078   }
    7079
    7080   final private boolean jj_3R_318() {
    7081     if (jj_scan_token(LBRACKET)) return true;
    7082     if (jj_scan_token(RBRACKET)) return true;
    7083     return false;
    7084   }
    7085
    7086   final private boolean jj_3R_250() {
    7087     if (jj_scan_token(COMMA)) return true;
    7088     if (jj_3R_249()) return true;
    7089     return false;
    7090   }
    7091
    7092   final private boolean jj_3R_305() {
    7093     if (jj_scan_token(IDENTIFIER)) return true;
    7094     Token xsp;
    7095     while (true) {
    7096       xsp = jj_scanpos;
    7097       if (jj_3R_318()) { jj_scanpos = xsp; break; }
    7098     }
    7099     return false;
    7100   }
    7101
    7102   final private boolean jj_3R_151() {
    7103     if (jj_3R_132()) return true;
    7104     return false;
    7105   }
    7106
    7107   final private boolean jj_3R_150() {
    7108     if (jj_3R_190()) return true;
    7109     return false;
    7110   }
    7111
    7112   final private boolean jj_3R_217() {
    7113     if (jj_scan_token(BIT_AND)) return true;
    7114     if (jj_3R_171()) return true;
    7115     return false;
    7116   }
    7117
    7118   final private boolean jj_3R_91() {
    7119     Token xsp;
    7120     xsp = jj_scanpos;
    7121     if (jj_3R_149()) {
    7122     jj_scanpos = xsp;
    7123     if (jj_3R_150()) {
    7124     jj_scanpos = xsp;
    7125     if (jj_3R_151()) return true;
    7126     }
    7127     }
    7128     return false;
    7129   }
    7130
    7131   final private boolean jj_3R_149() {
    7132     if (jj_3R_92()) return true;
    7133     return false;
    7134   }
    7135
    7136   final private boolean jj_3R_287() {
    7137     if (jj_3R_305()) return true;
    7138     Token xsp;
    7139     xsp = jj_scanpos;
    7140     if (jj_3R_306()) jj_scanpos = xsp;
    7141     return false;
    7142   }
    7143
    7144   final private boolean jj_3R_64() {
    7145     if (jj_3R_101()) return true;
    7146     return false;
    7147   }
    7148
    7149   final private boolean jj_3_6() {
    7150     if (jj_3R_65()) return true;
    7151     if (jj_scan_token(IDENTIFIER)) return true;
    7152     Token xsp;
    7153     while (true) {
    7154       xsp = jj_scanpos;
    7155       if (jj_3R_66()) { jj_scanpos = xsp; break; }
    7156     }
    7157     xsp = jj_scanpos;
    7158     if (jj_scan_token(81)) {
    7159     jj_scanpos = xsp;
    7160     if (jj_scan_token(84)) {
    7161     jj_scanpos = xsp;
    7162     if (jj_scan_token(80)) return true;
    7163     }
    7164     }
    7165     return false;
    7166   }
    7167
    7168   final private boolean jj_3_5() {
    7169     Token xsp;
    7170     xsp = jj_scanpos;
    7171     if (jj_3R_64()) jj_scanpos = xsp;
    7172     if (jj_scan_token(IDENTIFIER)) return true;
    7173     if (jj_scan_token(LPAREN)) return true;
    7174     return false;
    7175   }
    7176
    7177   final private boolean jj_3R_249() {
    7178     if (jj_scan_token(IDENTIFIER)) return true;
    7179     if (jj_scan_token(ASSIGN)) return true;
    7180     if (jj_3R_91()) return true;
    7181     return false;
    7182   }
    7183
    7184   final private boolean jj_3R_279() {
    7185     if (jj_3R_65()) return true;
    7186     if (jj_3R_287()) return true;
    7187     Token xsp;
    7188     while (true) {
    7189       xsp = jj_scanpos;
    7190       if (jj_3R_288()) { jj_scanpos = xsp; break; }
    7191     }
    7192     if (jj_scan_token(SEMICOLON)) return true;
    7193     return false;
    7194   }
    7195
    7196   final private boolean jj_3R_94() {
    7197     if (jj_scan_token(INTERFACE)) return true;
    7198     return false;
    7199   }
    7200
    7201   final private boolean jj_3_7() {
    7202     Token xsp;
    7203     xsp = jj_scanpos;
    7204     if (jj_scan_token(49)) jj_scanpos = xsp;
    7205     if (jj_scan_token(LBRACE)) return true;
    7206     return false;
    7207   }
    7208
    7209   final private boolean jj_3R_272() {
    7210     if (jj_3R_280()) return true;
    7211     return false;
    7212   }
    7213
    7214   final private boolean jj_3R_243() {
    7215     if (jj_3R_249()) return true;
    7216     Token xsp;
    7217     while (true) {
    7218       xsp = jj_scanpos;
    7219       if (jj_3R_250()) { jj_scanpos = xsp; break; }
    7220     }
    7221     return false;
    7222   }
    7223
    7224   final private boolean jj_3R_271() {
    7225     if (jj_3R_279()) return true;
    7226     return false;
    7227   }
    7228
    7229   final private boolean jj_3R_223() {
    7230     if (jj_3R_243()) return true;
    7231     return false;
    7232   }
    7233
    7234   final private boolean jj_3R_270() {
    7235     if (jj_3R_278()) return true;
    7236     return false;
    7237   }
    7238
    7239   final private boolean jj_3R_90() {
    7240     if (jj_scan_token(IDENTIFIER)) return true;
    7241     if (jj_scan_token(ASSIGN)) return true;
    7242     return false;
    7243   }
    7244
    7245   final private boolean jj_3_4() {
    7246     if (jj_3R_63()) return true;
    7247     return false;
    7248   }
    7249
    7250   final private boolean jj_3_3() {
    7251     if (jj_3R_62()) return true;
    7252     return false;
    7253   }
    7254
    7255   final private boolean jj_3R_192() {
    7256     if (jj_scan_token(AT)) return true;
    7257     if (jj_3R_89()) return true;
    7258     if (jj_scan_token(LPAREN)) return true;
    7259     if (jj_3R_91()) return true;
    7260     if (jj_scan_token(RPAREN)) return true;
    7261     return false;
    7262   }
    7263
    7264   final private boolean jj_3R_264() {
    7265     if (jj_3R_88()) return true;
    7266     Token xsp;
    7267     xsp = jj_scanpos;
    7268     if (jj_3_3()) {
    7269     jj_scanpos = xsp;
    7270     if (jj_3_4()) {
    7271     jj_scanpos = xsp;
    7272     if (jj_3R_270()) {
    7273     jj_scanpos = xsp;
    7274     if (jj_3R_271()) {
    7275     jj_scanpos = xsp;
    7276     if (jj_3R_272()) return true;
    7277     }
    7278     }
    7279     }
    7280     }
    7281     return false;
    7282   }
    7283
    7284   final private boolean jj_3R_259() {
    7285     Token xsp;
    7286     xsp = jj_scanpos;
    7287     if (jj_3R_263()) {
    7288     jj_scanpos = xsp;
    7289     if (jj_3R_264()) {
    7290     jj_scanpos = xsp;
    7291     if (jj_scan_token(80)) return true;
    7292     }
    7293     }
    7294     return false;
    7295   }
    7296
    7297   final private boolean jj_3R_326() {
    7298     if (jj_3R_98()) return true;
    7299     return false;
    7300   }
    7301
    7302   final private boolean jj_3R_263() {
    7303     if (jj_3R_269()) return true;
    7304     return false;
    7305   }
    7306
    7307   final private boolean jj_3R_255() {
    7308     if (jj_3R_259()) return true;
    7309     return false;
    7310   }
    7311
    7312   final private boolean jj_3R_159() {
    7313     if (jj_scan_token(COMMA)) return true;
    7314     if (jj_3R_158()) return true;
    7315     return false;
    7316   }
    7317
    7318   final private boolean jj_3R_194() {
    7319     if (jj_3R_203()) return true;
    7320     return false;
    7321   }
    7322
    7323   final private boolean jj_3R_193() {
    7324     if (jj_scan_token(AT)) return true;
    7325     if (jj_3R_89()) return true;
    7326     return false;
    7327   }
    7328
    7329   final private boolean jj_3_47() {
    7330     if (jj_scan_token(AT)) return true;
    7331     if (jj_3R_89()) return true;
    7332     if (jj_scan_token(LPAREN)) return true;
    7333     return false;
    7334   }
    7335
    7336   final private boolean jj_3R_98() {
    7337     if (jj_scan_token(LBRACE)) return true;
    7338     Token xsp;
    7339     while (true) {
    7340       xsp = jj_scanpos;
    7341       if (jj_3R_255()) { jj_scanpos = xsp; break; }
    7342     }
    7343     if (jj_scan_token(RBRACE)) return true;
    7344     return false;
    7345   }
    7346
    7347   final private boolean jj_3R_191() {
    7348     if (jj_scan_token(AT)) return true;
    7349     if (jj_3R_89()) return true;
    7350     if (jj_scan_token(LPAREN)) return true;
    7351     Token xsp;
    7352     xsp = jj_scanpos;
    7353     if (jj_3R_223()) jj_scanpos = xsp;
    7354     if (jj_scan_token(RPAREN)) return true;
    7355     return false;
    7356   }
    7357
    7358   final private boolean jj_3_46() {
    7359     if (jj_scan_token(AT)) return true;
    7360     if (jj_3R_89()) return true;
    7361     if (jj_scan_token(LPAREN)) return true;
    7362     Token xsp;
    7363     xsp = jj_scanpos;
    7364     if (jj_3R_90()) {
    7365     jj_scanpos = xsp;
    7366     if (jj_scan_token(75)) return true;
    7367     }
    7368     return false;
    7369   }
    7370
    7371   final private boolean jj_3R_203() {
    7372     if (jj_scan_token(EXTENDS)) return true;
    7373     if (jj_3R_171()) return true;
    7374     Token xsp;
    7375     while (true) {
    7376       xsp = jj_scanpos;
    7377       if (jj_3R_217()) { jj_scanpos = xsp; break; }
    7378     }
    7379     return false;
    7380   }
    7381
    7382   final private boolean jj_3R_154() {
    7383     if (jj_3R_193()) return true;
    7384     return false;
    7385   }
    7386
    7387   final private boolean jj_3R_325() {
    7388     if (jj_3R_71()) return true;
    7389     return false;
    7390   }
    7391
    7392   final private boolean jj_3R_155() {
    7393     Token xsp;
    7394     xsp = jj_scanpos;
    7395     if (jj_scan_token(28)) {
    7396     jj_scanpos = xsp;
    7397     if (jj_scan_token(12)) return true;
    7398     }
    7399     return false;
    7400   }
    7401
    7402   final private boolean jj_3R_153() {
    7403     if (jj_3R_192()) return true;
    7404     return false;
    7405   }
    7406
    7407   final private boolean jj_3R_93() {
    7408     Token xsp;
    7409     xsp = jj_scanpos;
    7410     if (jj_3R_155()) jj_scanpos = xsp;
    7411     if (jj_scan_token(CLASS)) return true;
    7412     return false;
    7413   }
    7414
    7415   final private boolean jj_3R_158() {
    7416     if (jj_scan_token(IDENTIFIER)) return true;
    7417     Token xsp;
    7418     xsp = jj_scanpos;
    7419     if (jj_3R_194()) jj_scanpos = xsp;
    7420     return false;
    7421   }
    7422
    7423   final private boolean jj_3_2() {
    7424     if (jj_scan_token(COMMA)) return true;
    7425     if (jj_3R_61()) return true;
    7426     return false;
    7427   }
    7428
    7429   final private boolean jj_3R_115() {
    7430     return false;
    7431   }
    7432
    7433   final private boolean jj_3R_92() {
    7434     Token xsp;
    7435     xsp = jj_scanpos;
    7436     if (jj_3R_152()) {
    7437     jj_scanpos = xsp;
    7438     if (jj_3R_153()) {
    7439     jj_scanpos = xsp;
    7440     if (jj_3R_154()) return true;
    7441     }
    7442     }
    7443     return false;
    7444   }
    7445
    7446   final private boolean jj_3R_152() {
    7447     if (jj_3R_191()) return true;
    7448     return false;
    7449   }
    7450
    7451   final private boolean jj_3R_335() {
    7452     if (jj_scan_token(COLON)) return true;
    7453     if (jj_3R_83()) return true;
    7454     return false;
    7455   }
    7456
    7457   final private boolean jj_3R_101() {
    7458     if (jj_scan_token(LT)) return true;
    7459     if (jj_3R_158()) return true;
    7460     Token xsp;
    7461     while (true) {
    7462       xsp = jj_scanpos;
    7463       if (jj_3R_159()) { jj_scanpos = xsp; break; }
    7464     }
    7465     if (jj_scan_token(GT)) return true;
    7466     return false;
    7467   }
    7468
    7469   final private boolean jj_3R_314() {
    7470     if (jj_3R_259()) return true;
    7471     return false;
    7472   }
    7473
    7474   final private boolean jj_3R_116() {
    7475     return false;
    7476   }
    7477
    7478   final private boolean jj_3R_61() {
    7479     if (jj_scan_token(IDENTIFIER)) return true;
    7480     Token xsp;
    7481     xsp = jj_scanpos;
    7482     if (jj_3R_325()) jj_scanpos = xsp;
    7483     xsp = jj_scanpos;
    7484     if (jj_3R_326()) jj_scanpos = xsp;
    7485     return false;
    7486   }
    7487
    7488   final private boolean jj_3R_75() {
    7489     Token xsp;
    7490     xsp = jj_scanpos;
    7491     lookingAhead = true;
    7492     jj_semLA = getToken(1).kind == GT &&
    7493                 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
    7494     lookingAhead = false;
    7495     if (!jj_semLA || jj_3R_115()) return true;
    7496     if (jj_scan_token(GT)) return true;
    7497     if (jj_scan_token(GT)) return true;
    7498     return false;
    7499   }
    7500
    7501   final private boolean jj_3R_302() {
    7502     if (jj_scan_token(SEMICOLON)) return true;
    7503     Token xsp;
    7504     while (true) {
    7505       xsp = jj_scanpos;
    7506       if (jj_3R_314()) { jj_scanpos = xsp; break; }
    7507     }
    7508     return false;
    7509   }
    7510
    7511   final private boolean jj_3R_301() {
    7512     if (jj_3R_61()) return true;
    7513     Token xsp;
    7514     while (true) {
    7515       xsp = jj_scanpos;
    7516       if (jj_3_2()) { jj_scanpos = xsp; break; }
    7517     }
    7518     return false;
    7519   }
    7520
    7521   final private boolean jj_3R_100() {
    7522     if (jj_scan_token(LBRACE)) return true;
    7523     Token xsp;
    7524     xsp = jj_scanpos;
    7525     if (jj_3R_301()) jj_scanpos = xsp;
    7526     xsp = jj_scanpos;
    7527     if (jj_scan_token(81)) jj_scanpos = xsp;
    7528     xsp = jj_scanpos;
    7529     if (jj_3R_302()) jj_scanpos = xsp;
    7530     if (jj_scan_token(RBRACE)) return true;
    7531     return false;
    7532   }
    7533
    7534   final private boolean jj_3R_76() {
    7535     Token xsp;
    7536     xsp = jj_scanpos;
    7537     lookingAhead = true;
    7538     jj_semLA = getToken(1).kind == GT &&
    7539                 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
    7540     lookingAhead = false;
    7541     if (!jj_semLA || jj_3R_116()) return true;
    7542     if (jj_scan_token(GT)) return true;
    7543     if (jj_scan_token(GT)) return true;
    7544     if (jj_scan_token(GT)) return true;
    7545     return false;
    7546   }
    7547
    7548   final private boolean jj_3R_99() {
    7549     if (jj_3R_157()) return true;
    7550     return false;
    7551   }
    7552
    7553   final private boolean jj_3R_161() {
    7554     if (jj_scan_token(IDENTIFIER)) return true;
    7555     if (jj_3R_83()) return true;
    7556     Token xsp;
    7557     xsp = jj_scanpos;
    7558     if (jj_3R_335()) jj_scanpos = xsp;
    7559     if (jj_scan_token(SEMICOLON)) return true;
    7560     return false;
    7561   }
    7562
    7563   final private boolean jj_3R_63() {
    7564     if (jj_scan_token(IDENTIFIER)) return true;
    7565     if (jj_scan_token(IDENTIFIER)) return true;
    7566     Token xsp;
    7567     xsp = jj_scanpos;
    7568     if (jj_3R_99()) jj_scanpos = xsp;
    7569     if (jj_3R_100()) return true;
    7570     return false;
    7571   }
    7572
    7573   final private boolean jj_3R_356() {
    7574     if (jj_scan_token(FINALLY)) return true;
    7575     if (jj_3R_176()) return true;
    7576     return false;
    7577   }
    7578
    7579   final private boolean jj_3R_313() {
    7580     if (jj_scan_token(COMMA)) return true;
    7581     if (jj_3R_171()) return true;
    7582     return false;
    7583   }
    7584
    7585   final private boolean jj_3R_157() {
    7586     if (jj_scan_token(IMPLEMENTS)) return true;
    7587     if (jj_3R_171()) return true;
    7588     Token xsp;
    7589     while (true) {
    7590       xsp = jj_scanpos;
    7591       if (jj_3R_313()) { jj_scanpos = xsp; break; }
    7592     }
    7593     return false;
    7594   }
    7595
    7596   final private boolean jj_3R_355() {
    7597     if (jj_scan_token(CATCH)) return true;
    7598     if (jj_scan_token(LPAREN)) return true;
    7599     if (jj_3R_315()) return true;
    7600     if (jj_scan_token(RPAREN)) return true;
    7601     if (jj_3R_176()) return true;
    7602     return false;
    7603   }
    7604
    7605   final private boolean jj_3R_312() {
    7606     if (jj_scan_token(COMMA)) return true;
    7607     if (jj_3R_171()) return true;
    7608     return false;
    7609   }
    7610
    7611   final private boolean jj_3R_349() {
    7612     if (jj_3R_356()) return true;
    7613     return false;
    7614   }
    7615
    7616   final private boolean jj_3R_348() {
    7617     if (jj_3R_355()) return true;
    7618     return false;
    7619   }
    7620
    7621   final private boolean jj_3R_156() {
    7622     if (jj_scan_token(EXTENDS)) return true;
    7623     if (jj_3R_171()) return true;
    7624     Token xsp;
    7625     while (true) {
    7626       xsp = jj_scanpos;
    7627       if (jj_3R_312()) { jj_scanpos = xsp; break; }
    7628     }
    7629     return false;
    7630   }
    7631
    7632   final private boolean jj_3R_189() {
    7633     if (jj_scan_token(TRY)) return true;
    7634     if (jj_3R_176()) return true;
    7635     Token xsp;
    7636     while (true) {
    7637       xsp = jj_scanpos;
    7638       if (jj_3R_348()) { jj_scanpos = xsp; break; }
    7639     }
    7640     xsp = jj_scanpos;
    7641     if (jj_3R_349()) jj_scanpos = xsp;
    7642     return false;
    7643   }
    7644
    7645   final private boolean jj_3R_97() {
    7646     if (jj_3R_157()) return true;
    7647     return false;
    7648   }
    7649
    7650   final private boolean jj_3R_96() {
    7651     if (jj_3R_156()) return true;
    7652     return false;
    7653   }
    7654
    7655   final private boolean jj_3R_95() {
    7656     if (jj_3R_101()) return true;
    7657     return false;
    7658   }
    7659
    7660   final private boolean jj_3R_188() {
    7661     if (jj_scan_token(SYNCHRONIZED)) return true;
    7662     if (jj_scan_token(LPAREN)) return true;
    7663     if (jj_3R_83()) return true;
    7664     if (jj_scan_token(RPAREN)) return true;
    7665     if (jj_3R_176()) return true;
    7666     return false;
    7667   }
    7668
    7669   final private boolean jj_3R_347() {
    7670     if (jj_3R_83()) return true;
    7671     return false;
    7672   }
    7673
    7674   final private boolean jj_3R_62() {
    7675     Token xsp;
    7676     xsp = jj_scanpos;
    7677     if (jj_3R_93()) {
    7678     jj_scanpos = xsp;
    7679     if (jj_3R_94()) return true;
    7680     }
    7681     if (jj_scan_token(IDENTIFIER)) return true;
    7682     xsp = jj_scanpos;
    7683     if (jj_3R_95()) jj_scanpos = xsp;
    7684     xsp = jj_scanpos;
    7685     if (jj_3R_96()) jj_scanpos = xsp;
    7686     xsp = jj_scanpos;
    7687     if (jj_3R_97()) jj_scanpos = xsp;
    7688     if (jj_3R_98()) return true;
    7689     return false;
    7690   }
    7691
    7692   final private boolean jj_3R_346() {
    7693     if (jj_scan_token(IDENTIFIER)) return true;
    7694     return false;
    7695   }
    7696
    7697   final private boolean jj_3R_187() {
    7698     if (jj_scan_token(THROW)) return true;
    7699     if (jj_3R_83()) return true;
    7700     if (jj_scan_token(SEMICOLON)) return true;
    7701     return false;
    7702   }
    7703
    7704   final private boolean jj_3R_367() {
    7705     if (jj_scan_token(COMMA)) return true;
    7706     if (jj_3R_178()) return true;
    7707     return false;
    7708   }
    7709
    7710   final private boolean jj_3R_186() {
    7711     if (jj_scan_token(RETURN)) return true;
    7712     Token xsp;
    7713     xsp = jj_scanpos;
    7714     if (jj_3R_347()) jj_scanpos = xsp;
    7715     if (jj_scan_token(SEMICOLON)) return true;
    7716     return false;
    7717   }
    7718
    7719   final private boolean jj_3R_345() {
    7720     if (jj_scan_token(IDENTIFIER)) return true;
    7721     return false;
    7722   }
    7723
    7724   final private boolean jj_3R_185() {
    7725     if (jj_scan_token(CONTINUE)) return true;
    7726     Token xsp;
    7727     xsp = jj_scanpos;
    7728     if (jj_3R_346()) jj_scanpos = xsp;
    7729     if (jj_scan_token(SEMICOLON)) return true;
    7730     return false;
    7731   }
    7732
    7733   final private boolean jj_3R_184() {
    7734     if (jj_scan_token(BREAK)) return true;
    7735     Token xsp;
    7736     xsp = jj_scanpos;
    7737     if (jj_3R_345()) jj_scanpos = xsp;
    7738     if (jj_scan_token(SEMICOLON)) return true;
    7739     return false;
    7740   }
    7741
    7742   final private boolean jj_3R_361() {
    7743     if (jj_3R_366()) return true;
    7744     return false;
    7745   }
    7746
    7747   final private boolean jj_3R_60() {
    7748     if (jj_3R_92()) return true;
    7749     return false;
    7750   }
    7751
    7752   final private boolean jj_3_45() {
    7753     Token xsp;
    7754     xsp = jj_scanpos;
    7755     if (jj_scan_token(28)) jj_scanpos = xsp;
    7756     if (jj_3R_65()) return true;
    7757     if (jj_scan_token(IDENTIFIER)) return true;
    7758     return false;
    7759   }
    7760
    7761   final private boolean jj_3R_59() {
    7762     if (jj_scan_token(STRICTFP)) return true;
    7763     return false;
    7764   }
    7765
    7766   final private boolean jj_3R_366() {
    7767     if (jj_3R_178()) return true;
    7768     Token xsp;
    7769     while (true) {
    7770       xsp = jj_scanpos;
    7771       if (jj_3R_367()) { jj_scanpos = xsp; break; }
    7772     }
    7773     return false;
    7774   }
    7775
    7776   final private boolean jj_3R_58() {
    7777     if (jj_scan_token(VOLATILE)) return true;
    7778     return false;
    7779   }
    7780
    7781   final private boolean jj_3R_57() {
    7782     if (jj_scan_token(TRANSIENT)) return true;
    7783     return false;
    7784   }
    7785
    7786   final private boolean jj_3R_56() {
    7787     if (jj_scan_token(NATIVE)) return true;
    7788     return false;
    7789   }
    7790
    7791   final private boolean jj_3R_55() {
    7792     if (jj_scan_token(SYNCHRONIZED)) return true;
    7793     return false;
    7794   }
    7795
    7796   final private boolean jj_3R_342() {
    7797     if (jj_scan_token(ELSE)) return true;
    7798     if (jj_3R_86()) return true;
    7799     return false;
    7800   }
    7801
    7802   final private boolean jj_3R_54() {
    7803     if (jj_scan_token(ABSTRACT)) return true;
    7804     return false;
    7805   }
    7806
    7807   final private boolean jj_3R_53() {
    7808     if (jj_scan_token(FINAL)) return true;
    7809     return false;
    7810   }
    7811
    7812   final private boolean jj_3R_365() {
    7813     if (jj_3R_366()) return true;
    7814     return false;
    7815   }
    7816
    7817   final private boolean jj_3R_52() {
    7818     if (jj_scan_token(PRIVATE)) return true;
    7819     return false;
    7820   }
    7821
    7822   final private boolean jj_3R_51() {
    7823     if (jj_scan_token(PROTECTED)) return true;
    7824     return false;
    7825   }
    7826
    7827   final private boolean jj_3R_50() {
    7828     if (jj_scan_token(STATIC)) return true;
    7829     return false;
    7830   }
    7831
    7832   final private boolean jj_3R_364() {
    7833     if (jj_3R_162()) return true;
    7834     return false;
    7835   }
    7836
    7837   final private boolean jj_3R_360() {
    7838     Token xsp;
    7839     xsp = jj_scanpos;
    7840     if (jj_3R_364()) {
    7841     jj_scanpos = xsp;
    7842     if (jj_3R_365()) return true;
    7843     }
    7844     return false;
    7845   }
    7846
    7847   final private boolean jj_3_44() {
    7848     if (jj_3R_88()) return true;
    7849     if (jj_3R_65()) return true;
    7850     if (jj_scan_token(IDENTIFIER)) return true;
    7851     if (jj_scan_token(COLON)) return true;
    7852     return false;
    7853   }
    7854
    7855   final private boolean jj_3R_49() {
    7856     if (jj_scan_token(PUBLIC)) return true;
    7857     return false;
    7858   }
    7859
    7860   final private boolean jj_3_1() {
    7861     Token xsp;
    7862     xsp = jj_scanpos;
    7863     if (jj_3R_49()) {
    7864     jj_scanpos = xsp;
    7865     if (jj_3R_50()) {
    7866     jj_scanpos = xsp;
    7867     if (jj_3R_51()) {
    7868     jj_scanpos = xsp;
    7869     if (jj_3R_52()) {
    7870     jj_scanpos = xsp;
    7871     if (jj_3R_53()) {
    7872     jj_scanpos = xsp;
    7873     if (jj_3R_54()) {
    7874     jj_scanpos = xsp;
    7875     if (jj_3R_55()) {
    7876     jj_scanpos = xsp;
    7877     if (jj_3R_56()) {
    7878     jj_scanpos = xsp;
    7879     if (jj_3R_57()) {
    7880     jj_scanpos = xsp;
    7881     if (jj_3R_58()) {
    7882     jj_scanpos = xsp;
    7883     if (jj_3R_59()) {
    7884     jj_scanpos = xsp;
    7885     if (jj_3R_60()) return true;
    7886     }
    7887     }
    7888     }
    7889     }
    7890     }
    7891     }
    7892     }
    7893     }
    7894     }
    7895     }
    7896     }
    7897     return false;
    7898   }
    7899
    7900   final private boolean jj_3R_354() {
    7901     if (jj_3R_361()) return true;
    7902     return false;
    7903   }
    7904
    7905   final private boolean jj_3R_88() {
    7906     Token xsp;
    7907     while (true) {
    7908       xsp = jj_scanpos;
    7909       if (jj_3_1()) { jj_scanpos = xsp; break; }
    7910     }
    7911     return false;
    7912   }
    7913
    7914   final private boolean jj_3R_353() {
    7915     if (jj_3R_83()) return true;
    7916     return false;
    7917   }
    7918
    7919   final private boolean jj_3R_352() {
    7920     if (jj_3R_360()) return true;
    7921     return false;
    7922   }
    7923
    7924   final private boolean jj_3R_344() {
    7925     Token xsp;
    7926     xsp = jj_scanpos;
    7927     if (jj_3R_352()) jj_scanpos = xsp;
    7928     if (jj_scan_token(SEMICOLON)) return true;
    7929     xsp = jj_scanpos;
    7930     if (jj_3R_353()) jj_scanpos = xsp;
    7931     if (jj_scan_token(SEMICOLON)) return true;
    7932     xsp = jj_scanpos;
    7933     if (jj_3R_354()) jj_scanpos = xsp;
    7934     return false;
    7935   }
    7936
    7937   final private boolean jj_3R_343() {
    7938     if (jj_3R_88()) return true;
    7939     if (jj_3R_65()) return true;
    7940     if (jj_scan_token(IDENTIFIER)) return true;
    7941     if (jj_scan_token(COLON)) return true;
    7942     if (jj_3R_83()) return true;
    7943     return false;
    7944   }
    7945
    7946   final private boolean jj_3R_183() {
    7947     if (jj_scan_token(FOR)) return true;
    7948     if (jj_scan_token(LPAREN)) return true;
    7949     Token xsp;
    7950     xsp = jj_scanpos;
    7951     if (jj_3R_343()) {
    7952     jj_scanpos = xsp;
    7953     if (jj_3R_344()) return true;
    7954     }
    7955     if (jj_scan_token(RPAREN)) return true;
    7956     if (jj_3R_86()) return true;
    7957     return false;
    7958   }
    7959
    7960   final private boolean jj_3R_182() {
    7961     if (jj_scan_token(DO)) return true;
    7962     if (jj_3R_86()) return true;
    7963     if (jj_scan_token(WHILE)) return true;
    7964     if (jj_scan_token(LPAREN)) return true;
    7965     if (jj_3R_83()) return true;
    7966     if (jj_scan_token(RPAREN)) return true;
    7967     if (jj_scan_token(SEMICOLON)) return true;
    7968     return false;
    7969   }
    7970
    7971   final private boolean jj_3R_181() {
    7972     if (jj_scan_token(WHILE)) return true;
    7973     if (jj_scan_token(LPAREN)) return true;
    7974     if (jj_3R_83()) return true;
    7975     if (jj_scan_token(RPAREN)) return true;
    7976     if (jj_3R_86()) return true;
    7977     return false;
    7978   }
    7979
    7980   final private boolean jj_3_43() {
    7981     if (jj_3R_69()) return true;
    7982     return false;
    7983   }
    7984
    7985   final private boolean jj_3R_180() {
    7986     if (jj_scan_token(IF)) return true;
    7987     if (jj_scan_token(LPAREN)) return true;
    7988     if (jj_3R_83()) return true;
    7989     if (jj_scan_token(RPAREN)) return true;
    7990     if (jj_3R_86()) return true;
    7991     Token xsp;
    7992     xsp = jj_scanpos;
    7993     if (jj_3R_342()) jj_scanpos = xsp;
    7994     return false;
    7995   }
    7996
    7997   final private boolean jj_3R_359() {
    7998     if (jj_scan_token(_DEFAULT)) return true;
    7999     if (jj_scan_token(COLON)) return true;
    8000     return false;
    8001   }
    8002
    8003   final private boolean jj_3R_358() {
    8004     if (jj_scan_token(CASE)) return true;
    8005     if (jj_3R_83()) return true;
    8006     if (jj_scan_token(COLON)) return true;
    8007     return false;
    8008   }
    8009
    8010   final private boolean jj_3R_351() {
    8011     Token xsp;
    8012     xsp = jj_scanpos;
    8013     if (jj_3R_358()) {
    8014     jj_scanpos = xsp;
    8015     if (jj_3R_359()) return true;
    8016     }
    8017     return false;
    8018   }
    8019
    8020   final private boolean jj_3R_341() {
    8021     if (jj_3R_351()) return true;
    8022     Token xsp;
    8023     while (true) {
    8024       xsp = jj_scanpos;
    8025       if (jj_3_43()) { jj_scanpos = xsp; break; }
    8026     }
    8027     return false;
    8028   }
    8029
    8030   final private boolean jj_3R_205() {
    8031     if (jj_3R_92()) return true;
    8032     return false;
    8033   }
    8034
    8035   final private boolean jj_3_42() {
    8036     if (jj_3R_70()) return true;
    8037     Token xsp;
    8038     xsp = jj_scanpos;
    8039     if (jj_scan_token(96)) {
    8040     jj_scanpos = xsp;
    8041     if (jj_scan_token(97)) return true;
    8042     }
    8043     return false;
    8044   }
    8045
    8046   final private boolean jj_3R_179() {
    8047     if (jj_scan_token(SWITCH)) return true;
    8048     if (jj_scan_token(LPAREN)) return true;
    8049     if (jj_3R_83()) return true;
    8050     if (jj_scan_token(RPAREN)) return true;
    8051     if (jj_scan_token(LBRACE)) return true;
    8052     Token xsp;
    8053     while (true) {
    8054       xsp = jj_scanpos;
    8055       if (jj_3R_341()) { jj_scanpos = xsp; break; }
    8056     }
    8057     if (jj_scan_token(RBRACE)) return true;
    8058     return false;
    8059   }
    8060
    8061   final private boolean jj_3R_350() {
    8062     if (jj_3R_221()) return true;
    8063     if (jj_3R_83()) return true;
    8064     return false;
    8065   }
    8066
    8067   final private boolean jj_3R_202() {
    8068     if (jj_3R_70()) return true;
    8069     Token xsp;
    8070     xsp = jj_scanpos;
    8071     if (jj_3R_350()) jj_scanpos = xsp;
    8072     return false;
    8073   }
    8074
    8075   final private boolean jj_3R_201() {
    8076     if (jj_3R_216()) return true;
    8077     return false;
    8078   }
    8079
    8080   final private boolean jj_3R_200() {
    8081     if (jj_3R_215()) return true;
    8082     return false;
    8083   }
    8084
    8085   final private boolean jj_3R_178() {
    8086     Token xsp;
    8087     xsp = jj_scanpos;
    8088     if (jj_3R_199()) {
    8089     jj_scanpos = xsp;
    8090     if (jj_3R_200()) {
    8091     jj_scanpos = xsp;
    8092     if (jj_3R_201()) {
    8093     jj_scanpos = xsp;
    8094     if (jj_3R_202()) return true;
    8095     }
    8096     }
    8097     }
    8098     return false;
    8099   }
    8100
    8101   final private boolean jj_3R_199() {
    8102     if (jj_3R_214()) return true;
    8103     return false;
    8104   }
    8105
    8106   final private boolean jj_3R_177() {
    8107     if (jj_scan_token(SEMICOLON)) return true;
    8108     return false;
    8109   }
    8110
    8111   final private boolean jj_3R_87() {
    8112     Token xsp;
    8113     xsp = jj_scanpos;
    8114     if (jj_scan_token(28)) {
    8115     jj_scanpos = xsp;
    8116     if (jj_scan_token(12)) return true;
    8117     }
    8118     return false;
    8119   }
    8120
    8121   final private boolean jj_3R_336() {
    8122     if (jj_scan_token(COMMA)) return true;
    8123     if (jj_3R_287()) return true;
    8124     return false;
    8125   }
    8126
    8127   final private boolean jj_3R_133() {
    8128     if (jj_3R_92()) return true;
    8129     return false;
    8130   }
    8131
    8132   final private boolean jj_3_41() {
    8133     Token xsp;
    8134     xsp = jj_scanpos;
    8135     if (jj_3R_87()) jj_scanpos = xsp;
    8136     if (jj_scan_token(CLASS)) return true;
    8137     return false;
    8138   }
    8139
    8140   final private boolean jj_3R_195() {
    8141     Token xsp;
    8142     xsp = jj_scanpos;
    8143     if (jj_3R_204()) {
    8144     jj_scanpos = xsp;
    8145     if (jj_3R_205()) return true;
    8146     }
    8147     return false;
    8148   }
    8149
    8150   final private boolean jj_3R_204() {
    8151     if (jj_scan_token(FINAL)) return true;
    8152     return false;
    8153   }
    8154
    8155   final private boolean jj_3R_162() {
    8156     Token xsp;
    8157     while (true) {
    8158       xsp = jj_scanpos;
    8159       if (jj_3R_195()) { jj_scanpos = xsp; break; }
    8160     }
    8161     if (jj_3R_65()) return true;
    8162     if (jj_3R_287()) return true;
    8163     while (true) {
    8164       xsp = jj_scanpos;
    8165       if (jj_3R_336()) { jj_scanpos = xsp; break; }
    8166     }
    8167     return false;
    8168   }
    8169
    8170   final private boolean jj_3R_85() {
    8171     Token xsp;
    8172     xsp = jj_scanpos;
    8173     if (jj_scan_token(28)) {
    8174     jj_scanpos = xsp;
    8175     if (jj_3R_133()) return true;
    8176     }
    8177     return false;
    8178   }
    8179
    8180   final private boolean jj_3R_109() {
    8181     if (jj_3R_62()) return true;
    8182     return false;
    8183   }
    8184
    8185   final private boolean jj_3_39() {
    8186     Token xsp;
    8187     while (true) {
    8188       xsp = jj_scanpos;
    8189       if (jj_3R_85()) { jj_scanpos = xsp; break; }
    8190     }
    8191     if (jj_3R_65()) return true;
    8192     if (jj_scan_token(IDENTIFIER)) return true;
    8193     return false;
    8194   }
    8195
    8196   final private boolean jj_3_40() {
    8197     if (jj_3R_86()) return true;
    8198     return false;
    8199   }
    8200
    8201   final private boolean jj_3R_108() {
    8202     if (jj_3R_162()) return true;
    8203     if (jj_scan_token(SEMICOLON)) return true;
    8204     return false;
    8205   }
    8206
    8207   final private boolean jj_3R_107() {
    8208     if (jj_3R_161()) return true;
    8209     return false;
    8210   }
    8211
    8212   final private boolean jj_3_38() {
    8213     if (jj_3R_69()) return true;
    8214     return false;
    8215   }
    8216
    8217   final private boolean jj_3R_69() {
    8218     Token xsp;
    8219     xsp = jj_scanpos;
    8220     lookingAhead = true;
    8221     jj_semLA = isNextTokenAnAssert();
    8222     lookingAhead = false;
    8223     if (!jj_semLA || jj_3R_107()) {
    8224     jj_scanpos = xsp;
    8225     if (jj_3R_108()) {
    8226     jj_scanpos = xsp;
    8227     if (jj_3_40()) {
    8228     jj_scanpos = xsp;
    8229     if (jj_3R_109()) return true;
    8230     }
    8231     }
    8232     }
    8233     return false;
    8234   }
    8235
    8236   final private boolean jj_3_35() {
    8237     if (jj_scan_token(LBRACKET)) return true;
    8238     if (jj_scan_token(RBRACKET)) return true;
    8239     return false;
    8240   }
    8241
    8242   final private boolean jj_3R_176() {
    8243     if (jj_scan_token(LBRACE)) return true;
    8244     Token xsp;
    8245     while (true) {
    8246       xsp = jj_scanpos;
    8247       if (jj_3_38()) { jj_scanpos = xsp; break; }
    8248     }
    8249     if (jj_scan_token(RBRACE)) return true;
    8250     return false;
    8251   }
    8252
    8253   final private boolean jj_3R_84() {
    8254     if (jj_scan_token(IDENTIFIER)) return true;
    8255     if (jj_scan_token(COLON)) return true;
    8256     if (jj_3R_86()) return true;
    8257     return false;
    8258   }
    8259
    8260   final private boolean jj_3R_148() {
    8261     if (jj_3R_189()) return true;
    8262     return false;
    8263   }
    8264
    8265   final private boolean jj_3R_147() {
    8266     if (jj_3R_188()) return true;
    8267     return false;
    8268   }
    8269
    8270   final private boolean jj_3R_146() {
    8271     if (jj_3R_187()) return true;
    8272     return false;
    8273   }
    8274
    8275   final private boolean jj_3R_145() {
    8276     if (jj_3R_186()) return true;
    8277     return false;
    8278   }
    8279
    8280   final private boolean jj_3R_144() {
    8281     if (jj_3R_185()) return true;
    8282     return false;
    8283   }
    8284
    8285   final private boolean jj_3R_143() {
    8286     if (jj_3R_184()) return true;
    8287     return false;
    8288   }
    8289
    8290   final private boolean jj_3R_142() {
    8291     if (jj_3R_183()) return true;
    8292     return false;
    8293   }
    8294
    8295   final private boolean jj_3R_141() {
    8296     if (jj_3R_182()) return true;
    8297     return false;
    8298   }
    8299
    8300   final private boolean jj_3R_140() {
    8301     if (jj_3R_181()) return true;
    8302     return false;
    8303   }
    8304
    8305   final private boolean jj_3R_139() {
    8306     if (jj_3R_180()) return true;
    8307     return false;
    8308   }
    8309
    8310   final private boolean jj_3R_138() {
    8311     if (jj_3R_179()) return true;
    8312     return false;
    8313   }
    8314
    8315   final private boolean jj_3R_137() {
    8316     if (jj_3R_178()) return true;
    8317     if (jj_scan_token(SEMICOLON)) return true;
    8318     return false;
    8319   }
    8320
    8321   final private boolean jj_3R_136() {
    8322     if (jj_3R_177()) return true;
    8323     return false;
    8324   }
    8325
    8326   final private boolean jj_3R_135() {
    8327     if (jj_3R_176()) return true;
    8328     return false;
    8329   }
    8330
    8331   final private boolean jj_3R_225() {
    8332     if (jj_3R_73()) return true;
    8333     return false;
    8334   }
    8335
    8336   final private boolean jj_3_37() {
    8337     if (jj_3R_84()) return true;
    8338     return false;
    8339   }
    8340
    8341   final private boolean jj_3R_134() {
    8342     if (jj_3R_161()) return true;
    8343     return false;
    8344   }
    8345
    8346   final private boolean jj_3R_86() {
    8347     Token xsp;
    8348     xsp = jj_scanpos;
    8349     lookingAhead = true;
    8350     jj_semLA = isNextTokenAnAssert();
    8351     lookingAhead = false;
    8352     if (!jj_semLA || jj_3R_134()) {
    8353     jj_scanpos = xsp;
    8354     if (jj_3_37()) {
    8355     jj_scanpos = xsp;
    8356     if (jj_3R_135()) {
    8357     jj_scanpos = xsp;
    8358     if (jj_3R_136()) {
    8359     jj_scanpos = xsp;
    8360     if (jj_3R_137()) {
    8361     jj_scanpos = xsp;
    8362     if (jj_3R_138()) {
    8363     jj_scanpos = xsp;
    8364     if (jj_3R_139()) {
    8365     jj_scanpos = xsp;
    8366     if (jj_3R_140()) {
    8367     jj_scanpos = xsp;
    8368     if (jj_3R_141()) {
    8369     jj_scanpos = xsp;
    8370     if (jj_3R_142()) {
    8371     jj_scanpos = xsp;
    8372     if (jj_3R_143()) {
    8373     jj_scanpos = xsp;
    8374     if (jj_3R_144()) {
    8375     jj_scanpos = xsp;
    8376     if (jj_3R_145()) {
    8377     jj_scanpos = xsp;
    8378     if (jj_3R_146()) {
    8379     jj_scanpos = xsp;
    8380     if (jj_3R_147()) {
    8381     jj_scanpos = xsp;
    8382     if (jj_3R_148()) return true;
    8383     }
    8384     }
    8385     }
    8386     }
    8387     }
    8388     }
    8389     }
    8390     }
    8391     }
    8392     }
    8393     }
    8394     }
    8395     }
    8396     }
    8397     }
    8398     return false;
    8399   }
    8400
    8401   final private boolean jj_3R_245() {
    8402     if (jj_3R_98()) return true;
    8403     return false;
    8404   }
    8405
    8406   final private boolean jj_3R_251() {
    8407     if (jj_scan_token(LBRACKET)) return true;
    8408     if (jj_scan_token(RBRACKET)) return true;
    8409     return false;
    8410   }
    8411
    8412   final private boolean jj_3_34() {
    8413     if (jj_scan_token(LBRACKET)) return true;
    8414     if (jj_3R_83()) return true;
    8415     if (jj_scan_token(RBRACKET)) return true;
    8416     return false;
    8417   }
    8418
    8419   final private boolean jj_3R_244() {
    8420     Token xsp;
    8421     if (jj_3R_251()) return true;
    8422     while (true) {
    8423       xsp = jj_scanpos;
    8424       if (jj_3R_251()) { jj_scanpos = xsp; break; }
    8425     }
    8426     if (jj_3R_160()) return true;
    8427     return false;
    8428   }
    8429
    8430   final private boolean jj_3_36() {
    8431     Token xsp;
    8432     if (jj_3_34()) return true;
    8433     while (true) {
    8434       xsp = jj_scanpos;
    8435       if (jj_3_34()) { jj_scanpos = xsp; break; }
    8436     }
    8437     while (true) {
    8438       xsp = jj_scanpos;
    8439       if (jj_3_35()) { jj_scanpos = xsp; break; }
    8440     }
    8441     return false;
    8442   }
    8443
    8444   final private boolean jj_3R_224() {
    8445     Token xsp;
    8446     xsp = jj_scanpos;
    8447     if (jj_3_36()) {
    8448     jj_scanpos = xsp;
    8449     if (jj_3R_244()) return true;
    8450     }
    8451     return false;
    8452   }
    8453
    8454   final private boolean jj_3R_227() {
    8455     if (jj_3R_71()) return true;
    8456     Token xsp;
    8457     xsp = jj_scanpos;
    8458     if (jj_3R_245()) jj_scanpos = xsp;
    8459     return false;
    8460   }
    8461
    8462   final private boolean jj_3R_197() {
    8463     if (jj_scan_token(COMMA)) return true;
    8464     if (jj_3R_83()) return true;
    8465     return false;
    8466   }
    8467
    8468   final private boolean jj_3R_226() {
    8469     if (jj_3R_224()) return true;
    8470     return false;
    8471   }
    8472
    8473   final private boolean jj_3R_131() {
    8474     if (jj_scan_token(NEW)) return true;
    8475     if (jj_3R_171()) return true;
    8476     Token xsp;
    8477     xsp = jj_scanpos;
    8478     if (jj_3R_225()) jj_scanpos = xsp;
    8479     xsp = jj_scanpos;
    8480     if (jj_3R_226()) {
    8481     jj_scanpos = xsp;
    8482     if (jj_3R_227()) return true;
    8483     }
    8484     return false;
    8485   }
    8486
    8487   final private boolean jj_3R_81() {
    8488     Token xsp;
    8489     xsp = jj_scanpos;
    8490     if (jj_3_33()) {
    8491     jj_scanpos = xsp;
    8492     if (jj_3R_131()) return true;
    8493     }
    8494     return false;
    8495   }
    8496
    8497   final private boolean jj_3_33() {
    8498     if (jj_scan_token(NEW)) return true;
    8499     if (jj_3R_78()) return true;
    8500     if (jj_3R_224()) return true;
    8501     return false;
    8502   }
    8503
    8504   final private boolean jj_3R_111() {
    8505     if (jj_3R_170()) return true;
    8506     return false;
    8507   }
    8508
    8509   final private boolean jj_3R_170() {
    8510     if (jj_3R_83()) return true;
    8511     Token xsp;
    8512     while (true) {
    8513       xsp = jj_scanpos;
    8514       if (jj_3R_197()) { jj_scanpos = xsp; break; }
    8515     }
    8516     return false;
    8517   }
    8518
    8519   final private boolean jj_3R_71() {
    8520     if (jj_scan_token(LPAREN)) return true;
    8521     Token xsp;
    8522     xsp = jj_scanpos;
    8523     if (jj_3R_111()) jj_scanpos = xsp;
    8524     if (jj_scan_token(RPAREN)) return true;
    8525     return false;
    8526   }
    8527
    8528   final private boolean jj_3R_174() {
    8529     if (jj_3R_196()) return true;
    8530     return false;
    8531   }
    8532
    8533   final private boolean jj_3R_219() {
    8534     if (jj_scan_token(NULL)) return true;
    8535     return false;
    8536   }
    8537
    8538   final private boolean jj_3R_218() {
    8539     Token xsp;
    8540     xsp = jj_scanpos;
    8541     if (jj_3R_228()) {
    8542     jj_scanpos = xsp;
    8543     if (jj_scan_token(27)) return true;
    8544     }
    8545     return false;
    8546   }
    8547
    8548   final private boolean jj_3R_228() {
    8549     if (jj_scan_token(TRUE)) return true;
    8550     return false;
    8551   }
    8552
    8553   final private boolean jj_3R_363() {
    8554     if (jj_scan_token(DECR)) return true;
    8555     return false;
    8556   }
    8557
    8558   final private boolean jj_3R_211() {
    8559     if (jj_3R_219()) return true;
    8560     return false;
    8561   }
    8562
    8563   final private boolean jj_3R_210() {
    8564     if (jj_3R_218()) return true;
    8565     return false;
    8566   }
    8567
    8568   final private boolean jj_3R_209() {
    8569     if (jj_scan_token(STRING_LITERAL)) return true;
    8570     return false;
    8571   }
    8572
    8573   final private boolean jj_3R_208() {
    8574     if (jj_scan_token(CHARACTER_LITERAL)) return true;
    8575     return false;
    8576   }
    8577
    8578   final private boolean jj_3R_207() {
    8579     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
    8580     return false;
    8581   }
    8582
    8583   final private boolean jj_3R_196() {
    8584     Token xsp;
    8585     xsp = jj_scanpos;
    8586     if (jj_3R_206()) {
    8587     jj_scanpos = xsp;
    8588     if (jj_3R_207()) {
    8589     jj_scanpos = xsp;
    8590     if (jj_3R_208()) {
    8591     jj_scanpos = xsp;
    8592     if (jj_3R_209()) {
    8593     jj_scanpos = xsp;
    8594     if (jj_3R_210()) {
    8595     jj_scanpos = xsp;
    8596     if (jj_3R_211()) return true;
    8597     }
    8598     }
    8599     }
    8600     }
    8601     }
    8602     return false;
    8603   }
    8604
    8605   final private boolean jj_3R_206() {
    8606     if (jj_scan_token(INTEGER_LITERAL)) return true;
    8607     return false;
    8608   }
    8609
    8610   final private boolean jj_3R_129() {
    8611     if (jj_3R_71()) return true;
    8612     return false;
    8613   }
    8614
    8615   final private boolean jj_3R_128() {
    8616     if (jj_scan_token(DOT)) return true;
    8617     if (jj_scan_token(IDENTIFIER)) return true;
    8618     return false;
    8619   }
    8620
    8621   final private boolean jj_3_28() {
    8622     if (jj_3R_80()) return true;
    8623     if (jj_scan_token(DOT)) return true;
    8624     if (jj_scan_token(CLASS)) return true;
    8625     return false;
    8626   }
    8627
    8628   final private boolean jj_3R_127() {
    8629     if (jj_scan_token(LBRACKET)) return true;
    8630     if (jj_3R_83()) return true;
    8631     if (jj_scan_token(RBRACKET)) return true;
    8632     return false;
    8633   }
    8634
    8635   final private boolean jj_3_32() {
    8636     if (jj_3R_82()) return true;
    8637     return false;
    8638   }
    8639
    8640   final private boolean jj_3_31() {
    8641     if (jj_scan_token(DOT)) return true;
    8642     if (jj_3R_81()) return true;
    8643     return false;
    8644   }
    8645
    8646   final private boolean jj_3R_331() {
    8647     if (jj_scan_token(REM)) return true;
    8648     return false;
    8649   }
    8650
    8651   final private boolean jj_3R_79() {
    8652     Token xsp;
    8653     xsp = jj_scanpos;
    8654     if (jj_3_29()) {
    8655     jj_scanpos = xsp;
    8656     if (jj_3_30()) {
    8657     jj_scanpos = xsp;
    8658     if (jj_3_31()) {
    8659     jj_scanpos = xsp;
    8660     if (jj_3_32()) {
    8661     jj_scanpos = xsp;
    8662     if (jj_3R_127()) {
    8663     jj_scanpos = xsp;
    8664     if (jj_3R_128()) {
    8665     jj_scanpos = xsp;
    8666     if (jj_3R_129()) return true;
    8667     }
    8668     }
    8669     }
    8670     }
    8671     }
    8672     }
    8673     return false;
    8674   }
    8675
    8676   final private boolean jj_3_30() {
    8677     if (jj_scan_token(DOT)) return true;
    8678     if (jj_scan_token(SUPER)) return true;
    8679     return false;
    8680   }
    8681
    8682   final private boolean jj_3_29() {
    8683     if (jj_scan_token(DOT)) return true;
    8684     if (jj_scan_token(THIS)) return true;
    8685     return false;
    8686   }
    8687
    8688   final private boolean jj_3R_169() {
    8689     if (jj_3R_89()) return true;
    8690     return false;
    8691   }
    8692
    8693   final private boolean jj_3R_168() {
    8694     if (jj_3R_80()) return true;
    8695     if (jj_scan_token(DOT)) return true;
    8696     if (jj_scan_token(CLASS)) return true;
    8697     return false;
    8698   }
    8699
    8700   final private boolean jj_3_27() {
    8701     if (jj_3R_79()) return true;
    8702     return false;
    8703   }
    8704
    8705   final private boolean jj_3R_167() {
    8706     if (jj_3R_81()) return true;
    8707     return false;
    8708   }
    8709
    8710   final private boolean jj_3R_166() {
    8711     if (jj_scan_token(LPAREN)) return true;
    8712     if (jj_3R_83()) return true;
    8713     if (jj_scan_token(RPAREN)) return true;
    8714     return false;
    8715   }
    8716
    8717   final private boolean jj_3R_165() {
    8718     if (jj_scan_token(SUPER)) return true;
    8719     if (jj_scan_token(DOT)) return true;
    8720     if (jj_scan_token(IDENTIFIER)) return true;
    8721     return false;
    8722   }
    8723
    8724   final private boolean jj_3R_164() {
    8725     if (jj_scan_token(THIS)) return true;
    8726     return false;
    8727   }
    8728
    8729   final private boolean jj_3R_110() {
    8730     Token xsp;
    8731     xsp = jj_scanpos;
    8732     if (jj_3R_163()) {
    8733     jj_scanpos = xsp;
    8734     if (jj_3R_164()) {
    8735     jj_scanpos = xsp;
    8736     if (jj_3R_165()) {
    8737     jj_scanpos = xsp;
    8738     if (jj_3R_166()) {
    8739     jj_scanpos = xsp;
    8740     if (jj_3R_167()) {
    8741     jj_scanpos = xsp;
    8742     if (jj_3R_168()) {
    8743     jj_scanpos = xsp;
    8744     if (jj_3R_169()) return true;
    8745     }
    8746     }
    8747     }
    8748     }
    8749     }
    8750     }
    8751     return false;
    8752   }
    8753
    8754   final private boolean jj_3R_163() {
    8755     if (jj_3R_196()) return true;
    8756     return false;
    8757   }
    8758
    8759   final private boolean jj_3R_362() {
    8760     if (jj_scan_token(INCR)) return true;
    8761     return false;
    8762   }
    8763
    8764   final private boolean jj_3R_357() {
    8765     Token xsp;
    8766     xsp = jj_scanpos;
    8767     if (jj_3R_362()) {
    8768     jj_scanpos = xsp;
    8769     if (jj_3R_363()) return true;
    8770     }
    8771     return false;
    8772   }
    8773
    8774   final private boolean jj_3R_82() {
    8775     if (jj_scan_token(DOT)) return true;
    8776     if (jj_3R_73()) return true;
    8777     if (jj_scan_token(IDENTIFIER)) return true;
    8778     return false;
    8779   }
    8780
    8781   final private boolean jj_3_26() {
    8782     if (jj_scan_token(LPAREN)) return true;
    8783     if (jj_3R_78()) return true;
    8784     return false;
    8785   }
    8786
    8787   final private boolean jj_3R_333() {
    8788     if (jj_scan_token(BANG)) return true;
    8789     return false;
    8790   }
    8791
    8792   final private boolean jj_3R_70() {
    8793     if (jj_3R_110()) return true;
    8794     Token xsp;
    8795     while (true) {
    8796       xsp = jj_scanpos;
    8797       if (jj_3_27()) { jj_scanpos = xsp; break; }
    8798     }
    8799     return false;
    8800   }
    8801
    8802   final private boolean jj_3R_321() {
    8803     if (jj_scan_token(MINUS)) return true;
    8804     return false;
    8805   }
    8806
    8807   final private boolean jj_3R_330() {
    8808     if (jj_scan_token(SLASH)) return true;
    8809     return false;
    8810   }
    8811
    8812   final private boolean jj_3R_340() {
    8813     if (jj_scan_token(LPAREN)) return true;
    8814     if (jj_3R_65()) return true;
    8815     if (jj_scan_token(RPAREN)) return true;
    8816     if (jj_3R_311()) return true;
    8817     return false;
    8818   }
    8819
    8820   final private boolean jj_3R_334() {
    8821     Token xsp;
    8822     xsp = jj_scanpos;
    8823     if (jj_3R_339()) {
    8824     jj_scanpos = xsp;
    8825     if (jj_3R_340()) return true;
    8826     }
    8827     return false;
    8828   }
    8829
    8830   final private boolean jj_3R_339() {
    8831     if (jj_scan_token(LPAREN)) return true;
    8832     if (jj_3R_65()) return true;
    8833     if (jj_scan_token(RPAREN)) return true;
    8834     if (jj_3R_282()) return true;
    8835     return false;
    8836   }
    8837
    8838   final private boolean jj_3_25() {
    8839     if (jj_scan_token(LPAREN)) return true;
    8840     if (jj_3R_65()) return true;
    8841     if (jj_scan_token(LBRACKET)) return true;
    8842     return false;
    8843   }
    8844
    8845   final private boolean jj_3R_216() {
    8846     if (jj_3R_70()) return true;
    8847     Token xsp;
    8848     xsp = jj_scanpos;
    8849     if (jj_3R_357()) jj_scanpos = xsp;
    8850     return false;
    8851   }
    8852
    8853   final private boolean jj_3R_118() {
    8854     if (jj_scan_token(LPAREN)) return true;
    8855     if (jj_3R_65()) return true;
    8856     if (jj_scan_token(RPAREN)) return true;
    8857     Token xsp;
    8858     xsp = jj_scanpos;
    8859     if (jj_scan_token(87)) {
    8860     jj_scanpos = xsp;
    8861     if (jj_scan_token(86)) {
    8862     jj_scanpos = xsp;
    8863     if (jj_scan_token(74)) {
    8864     jj_scanpos = xsp;
    8865     if (jj_scan_token(71)) {
    8866     jj_scanpos = xsp;
    8867     if (jj_scan_token(53)) {
    8868     jj_scanpos = xsp;
    8869     if (jj_scan_token(50)) {
    8870     jj_scanpos = xsp;
    8871     if (jj_scan_token(41)) {
    8872     jj_scanpos = xsp;
    8873     if (jj_3R_174()) return true;
    8874     }
    8875     }
    8876     }
    8877     }
    8878     }
    8879     }
    8880     }
    8881     return false;
    8882   }
    8883
    8884   final private boolean jj_3_23() {
    8885     if (jj_3R_77()) return true;
    8886     return false;
    8887   }
    8888
    8889   final private boolean jj_3R_310() {
    8890     if (jj_scan_token(MINUS)) return true;
    8891     return false;
    8892   }
    8893
    8894   final private boolean jj_3R_117() {
    8895     if (jj_scan_token(LPAREN)) return true;
    8896     if (jj_3R_65()) return true;
    8897     if (jj_scan_token(LBRACKET)) return true;
    8898     if (jj_scan_token(RBRACKET)) return true;
    8899     return false;
    8900   }
    8901
    8902   final private boolean jj_3R_77() {
    8903     Token xsp;
    8904     xsp = jj_scanpos;
    8905     if (jj_3_24()) {
    8906     jj_scanpos = xsp;
    8907     if (jj_3R_117()) {
    8908     jj_scanpos = xsp;
    8909     if (jj_3R_118()) return true;
    8910     }
    8911     }
    8912     return false;
    8913   }
    8914
    8915   final private boolean jj_3_24() {
    8916     if (jj_scan_token(LPAREN)) return true;
    8917     if (jj_3R_78()) return true;
    8918     return false;
    8919   }
    8920
    8921   final private boolean jj_3R_324() {
    8922     if (jj_3R_216()) return true;
    8923     return false;
    8924   }
    8925
    8926   final private boolean jj_3R_332() {
    8927     if (jj_scan_token(TILDE)) return true;
    8928     return false;
    8929   }
    8930
    8931   final private boolean jj_3R_323() {
    8932     if (jj_3R_334()) return true;
    8933     return false;
    8934   }
    8935
    8936   final private boolean jj_3R_322() {
    8937     Token xsp;
    8938     xsp = jj_scanpos;
    8939     if (jj_3R_332()) {
    8940     jj_scanpos = xsp;
    8941     if (jj_3R_333()) return true;
    8942     }
    8943     if (jj_3R_282()) return true;
    8944     return false;
    8945   }
    8946
    8947   final private boolean jj_3R_311() {
    8948     Token xsp;
    8949     xsp = jj_scanpos;
    8950     if (jj_3R_322()) {
    8951     jj_scanpos = xsp;
    8952     if (jj_3R_323()) {
    8953     jj_scanpos = xsp;
    8954     if (jj_3R_324()) return true;
    8955     }
    8956     }
    8957     return false;
    8958   }
    8959
    8960   final private boolean jj_3R_320() {
    8961     if (jj_scan_token(PLUS)) return true;
    8962     return false;
    8963   }
    8964
    8965   final private boolean jj_3R_308() {
    8966     Token xsp;
    8967     xsp = jj_scanpos;
    8968     if (jj_3R_320()) {
    8969     jj_scanpos = xsp;
    8970     if (jj_3R_321()) return true;
    8971     }
    8972     if (jj_3R_276()) return true;
    8973     return false;
    8974   }
    8975
    8976   final private boolean jj_3R_329() {
    8977     if (jj_scan_token(STAR)) return true;
    8978     return false;
    8979   }
    8980
    8981   final private boolean jj_3R_215() {
    8982     if (jj_scan_token(DECR)) return true;
    8983     if (jj_3R_70()) return true;
    8984     return false;
    8985   }
    8986
    8987   final private boolean jj_3R_319() {
    8988     Token xsp;
    8989     xsp = jj_scanpos;
    8990     if (jj_3R_329()) {
    8991     jj_scanpos = xsp;
    8992     if (jj_3R_330()) {
    8993     jj_scanpos = xsp;
    8994     if (jj_3R_331()) return true;
    8995     }
    8996     }
    8997     if (jj_3R_282()) return true;
    8998     return false;
    8999   }
    9000
    9001   final private boolean jj_3R_275() {
    9002     if (jj_scan_token(NE)) return true;
    9003     return false;
    9004   }
    9005
    9006   final private boolean jj_3R_214() {
    9007     if (jj_scan_token(INCR)) return true;
    9008     if (jj_3R_70()) return true;
    9009     return false;
    9010   }
    9011
    9012   final private boolean jj_3R_300() {
    9013     if (jj_3R_311()) return true;
    9014     return false;
    9015   }
    9016
    9017   final private boolean jj_3R_299() {
    9018     if (jj_3R_215()) return true;
    9019     return false;
    9020   }
    9021
    9022   final private boolean jj_3R_298() {
    9023     if (jj_3R_214()) return true;
    9024     return false;
    9025   }
    9026
    9027   public JavaParserTokenManager token_source;
    9028   public Token token, jj_nt;
    9029   private int jj_ntk;
    9030   private Token jj_scanpos, jj_lastpos;
    9031   private int jj_la;
    9032   public boolean lookingAhead = false;
    9033   private boolean jj_semLA;
    9034   private int jj_gen;
    9035   final private int[] jj_la1 = new int[133];
    9036   static private int[] jj_la1_0;
    9037   static private int[] jj_la1_1;
    9038   static private int[] jj_la1_2;
    9039   static private int[] jj_la1_3;
    9040   static {
    9041       jj_la1_0();
    9042       jj_la1_1();
    9043       jj_la1_2();
    9044       jj_la1_3();
    9045    }
    9046    private static void jj_la1_0() {
    9047       jj_la1_0 = new int[] {0x0,0x0,0x10081000,0x0,0x0,0x0,0x0,0x10001000,0x10081000,0x10081000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x510cb000,0x0,0x0,0x0,0x0,0x4000000,0x0,0x510cb000,0x4104a000,0x510cb000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,0x4000000,0x4104a000,0x4000000,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x5904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x20000,0x20000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x510cb000,0x400000,0x10081000,0x4104a000,0x510cb000,};
    9048    }
    9049    private static void jj_la1_1() {
    9050       jj_la1_1 = new int[] {0x800,0x8,0x51127140,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x4,0x0,0x0,0x591371e0,0x0,0x0,0x0,0x0,0x0,0x0,0x591371e0,0x80100a0,0x591371e0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x0,0x800000,0x240000,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,0x40000,0x100a0,0x40000,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x82240600,0x0,0x0,0x0,0x0,0x82240600,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xae7d86a2,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x511371e0,0x0,0x40,0x100a0,0x511371e0,};
    9051    }
    9052    private static void jj_la1_2() {
    9053       jj_la1_2 = new int[] {0x0,0x0,0x90080,0x0,0x0,0x0,0x40000,0x80000,0x80080,0x90080,0x0,0x0,0x0,0x200000,0x0,0x0,0x20000,0x20000,0x0,0x80,0x20000,0x291080,0x10000,0x400,0x1000,0x20000,0x0,0x0,0x291080,0x200080,0x290080,0x20000,0x100000,0x4000,0xc014e8,0xc014e8,0x20000,0x200000,0x0,0x11000,0x4000,0x20000,0x80080,0x80000,0x80000,0x0,0x200000,0x0,0x0,0x4e8,0x0,0x0,0x80,0x20000,0x0,0x1000080,0x0,0x0,0x80,0x20000,0x100000,0x100000,0x1000000,0x40000000,0x80000000,0x0,0x0,0x0,0x24000000,0x24000000,0x0,0x18200000,0x18200000,0x0,0x0,0x0,0x0,0x0,0x0,0xc004e8,0xc00000,0xc00000,0x4e8,0xc004e8,0x400,0x0,0x0,0x400,0x468,0x80,0x44400,0x68,0x0,0xc004e8,0x20000,0x200000,0x1000,0x4400,0x0,0x4000,0x4000,0x114e8,0x80000,0x80000,0x20000,0x100000,0x0,0x4e8,0x0,0x0,0x0,0x804e8,0xc004e8,0x4e8,0x904e8,0x4e8,0x20000,0x80,0x80,0xc004e8,0x0,0x0,0x2000000,0x80000,0x80,0x20000,0xc814e8,0x20000,0x90080,0x0,0x0,0x80080,0x90080,};
    9054    }
    9055    private static void jj_la1_3() {
    9056       jj_la1_3 = new int[] {0x0,0x0,0x0,0x4000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3ff800,0x3ff800,0x0,0x0,0x0,0x80,0x100,0x40,0x0,0x0,0x0,0x2000000,0x2000000,0x400,0xc,0xc,0x230,0x230,0xc,0xf,0x0,0x0,0x0,0x0,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x3ff800,0x3,0x0,0x0,0x0,0x0,0x3,0xf,0x3,0x3,0x3,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,};
    9057    }
    9058   final private JJCalls[] jj_2_rtns = new JJCalls[50];
    9059   private boolean jj_rescan = false;
    9060   private int jj_gc = 0;
    9061
    9062   public JavaParser(CharStream stream) {
    9063     token_source = new JavaParserTokenManager(stream);
    9064     token = new Token();
    9065     jj_ntk = -1;
    9066     jj_gen = 0;
    9067     for (int i = 0; i < 133; i++) jj_la1[i] = -1;
    9068     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9069   }
    9070
    9071   public void ReInit(CharStream stream) {
    9072     token_source.ReInit(stream);
    9073     token = new Token();
    9074     jj_ntk = -1;
    9075     jjtree.reset();
    9076     jj_gen = 0;
    9077     for (int i = 0; i < 133; i++) jj_la1[i] = -1;
    9078     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9079   }
    9080
    9081   public JavaParser(JavaParserTokenManager tm) {
    9082     token_source = tm;
    9083     token = new Token();
    9084     jj_ntk = -1;
    9085     jj_gen = 0;
    9086     for (int i = 0; i < 133; i++) jj_la1[i] = -1;
    9087     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9088   }
    9089
    9090   public void ReInit(JavaParserTokenManager tm) {
    9091     token_source = tm;
    9092     token = new Token();
    9093     jj_ntk = -1;
    9094     jjtree.reset();
    9095     jj_gen = 0;
    9096     for (int i = 0; i < 133; i++) jj_la1[i] = -1;
    9097     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    9098   }
    9099
    9100   final private Token jj_consume_token(int kind) throws ParseException {
    9101     Token oldToken;
    9102     if ((oldToken = token).next != null) token = token.next;
    9103     else token = token.next = token_source.getNextToken();
    9104     jj_ntk = -1;
    9105     if (token.kind == kind) {
    9106       jj_gen++;
    9107       if (++jj_gc > 100) {
    9108         jj_gc = 0;
    9109         for (int i = 0; i < jj_2_rtns.length; i++) {
    9110           JJCalls c = jj_2_rtns[i];
    9111           while (c != null) {
    9112             if (c.gen < jj_gen) c.first = null;
    9113             c = c.next;
    9114           }
    9115         }
    9116       }
    9117       return token;
    9118     }
    9119     token = oldToken;
    9120     jj_kind = kind;
    9121     throw generateParseException();
    9122   }
    9123
    9124   static private final class LookaheadSuccess extends java.lang.Error { }
    9125   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
    9126   final private boolean jj_scan_token(int kind) {
    9127     if (jj_scanpos == jj_lastpos) {
    9128       jj_la--;
    9129       if (jj_scanpos.next == null) {
    9130         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    9131       } else {
    9132         jj_lastpos = jj_scanpos = jj_scanpos.next;
    9133       }
    9134     } else {
    9135       jj_scanpos = jj_scanpos.next;
    9136     }
    9137     if (jj_rescan) {
    9138       int i = 0; Token tok = token;
    9139       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    9140       if (tok != null) jj_add_error_token(kind, i);
    9141     }
    9142     if (jj_scanpos.kind != kind) return true;
    9143     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    9144     return false;
    9145   }
    9146
    9147   final public Token getNextToken() {
    9148     if (token.next != null) token = token.next;
    9149     else token = token.next = token_source.getNextToken();
    9150     jj_ntk = -1;
    9151     jj_gen++;
    9152     return token;
    9153   }
    9154
    9155   final public Token getToken(int index) {
    9156     Token t = lookingAhead ? jj_scanpos : token;
    9157     for (int i = 0; i < index; i++) {
    9158       if (t.next != null) t = t.next;
    9159       else t = t.next = token_source.getNextToken();
    9160     }
    9161     return t;
    9162   }
    9163
    9164   final private int jj_ntk() {
    9165     if ((jj_nt=token.next) == null)
    9166       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    9167     else
    9168       return (jj_ntk = jj_nt.kind);
    9169   }
    9170
    9171   private java.util.Vector jj_expentries = new java.util.Vector();
    9172   private int[] jj_expentry;
    9173   private int jj_kind = -1;
    9174   private int[] jj_lasttokens = new int[100];
    9175   private int jj_endpos;
    9176
    9177   private void jj_add_error_token(int kind, int pos) {
    9178     if (pos >= 100) return;
    9179     if (pos == jj_endpos + 1) {
    9180       jj_lasttokens[jj_endpos++] = kind;
    9181     } else if (jj_endpos != 0) {
    9182       jj_expentry = new int[jj_endpos];
    9183       for (int i = 0; i < jj_endpos; i++) {
    9184         jj_expentry[i] = jj_lasttokens[i];
    9185       }
    9186       boolean exists = false;
    9187       for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
    9188         int[] oldentry = (int[])(e.nextElement());
    9189         if (oldentry.length == jj_expentry.length) {
    9190           exists = true;
    9191           for (int i = 0; i < jj_expentry.length; i++) {
    9192             if (oldentry[i] != jj_expentry[i]) {
    9193               exists = false;
    9194               break;
    9195             }
    9196           }
    9197           if (exists) break;
    9198         }
    9199       }
    9200       if (!exists) jj_expentries.addElement(jj_expentry);
    9201       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    9202     }
    9203   }
    9204
    9205   public ParseException generateParseException() {
    9206     jj_expentries.removeAllElements();
    9207     boolean[] la1tokens = new boolean[124];
    9208     for (int i = 0; i < 124; i++) {
    9209       la1tokens[i] = false;
    9210     }
    9211     if (jj_kind >= 0) {
    9212       la1tokens[jj_kind] = true;
    9213       jj_kind = -1;
    9214     }
    9215     for (int i = 0; i < 133; i++) {
    9216       if (jj_la1[i] == jj_gen) {
    9217         for (int j = 0; j < 32; j++) {
    9218           if ((jj_la1_0[i] & (1<<j)) != 0) {
    9219             la1tokens[j] = true;
    9220           }
    9221           if ((jj_la1_1[i] & (1<<j)) != 0) {
    9222             la1tokens[32+j] = true;
    9223           }
    9224           if ((jj_la1_2[i] & (1<<j)) != 0) {
    9225             la1tokens[64+j] = true;
    9226           }
    9227           if ((jj_la1_3[i] & (1<<j)) != 0) {
    9228             la1tokens[96+j] = true;
    9229           }
    9230         }
    9231       }
    9232     }
    9233     for (int i = 0; i < 124; i++) {
    9234       if (la1tokens[i]) {
    9235         jj_expentry = new int[1];
    9236         jj_expentry[0] = i;
    9237         jj_expentries.addElement(jj_expentry);
    9238       }
    9239     }
    9240     jj_endpos = 0;
    9241     jj_rescan_token();
    9242     jj_add_error_token(0, 0);
    9243     int[][] exptokseq = new int[jj_expentries.size()][];
    9244     for (int i = 0; i < jj_expentries.size(); i++) {
    9245       exptokseq[i] = (int[])jj_expentries.elementAt(i);
    9246     }
    9247     return new ParseException(token, exptokseq, tokenImage);
    9248   }
    9249
    9250   final public void enable_tracing() {
    9251   }
    9252
    9253   final public void disable_tracing() {
    9254   }
    9255
    9256   final private void jj_rescan_token() {
    9257     jj_rescan = true;
    9258     for (int i = 0; i < 50; i++) {
    9259     try {
    9260       JJCalls p = jj_2_rtns[i];
    9261       do {
    9262         if (p.gen > jj_gen) {
    9263           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    9264           switch (i) {
    9265             case 0: jj_3_1(); break;
    9266             case 1: jj_3_2(); break;
    9267             case 2: jj_3_3(); break;
    9268             case 3: jj_3_4(); break;
    9269             case 4: jj_3_5(); break;
    9270             case 5: jj_3_6(); break;
    9271             case 6: jj_3_7(); break;
    9272             case 7: jj_3_8(); break;
    9273             case 8: jj_3_9(); break;
    9274             case 9: jj_3_10(); break;
    9275             case 10: jj_3_11(); break;
    9276             case 11: jj_3_12(); break;
    9277             case 12: jj_3_13(); break;
    9278             case 13: jj_3_14(); break;
    9279             case 14: jj_3_15(); break;
    9280             case 15: jj_3_16(); break;
    9281             case 16: jj_3_17(); break;
    9282             case 17: jj_3_18(); break;
    9283             case 18: jj_3_19(); break;
    9284             case 19: jj_3_20(); break;
    9285             case 20: jj_3_21(); break;
    9286             case 21: jj_3_22(); break;
    9287             case 22: jj_3_23(); break;
    9288             case 23: jj_3_24(); break;
    9289             case 24: jj_3_25(); break;
    9290             case 25: jj_3_26(); break;
    9291             case 26: jj_3_27(); break;
    9292             case 27: jj_3_28(); break;
    9293             case 28: jj_3_29(); break;
    9294             case 29: jj_3_30(); break;
    9295             case 30: jj_3_31(); break;
    9296             case 31: jj_3_32(); break;
    9297             case 32: jj_3_33(); break;
    9298             case 33: jj_3_34(); break;
    9299             case 34: jj_3_35(); break;
    9300             case 35: jj_3_36(); break;
    9301             case 36: jj_3_37(); break;
    9302             case 37: jj_3_38(); break;
    9303             case 38: jj_3_39(); break;
    9304             case 39: jj_3_40(); break;
    9305             case 40: jj_3_41(); break;
    9306             case 41: jj_3_42(); break;
    9307             case 42: jj_3_43(); break;
    9308             case 43: jj_3_44(); break;
    9309             case 44: jj_3_45(); break;
    9310             case 45: jj_3_46(); break;
    9311             case 46: jj_3_47(); break;
    9312             case 47: jj_3_48(); break;
    9313             case 48: jj_3_49(); break;
    9314             case 49: jj_3_50(); break;
    9315           }
    9316         }
    9317         p = p.next;
    9318       } while (p != null);
    9319       } catch(LookaheadSuccess ls) { }
    9320     }
    9321     jj_rescan = false;
    9322   }
    9323
    9324   final private void jj_save(int index, int xla) {
    9325     JJCalls p = jj_2_rtns[index];
    9326     while (p.gen > jj_gen) {
    9327       if (p.next == null) { p = p.next = new JJCalls(); break; }
    9328       p = p.next;
    9329     }
    9330     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    9331   }
    9332
    9333   static final class JJCalls {
    9334     int gen;
    9335     Token first;
    9336     int arg;
    9337     JJCalls next;
    9338   }
    9339
    9340 }