View Javadoc

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