View Javadoc

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