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