View Javadoc

    1   /* Generated By:JavaCC: Do not edit this line. SimpleParser.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 SimpleParser implements JavaParser, SimpleParserConstants {
    10     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 SimpleParser( 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     switch (jj_nt.kind) {
    152     case PACKAGE:
    153       PackageDeclaration();
    154       break;
    155     default:
    156       jj_la1[0] = jj_gen;
    157       ;
    158     }
    159     label_1:
    160     while (true) {
    161       switch (jj_nt.kind) {
    162       case IMPORT:
    163         ;
    164         break;
    165       default:
    166         jj_la1[1] = jj_gen;
    167         break label_1;
    168       }
    169       ImportDeclaration();
    170     }
    171     label_2:
    172     while (true) {
    173       switch (jj_nt.kind) {
    174       case ABSTRACT:
    175       case CLASS:
    176       case FINAL:
    177       case INTERFACE:
    178       case PUBLIC:
    179       case STRICTFP:
    180       case SEMICOLON:
    181         ;
    182         break;
    183       default:
    184         jj_la1[2] = jj_gen;
    185         break label_2;
    186       }
    187       TypeDeclaration();
    188     }
    189     jj_consume_token(0);
    190       // sourceClass must know about the CompilationUnit node
    191       // if it wants to mutate or print the code
    192       // In SimpleParser we can't use nodes
    193
    194     if( _sourceClassStack.size() != 0 ) {
    195        {if (true) throw new IllegalStateException("There should be no more classes on the stack:" + _sourceClassStack.size());}
    196     }
    197   }
    198
    199   final public void PackageDeclaration() throws ParseException {
    200     jj_consume_token(PACKAGE);
    201     _packageName = Name();
    202     jj_consume_token(SEMICOLON);
    203      _sourceClass.setContainingPackage( _packageName );
    204   }
    205
    206   final public void ImportDeclaration() throws ParseException {
    207    String importedElement;
    208    boolean isPackage = false;
    209     jj_consume_token(IMPORT);
    210     importedElement = Name();
    211     switch (jj_nt.kind) {
    212     case DOT:
    213       jj_consume_token(DOT);
    214       jj_consume_token(STAR);
    215      isPackage = true;
    216       break;
    217     default:
    218       jj_la1[3] = jj_gen;
    219       ;
    220     }
    221     jj_consume_token(SEMICOLON);
    222      if( isPackage ) {
    223         _sourceClass.addImportedPackage(importedElement);
    224      } else {
    225         _sourceClass.addImportedClass(importedElement);
    226      }
    227   }
    228
    229   final public void TypeDeclaration() throws ParseException {
    230     if (jj_2_1(2147483647)) {
    231       ClassDeclaration();
    232     _hasParsedMain = true;
    233     } else {
    234       switch (jj_nt.kind) {
    235       case ABSTRACT:
    236       case INTERFACE:
    237       case PUBLIC:
    238       case STRICTFP:
    239         InterfaceDeclaration();
    240     _hasParsedMain = true;
    241         break;
    242       case SEMICOLON:
    243         jj_consume_token(SEMICOLON);
    244         break;
    245       default:
    246         jj_la1[4] = jj_gen;
    247         jj_consume_token(-1);
    248         throw new ParseException();
    249       }
    250     }
    251   }
    252
    253 /*
    254  * Declaration syntax follows.
    255  */
    256
    257 /*
    258 Javadoc is stored in special tokens, and will either be
    259 attached to the first modifier token (if there are any modifiers)
    260 or to the first token in UnmodifiedClassDeclaration
    261 */
    262   final public void ClassDeclaration() throws ParseException {
    263    SourceClass sourceClass = pushAndGet();
    264    Token t = null;
    265     label_3:
    266     while (true) {
    267       switch (jj_nt.kind) {
    268       case ABSTRACT:
    269       case FINAL:
    270       case PUBLIC:
    271       case STRICTFP:
    272         ;
    273         break;
    274       default:
    275         jj_la1[5] = jj_gen;
    276         break label_3;
    277       }
    278       switch (jj_nt.kind) {
    279       case ABSTRACT:
    280         t = jj_consume_token(ABSTRACT);
    281        setToken(sourceClass, t);
    282        sourceClass.addModifier( Modifier.ABSTRACT );
    283         break;
    284       case FINAL:
    285         t = jj_consume_token(FINAL);
    286        setToken(sourceClass, t);
    287        sourceClass.addModifier( Modifier.FINAL );
    288         break;
    289       case PUBLIC:
    290         t = jj_consume_token(PUBLIC);
    291        setToken(sourceClass, t);
    292        sourceClass.addModifier( Modifier.PUBLIC );
    293         break;
    294       case STRICTFP:
    295         t = jj_consume_token(STRICTFP);
    296        setToken(sourceClass, t);
    297        sourceClass.addModifier( Modifier.STRICT );
    298         break;
    299       default:
    300         jj_la1[6] = jj_gen;
    301         jj_consume_token(-1);
    302         throw new ParseException();
    303       }
    304     }
    305     UnmodifiedClassDeclaration();
    306      popAndAddInner();
    307   }
    308
    309   final public void UnmodifiedClassDeclaration() throws ParseException {
    310    // Get a ref to the containing class
    311    SourceClass sourceClass = currentClass();
    312
    313    Token ct;
    314    Token name = null;
    315    String superclass = null;
    316     ct = jj_consume_token(CLASS);
    317         if(sourceClass!=null) {
    318             setToken( sourceClass, ct );
    319             sourceClass.setInterface( false );
    320         }
    321     name = jj_consume_token(IDENTIFIER);
    322     if(sourceClass.isInner()) {
    323         sourceClass.setName(name.image);
    324         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
    325         _xJavaDoc.addSourceClass( sourceClass );
    326     } else {
    327         sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
    328         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
    329         _xJavaDoc.addSourceClass( sourceClass );
    330         sourceClass.resolveImportedClasses();
    331
    332         // we're adding to xjavadoc in case we're an "extra" class (XJD-8).
    333         _xJavaDoc.addSourceClass(sourceClass);
    334     }
    335     switch (jj_nt.kind) {
    336     case EXTENDS:
    337       jj_consume_token(EXTENDS);
    338       superclass = Name();
    339       break;
    340     default:
    341       jj_la1[7] = jj_gen;
    342       ;
    343     }
    344     switch (jj_nt.kind) {
    345     case IMPLEMENTS:
    346       jj_consume_token(IMPLEMENTS);
    347       Interfaces_NameList();
    348       break;
    349     default:
    350       jj_la1[8] = jj_gen;
    351       ;
    352     }
    353     ClassBody();
    354     if( superclass != null ) {
    355         sourceClass.setSuperclass(superclass);
    356     } else {
    357         sourceClass.setSuperclass("java.lang.Object");
    358     }
    359   }
    360
    361   final public void ClassBody() throws ParseException {
    362     jj_consume_token(LBRACE);
    363     label_4:
    364     while (true) {
    365       switch (jj_nt.kind) {
    366       case ABSTRACT:
    367       case BOOLEAN:
    368       case BYTE:
    369       case CHAR:
    370       case CLASS:
    371       case DOUBLE:
    372       case FINAL:
    373       case FLOAT:
    374       case INT:
    375       case INTERFACE:
    376       case LONG:
    377       case NATIVE:
    378       case PRIVATE:
    379       case PROTECTED:
    380       case PUBLIC:
    381       case SHORT:
    382       case STATIC:
    383       case SYNCHRONIZED:
    384       case TRANSIENT:
    385       case VOID:
    386       case VOLATILE:
    387       case STRICTFP:
    388       case IDENTIFIER:
    389       case LBRACE:
    390         ;
    391         break;
    392       default:
    393         jj_la1[9] = jj_gen;
    394         break label_4;
    395       }
    396       ClassBodyDeclaration();
    397     }
    398     jj_consume_token(RBRACE);
    399   }
    400
    401   final public void NestedClassDeclaration() throws ParseException {
    402    SourceClass sourceClass = pushAndGet();
    403    Token t;
    404     label_5:
    405     while (true) {
    406       switch (jj_nt.kind) {
    407       case ABSTRACT:
    408       case FINAL:
    409       case PRIVATE:
    410       case PROTECTED:
    411       case PUBLIC:
    412       case STATIC:
    413       case STRICTFP:
    414         ;
    415         break;
    416       default:
    417         jj_la1[10] = jj_gen;
    418         break label_5;
    419       }
    420       switch (jj_nt.kind) {
    421       case STATIC:
    422         t = jj_consume_token(STATIC);
    423        sourceClass.addModifier( Modifier.STATIC );
    424        sourceClass.setToken( t );
    425         break;
    426       case ABSTRACT:
    427         t = jj_consume_token(ABSTRACT);
    428        sourceClass.addModifier( Modifier.ABSTRACT );
    429        sourceClass.setToken( t );
    430         break;
    431       case FINAL:
    432         t = jj_consume_token(FINAL);
    433        sourceClass.addModifier( Modifier.FINAL );
    434        sourceClass.setToken( t );
    435         break;
    436       case PUBLIC:
    437         t = jj_consume_token(PUBLIC);
    438        sourceClass.addModifier( Modifier.PUBLIC );
    439        sourceClass.setToken( t );
    440         break;
    441       case PROTECTED:
    442         t = jj_consume_token(PROTECTED);
    443        sourceClass.addModifier( Modifier.PROTECTED );
    444        sourceClass.setToken( t );
    445         break;
    446       case PRIVATE:
    447         t = jj_consume_token(PRIVATE);
    448        sourceClass.addModifier( Modifier.PRIVATE );
    449        sourceClass.setToken( t );
    450         break;
    451       case STRICTFP:
    452         t = jj_consume_token(STRICTFP);
    453        sourceClass.addModifier( Modifier.STRICT );
    454        sourceClass.setToken( t );
    455         break;
    456       default:
    457         jj_la1[11] = jj_gen;
    458         jj_consume_token(-1);
    459         throw new ParseException();
    460       }
    461     }
    462     UnmodifiedClassDeclaration();
    463     popAndAddInner();
    464   }
    465
    466   final public void ClassBodyDeclaration() throws ParseException {
    467    SourceClass sourceClass = currentClass();
    468     if (jj_2_2(2)) {
    469       Initializer();
    470     } else if (jj_2_3(2147483647)) {
    471       NestedClassDeclaration();
    472     } else if (jj_2_4(2147483647)) {
    473       NestedInterfaceDeclaration();
    474     } else if (jj_2_5(2147483647)) {
    475       ConstructorDeclaration();
    476     } else if (jj_2_6(2147483647)) {
    477       MethodDeclaration();
    478     } else {
    479       switch (jj_nt.kind) {
    480       case BOOLEAN:
    481       case BYTE:
    482       case CHAR:
    483       case DOUBLE:
    484       case FINAL:
    485       case FLOAT:
    486       case INT:
    487       case LONG:
    488       case PRIVATE:
    489       case PROTECTED:
    490       case PUBLIC:
    491       case SHORT:
    492       case STATIC:
    493       case TRANSIENT:
    494       case VOLATILE:
    495       case IDENTIFIER:
    496         FieldDeclaration();
    497         break;
    498       default:
    499         jj_la1[12] = jj_gen;
    500         jj_consume_token(-1);
    501         throw new ParseException();
    502       }
    503     }
    504   }
    505
    506 // This production is to determine lookahead only.
    507   final public void MethodDeclarationLookahead() throws ParseException {
    508     label_6:
    509     while (true) {
    510       switch (jj_nt.kind) {
    511       case ABSTRACT:
    512       case FINAL:
    513       case NATIVE:
    514       case PRIVATE:
    515       case PROTECTED:
    516       case PUBLIC:
    517       case STATIC:
    518       case SYNCHRONIZED:
    519       case STRICTFP:
    520         ;
    521         break;
    522       default:
    523         jj_la1[13] = jj_gen;
    524         break label_6;
    525       }
    526       switch (jj_nt.kind) {
    527       case PUBLIC:
    528         jj_consume_token(PUBLIC);
    529         break;
    530       case PROTECTED:
    531         jj_consume_token(PROTECTED);
    532         break;
    533       case PRIVATE:
    534         jj_consume_token(PRIVATE);
    535         break;
    536       case STATIC:
    537         jj_consume_token(STATIC);
    538         break;
    539       case ABSTRACT:
    540         jj_consume_token(ABSTRACT);
    541         break;
    542       case FINAL:
    543         jj_consume_token(FINAL);
    544         break;
    545       case NATIVE:
    546         jj_consume_token(NATIVE);
    547         break;
    548       case SYNCHRONIZED:
    549         jj_consume_token(SYNCHRONIZED);
    550         break;
    551       case STRICTFP:
    552         jj_consume_token(STRICTFP);
    553         break;
    554       default:
    555         jj_la1[14] = jj_gen;
    556         jj_consume_token(-1);
    557         throw new ParseException();
    558       }
    559     }
    560     ResultType(null);
    561     jj_consume_token(IDENTIFIER);
    562     jj_consume_token(LPAREN);
    563   }
    564
    565   final public void InterfaceDeclaration() throws ParseException {
    566    SourceClass sourceClass = pushAndGet();
    567    Token t = null;
    568     label_7:
    569     while (true) {
    570       switch (jj_nt.kind) {
    571       case ABSTRACT:
    572       case PUBLIC:
    573       case STRICTFP:
    574         ;
    575         break;
    576       default:
    577         jj_la1[15] = jj_gen;
    578         break label_7;
    579       }
    580       switch (jj_nt.kind) {
    581       case ABSTRACT:
    582         t = jj_consume_token(ABSTRACT);
    583        sourceClass.addModifier( Modifier.ABSTRACT );
    584        sourceClass.setToken( t );
    585         break;
    586       case PUBLIC:
    587         t = jj_consume_token(PUBLIC);
    588        sourceClass.addModifier( Modifier.PUBLIC );
    589        sourceClass.setToken( t );
    590         break;
    591       case STRICTFP:
    592         t = jj_consume_token(STRICTFP);
    593        sourceClass.addModifier( Modifier.STRICT );
    594        sourceClass.setToken( t );
    595         break;
    596       default:
    597         jj_la1[16] = jj_gen;
    598         jj_consume_token(-1);
    599         throw new ParseException();
    600       }
    601     }
    602     UnmodifiedInterfaceDeclaration();
    603      popAndAddInner();
    604   }
    605
    606   final public void NestedInterfaceDeclaration() throws ParseException {
    607    SourceClass sourceClass = pushAndGet();
    608    Token t;
    609     label_8:
    610     while (true) {
    611       switch (jj_nt.kind) {
    612       case ABSTRACT:
    613       case FINAL:
    614       case PRIVATE:
    615       case PROTECTED:
    616       case PUBLIC:
    617       case STATIC:
    618       case STRICTFP:
    619         ;
    620         break;
    621       default:
    622         jj_la1[17] = jj_gen;
    623         break label_8;
    624       }
    625       switch (jj_nt.kind) {
    626       case STATIC:
    627         t = jj_consume_token(STATIC);
    628        sourceClass.addModifier( Modifier.STATIC );
    629        sourceClass.setToken( t );
    630         break;
    631       case ABSTRACT:
    632         t = jj_consume_token(ABSTRACT);
    633        sourceClass.addModifier( Modifier.ABSTRACT );
    634        sourceClass.setToken( t );
    635         break;
    636       case FINAL:
    637         t = jj_consume_token(FINAL);
    638        sourceClass.addModifier( Modifier.FINAL );
    639        sourceClass.setToken( t );
    640         break;
    641       case PUBLIC:
    642         t = jj_consume_token(PUBLIC);
    643        sourceClass.addModifier( Modifier.PUBLIC );
    644        sourceClass.setToken( t );
    645         break;
    646       case PROTECTED:
    647         t = jj_consume_token(PROTECTED);
    648        sourceClass.addModifier( Modifier.PROTECTED );
    649        sourceClass.setToken( t );
    650         break;
    651       case PRIVATE:
    652         t = jj_consume_token(PRIVATE);
    653        sourceClass.addModifier( Modifier.PRIVATE );
    654        sourceClass.setToken( t );
    655         break;
    656       case STRICTFP:
    657         t = jj_consume_token(STRICTFP);
    658        sourceClass.addModifier( Modifier.STRICT );
    659        sourceClass.setToken( t );
    660         break;
    661       default:
    662         jj_la1[18] = jj_gen;
    663         jj_consume_token(-1);
    664         throw new ParseException();
    665       }
    666     }
    667     UnmodifiedInterfaceDeclaration();
    668     popAndAddInner();
    669   }
    670
    671   final public void UnmodifiedInterfaceDeclaration() throws ParseException {
    672    SourceClass sourceClass = currentClass();
    673    Token it;
    674    Token name = null;
    675     it = jj_consume_token(INTERFACE);
    676     name = jj_consume_token(IDENTIFIER);
    677       // interfaces are always abstract
    678       sourceClass.addModifier( Modifier.ABSTRACT );
    679
    680       if(sourceClass.isInner()) {
    681         sourceClass.setName(name.image);
    682         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
    683         _xJavaDoc.addSourceClass( sourceClass );
    684       } else {
    685         sourceClass.setQualifiedName(Util.getQualifiedNameFor(_packageName,name.image));
    686         _xJavaDoc.addPackageMaybe( _packageName ).addClass(sourceClass);
    687         _xJavaDoc.addSourceClass( sourceClass );
    688         sourceClass.resolveImportedClasses();
    689       }
    690
    691       sourceClass.setInterface( true );
    692       setToken(sourceClass,it);
    693     switch (jj_nt.kind) {
    694     case EXTENDS:
    695       jj_consume_token(EXTENDS);
    696       Interfaces_NameList();
    697       break;
    698     default:
    699       jj_la1[19] = jj_gen;
    700       ;
    701     }
    702     jj_consume_token(LBRACE);
    703     label_9:
    704     while (true) {
    705       switch (jj_nt.kind) {
    706       case ABSTRACT:
    707       case BOOLEAN:
    708       case BYTE:
    709       case CHAR:
    710       case CLASS:
    711       case DOUBLE:
    712       case FINAL:
    713       case FLOAT:
    714       case INT:
    715       case INTERFACE:
    716       case LONG:
    717       case NATIVE:
    718       case PRIVATE:
    719       case PROTECTED:
    720       case PUBLIC:
    721       case SHORT:
    722       case STATIC:
    723       case SYNCHRONIZED:
    724       case TRANSIENT:
    725       case VOID:
    726       case VOLATILE:
    727       case STRICTFP:
    728       case IDENTIFIER:
    729         ;
    730         break;
    731       default:
    732         jj_la1[20] = jj_gen;
    733         break label_9;
    734       }
    735       InterfaceMemberDeclaration();
    736     }
    737     jj_consume_token(RBRACE);
    738     if(sourceClass.isInner()) {
    739         sourceClass.setName(name.image);
    740     }
    741   }
    742
    743   final public void InterfaceMemberDeclaration() throws ParseException {
    744     if (jj_2_7(2147483647)) {
    745       NestedClassDeclaration();
    746     } else if (jj_2_8(2147483647)) {
    747       NestedInterfaceDeclaration();
    748     } else if (jj_2_9(2147483647)) {
    749       MethodDeclaration();
    750     } else {
    751       switch (jj_nt.kind) {
    752       case BOOLEAN:
    753       case BYTE:
    754       case CHAR:
    755       case DOUBLE:
    756       case FINAL:
    757       case FLOAT:
    758       case INT:
    759       case LONG:
    760       case PRIVATE:
    761       case PROTECTED:
    762       case PUBLIC:
    763       case SHORT:
    764       case STATIC:
    765       case TRANSIENT:
    766       case VOLATILE:
    767       case IDENTIFIER:
    768         FieldDeclaration();
    769         break;
    770       default:
    771         jj_la1[21] = jj_gen;
    772         jj_consume_token(-1);
    773         throw new ParseException();
    774       }
    775     }
    776   }
    777
    778   final public void FieldDeclaration() throws ParseException {
    779    SourceClass sourceClass = currentClass();
    780
    781    /* NOTE: We also support lame style like
    782
    783    private static int a,b,c,d;
    784
    785    They should share the same javadoc, type and modifiers
    786    */
    787
    788    Token t = null;
    789    FieldImpl fieldImpl = null;
    790    fieldImpl = new FieldImpl(sourceClass, _tagFactory);
    791     label_10:
    792     while (true) {
    793       switch (jj_nt.kind) {
    794       case FINAL:
    795       case PRIVATE:
    796       case PROTECTED:
    797       case PUBLIC:
    798       case STATIC:
    799       case TRANSIENT:
    800       case VOLATILE:
    801         ;
    802         break;
    803       default:
    804         jj_la1[22] = jj_gen;
    805         break label_10;
    806       }
    807       switch (jj_nt.kind) {
    808       case PUBLIC:
    809         t = jj_consume_token(PUBLIC);
    810        fieldImpl.addModifier( Modifier.PUBLIC );
    811        setToken(fieldImpl,t);
    812         break;
    813       case PROTECTED:
    814         t = jj_consume_token(PROTECTED);
    815        fieldImpl.addModifier( Modifier.PROTECTED );
    816        setToken(fieldImpl,t);
    817         break;
    818       case PRIVATE:
    819         t = jj_consume_token(PRIVATE);
    820        fieldImpl.addModifier( Modifier.PRIVATE );
    821        setToken(fieldImpl,t);
    822         break;
    823       case STATIC:
    824         t = jj_consume_token(STATIC);
    825        fieldImpl.addModifier( Modifier.STATIC );
    826        setToken(fieldImpl,t);
    827         break;
    828       case FINAL:
    829         t = jj_consume_token(FINAL);
    830        fieldImpl.addModifier( Modifier.FINAL );
    831        setToken(fieldImpl,t);
    832         break;
    833       case TRANSIENT:
    834         t = jj_consume_token(TRANSIENT);
    835        fieldImpl.addModifier( Modifier.TRANSIENT );
    836        setToken(fieldImpl,t);
    837         break;
    838       case VOLATILE:
    839         t = jj_consume_token(VOLATILE);
    840        fieldImpl.addModifier( Modifier.VOLATILE );
    841        setToken(fieldImpl,t);
    842         break;
    843       default:
    844         jj_la1[23] = jj_gen;
    845         jj_consume_token(-1);
    846         throw new ParseException();
    847       }
    848     }
    849     Field_Type(fieldImpl);
    850     FieldDeclarator(fieldImpl);
    851     label_11:
    852     while (true) {
    853       switch (jj_nt.kind) {
    854       case COMMA:
    855         ;
    856         break;
    857       default:
    858         jj_la1[24] = jj_gen;
    859         break label_11;
    860       }
    861       jj_consume_token(COMMA);
    862         FieldImpl badProgrammingStyleFieldImpl = new FieldImpl(sourceClass, _tagFactory);
    863         badProgrammingStyleFieldImpl.setType(fieldImpl.getTypeAsString());
    864       FieldDeclarator(badProgrammingStyleFieldImpl);
    865         sourceClass.addField(badProgrammingStyleFieldImpl);
    866     }
    867     jj_consume_token(SEMICOLON);
    868     // we must add the field after parsing the field because the name must be set
    869     sourceClass.addField(fieldImpl);
    870   }
    871
    872   final public void FieldDeclarator(FieldImpl fieldImpl) throws ParseException {
    873     Field_VariableDeclaratorId(fieldImpl);
    874     switch (jj_nt.kind) {
    875     case ASSIGN:
    876       jj_consume_token(ASSIGN);
    877       VariableInitializer();
    878       break;
    879     default:
    880       jj_la1[25] = jj_gen;
    881       ;
    882     }
    883   }
    884
    885   final public void VariableDeclarator() throws ParseException {
    886     VariableDeclaratorId();
    887     switch (jj_nt.kind) {
    888     case ASSIGN:
    889       jj_consume_token(ASSIGN);
    890       VariableInitializer();
    891       break;
    892     default:
    893       jj_la1[26] = jj_gen;
    894       ;
    895     }
    896   }
    897
    898   final public void Field_VariableDeclaratorId(FieldImpl fieldImpl) throws ParseException {
    899    Token t = null;
    900     t = jj_consume_token(IDENTIFIER);
    901     label_12:
    902     while (true) {
    903       switch (jj_nt.kind) {
    904       case LBRACKET:
    905         ;
    906         break;
    907       default:
    908         jj_la1[27] = jj_gen;
    909         break label_12;
    910       }
    911       jj_consume_token(LBRACKET);
    912       jj_consume_token(RBRACKET);
    913                              fieldImpl.setDimension(fieldImpl.getDimension() + 1);
    914     }
    915      fieldImpl.setName( t.image );
    916   }
    917
    918   final public void Parameter_VariableDeclaratorId() throws ParseException {
    919    Token t = null;
    920     t = jj_consume_token(IDENTIFIER);
    921     label_13:
    922     while (true) {
    923       switch (jj_nt.kind) {
    924       case LBRACKET:
    925         ;
    926         break;
    927       default:
    928         jj_la1[28] = jj_gen;
    929         break label_13;
    930       }
    931       jj_consume_token(LBRACKET);
    932       jj_consume_token(RBRACKET);
    933                              _parameter.dimension++;
    934     }
    935      _parameter.name = t.image;
    936   }
    937
    938   final public void VariableDeclaratorId() throws ParseException {
    939     jj_consume_token(IDENTIFIER);
    940     label_14:
    941     while (true) {
    942       switch (jj_nt.kind) {
    943       case LBRACKET:
    944         ;
    945         break;
    946       default:
    947         jj_la1[29] = jj_gen;
    948         break label_14;
    949       }
    950       jj_consume_token(LBRACKET);
    951       jj_consume_token(RBRACKET);
    952     }
    953   }
    954
    955   final public void VariableInitializer() throws ParseException {
    956     switch (jj_nt.kind) {
    957     case LBRACE:
    958       ArrayInitializer();
    959       break;
    960     case BOOLEAN:
    961     case BYTE:
    962     case CHAR:
    963     case DOUBLE:
    964     case FALSE:
    965     case FLOAT:
    966     case INT:
    967     case LONG:
    968     case NEW:
    969     case NULL:
    970     case SHORT:
    971     case SUPER:
    972     case THIS:
    973     case TRUE:
    974     case VOID:
    975     case INTEGER_LITERAL:
    976     case FLOATING_POINT_LITERAL:
    977     case CHARACTER_LITERAL:
    978     case STRING_LITERAL:
    979     case IDENTIFIER:
    980     case LPAREN:
    981     case BANG:
    982     case TILDE:
    983     case INCR:
    984     case DECR:
    985     case PLUS:
    986     case MINUS:
    987       Expression();
    988       break;
    989     default:
    990       jj_la1[30] = jj_gen;
    991       jj_consume_token(-1);
    992       throw new ParseException();
    993     }
    994   }
    995
    996   final public void ArrayInitializer() throws ParseException {
    997     jj_consume_token(LBRACE);
    998     switch (jj_nt.kind) {
    999     case BOOLEAN:
    1000     case BYTE:
    1001     case CHAR:
    1002     case DOUBLE:
    1003     case FALSE:
    1004     case FLOAT:
    1005     case INT:
    1006     case LONG:
    1007     case NEW:
    1008     case NULL:
    1009     case SHORT:
    1010     case SUPER:
    1011     case THIS:
    1012     case TRUE:
    1013     case VOID:
    1014     case INTEGER_LITERAL:
    1015     case FLOATING_POINT_LITERAL:
    1016     case CHARACTER_LITERAL:
    1017     case STRING_LITERAL:
    1018     case IDENTIFIER:
    1019     case LPAREN:
    1020     case LBRACE:
    1021     case BANG:
    1022     case TILDE:
    1023     case INCR:
    1024     case DECR:
    1025     case PLUS:
    1026     case MINUS:
    1027       VariableInitializer();
    1028       label_15:
    1029       while (true) {
    1030         if (jj_2_10(2)) {
    1031           ;
    1032         } else {
    1033           break label_15;
    1034         }
    1035         jj_consume_token(COMMA);
    1036         VariableInitializer();
    1037       }
    1038       break;
    1039     default:
    1040       jj_la1[31] = jj_gen;
    1041       ;
    1042     }
    1043     switch (jj_nt.kind) {
    1044     case COMMA:
    1045       jj_consume_token(COMMA);
    1046       break;
    1047     default:
    1048       jj_la1[32] = jj_gen;
    1049       ;
    1050     }
    1051     jj_consume_token(RBRACE);
    1052   }
    1053
    1054   final public void MethodDeclaration() throws ParseException {
    1055    SourceClass sourceClass = currentClass();
    1056
    1057    Token t = null;
    1058    String exceptions = null;
    1059
    1060    //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
    1061    MethodImpl methodImpl = null;
    1062
    1063     if(sourceClass!=null) {
    1064        methodImpl = new MethodImpl(sourceClass, _tagFactory);
    1065     }
    1066     label_16:
    1067     while (true) {
    1068       switch (jj_nt.kind) {
    1069       case ABSTRACT:
    1070       case FINAL:
    1071       case NATIVE:
    1072       case PRIVATE:
    1073       case PROTECTED:
    1074       case PUBLIC:
    1075       case STATIC:
    1076       case SYNCHRONIZED:
    1077       case STRICTFP:
    1078         ;
    1079         break;
    1080       default:
    1081         jj_la1[33] = jj_gen;
    1082         break label_16;
    1083       }
    1084       switch (jj_nt.kind) {
    1085       case PUBLIC:
    1086         t = jj_consume_token(PUBLIC);
    1087         if(methodImpl!=null) {
    1088             methodImpl.addModifier( Modifier.PUBLIC );
    1089             setToken( methodImpl, t );
    1090         }
    1091         break;
    1092       case PROTECTED:
    1093         t = jj_consume_token(PROTECTED);
    1094         if(methodImpl!=null) {
    1095             methodImpl.addModifier( Modifier.PROTECTED );
    1096             setToken( methodImpl, t );
    1097         }
    1098         break;
    1099       case PRIVATE:
    1100         t = jj_consume_token(PRIVATE);
    1101         if(methodImpl!=null) {
    1102             methodImpl.addModifier( Modifier.PRIVATE );
    1103             setToken( methodImpl, t );
    1104         }
    1105         break;
    1106       case STATIC:
    1107         t = jj_consume_token(STATIC);
    1108         if(methodImpl!=null) {
    1109             methodImpl.addModifier( Modifier.STATIC );
    1110             setToken( methodImpl, t );
    1111         }
    1112         break;
    1113       case ABSTRACT:
    1114         t = jj_consume_token(ABSTRACT);
    1115         if(methodImpl!=null) {
    1116             methodImpl.addModifier( Modifier.ABSTRACT );
    1117             setToken( methodImpl, t );
    1118         }
    1119         break;
    1120       case FINAL:
    1121         t = jj_consume_token(FINAL);
    1122         if(methodImpl!=null) {
    1123             methodImpl.addModifier( Modifier.FINAL );
    1124             setToken( methodImpl, t );
    1125         }
    1126         break;
    1127       case NATIVE:
    1128         t = jj_consume_token(NATIVE);
    1129         if(methodImpl!=null) {
    1130             methodImpl.addModifier( Modifier.NATIVE );
    1131             setToken( methodImpl, t );
    1132         }
    1133         break;
    1134       case SYNCHRONIZED:
    1135         t = jj_consume_token(SYNCHRONIZED);
    1136         if(methodImpl!=null) {
    1137             methodImpl.addModifier( Modifier.SYNCHRONIZED );
    1138             setToken( methodImpl, t );
    1139         }
    1140         break;
    1141       case STRICTFP:
    1142         t = jj_consume_token(STRICTFP);
    1143         if(methodImpl!=null) {
    1144             methodImpl.addModifier( Modifier.STRICT );
    1145             setToken( methodImpl, t );
    1146         }
    1147         break;
    1148       default:
    1149         jj_la1[34] = jj_gen;
    1150         jj_consume_token(-1);
    1151         throw new ParseException();
    1152       }
    1153     }
    1154     ResultType(methodImpl);
    1155     MethodDeclarator(methodImpl);
    1156     switch (jj_nt.kind) {
    1157     case THROWS:
    1158       jj_consume_token(THROWS);
    1159       ExecutableMemberThrows_NameList(methodImpl);
    1160       break;
    1161     default:
    1162       jj_la1[35] = jj_gen;
    1163       ;
    1164     }
    1165     switch (jj_nt.kind) {
    1166     case LBRACE:
    1167       Method_Block();
    1168       break;
    1169     case SEMICOLON:
    1170       jj_consume_token(SEMICOLON);
    1171       break;
    1172     default:
    1173       jj_la1[36] = jj_gen;
    1174       jj_consume_token(-1);
    1175       throw new ParseException();
    1176     }
    1177     // we must add the method after the fields are in, because the
    1178     // signature must be complete when adding
    1179     sourceClass.addMethod(methodImpl);
    1180   }
    1181
    1182   final public void MethodDeclarator(MethodImpl methodImpl) throws ParseException {
    1183    Token t = null;
    1184     t = jj_consume_token(IDENTIFIER);
    1185      if( methodImpl != null ) {
    1186         methodImpl.setName( t.image );
    1187      }
    1188     FormalParameters(methodImpl);
    1189     label_17:
    1190     while (true) {
    1191       switch (jj_nt.kind) {
    1192       case LBRACKET:
    1193         ;
    1194         break;
    1195       default:
    1196         jj_la1[37] = jj_gen;
    1197         break label_17;
    1198       }
    1199       jj_consume_token(LBRACKET);
    1200       jj_consume_token(RBRACKET);
    1201      methodImpl.setReturnDimension( methodImpl.getReturnType().getDimension() + 1 );
    1202     }
    1203   }
    1204
    1205   final public void FormalParameters(AbstractExecutableMember member) throws ParseException {
    1206     jj_consume_token(LPAREN);
    1207     switch (jj_nt.kind) {
    1208     case BOOLEAN:
    1209     case BYTE:
    1210     case CHAR:
    1211     case DOUBLE:
    1212     case FINAL:
    1213     case FLOAT:
    1214     case INT:
    1215     case LONG:
    1216     case SHORT:
    1217     case IDENTIFIER:
    1218       FormalParameter(member);
    1219       label_18:
    1220       while (true) {
    1221         switch (jj_nt.kind) {
    1222         case COMMA:
    1223           ;
    1224           break;
    1225         default:
    1226           jj_la1[38] = jj_gen;
    1227           break label_18;
    1228         }
    1229         jj_consume_token(COMMA);
    1230         FormalParameter(member);
    1231       }
    1232       break;
    1233     default:
    1234       jj_la1[39] = jj_gen;
    1235       ;
    1236     }
    1237     jj_consume_token(RPAREN);
    1238   }
    1239
    1240   final public void FormalParameter(AbstractExecutableMember member) throws ParseException {
    1241    if(member != null) {
    1242       // reset the _parameter helper's dimension
    1243       _parameter.dimension = 0;
    1244    }
    1245     switch (jj_nt.kind) {
    1246     case FINAL:
    1247       jj_consume_token(FINAL);
    1248       break;
    1249     default:
    1250       jj_la1[40] = jj_gen;
    1251       ;
    1252     }
    1253     Parameter_Type();
    1254     Parameter_VariableDeclaratorId();
    1255      if( member != null ) {
    1256         member.addParameterData(_parameter.type, _parameter.name, _parameter.dimension);
    1257      }
    1258   }
    1259
    1260   final public void ConstructorDeclaration() throws ParseException {
    1261    SourceClass sourceClass = currentClass();
    1262    Token t = null;
    1263    ConstructorImpl constructor = constructor = new ConstructorImpl(sourceClass, _tagFactory);
    1264     switch (jj_nt.kind) {
    1265     case PRIVATE:
    1266     case PROTECTED:
    1267     case PUBLIC:
    1268       switch (jj_nt.kind) {
    1269       case PUBLIC:
    1270         t = jj_consume_token(PUBLIC);
    1271        constructor.addModifier( Modifier.PUBLIC );
    1272        setToken( constructor, t );
    1273         break;
    1274       case PROTECTED:
    1275         t = jj_consume_token(PROTECTED);
    1276        constructor.addModifier( Modifier.PROTECTED );
    1277        setToken( constructor, t );
    1278         break;
    1279       case PRIVATE:
    1280         t = jj_consume_token(PRIVATE);
    1281        constructor.addModifier( Modifier.PRIVATE );
    1282        setToken( constructor, t );
    1283         break;
    1284       default:
    1285         jj_la1[41] = jj_gen;
    1286         jj_consume_token(-1);
    1287         throw new ParseException();
    1288       }
    1289       break;
    1290     default:
    1291       jj_la1[42] = jj_gen;
    1292       ;
    1293     }
    1294     jj_consume_token(IDENTIFIER);
    1295     FormalParameters(constructor);
    1296     switch (jj_nt.kind) {
    1297     case THROWS:
    1298       jj_consume_token(THROWS);
    1299       ExecutableMemberThrows_NameList(constructor);
    1300       break;
    1301     default:
    1302       jj_la1[43] = jj_gen;
    1303       ;
    1304     }
    1305     jj_consume_token(LBRACE);
    1306     if (jj_2_11(2147483647)) {
    1307       ExplicitConstructorInvocation();
    1308     } else {
    1309       ;
    1310     }
    1311     label_19:
    1312     while (true) {
    1313       switch (jj_nt.kind) {
    1314       case BOOLEAN:
    1315       case BREAK:
    1316       case BYTE:
    1317       case CHAR:
    1318       case CLASS:
    1319       case CONTINUE:
    1320       case DO:
    1321       case DOUBLE:
    1322       case FALSE:
    1323       case FINAL:
    1324       case FLOAT:
    1325       case FOR:
    1326       case IF:
    1327       case INT:
    1328       case INTERFACE:
    1329       case LONG:
    1330       case NEW:
    1331       case NULL:
    1332       case RETURN:
    1333       case SHORT:
    1334       case SUPER:
    1335       case SWITCH:
    1336       case SYNCHRONIZED:
    1337       case THIS:
    1338       case THROW:
    1339       case TRUE:
    1340       case TRY:
    1341       case VOID:
    1342       case WHILE:
    1343       case ASSERT:
    1344       case INTEGER_LITERAL:
    1345       case FLOATING_POINT_LITERAL:
    1346       case CHARACTER_LITERAL:
    1347       case STRING_LITERAL:
    1348       case IDENTIFIER:
    1349       case LPAREN:
    1350       case LBRACE:
    1351       case SEMICOLON:
    1352       case INCR:
    1353       case DECR:
    1354         ;
    1355         break;
    1356       default:
    1357         jj_la1[44] = jj_gen;
    1358         break label_19;
    1359       }
    1360       BlockStatement();
    1361     }
    1362     jj_consume_token(RBRACE);
    1363     // we must add the method after the fields are in, because the
    1364     // signature must be complete when adding
    1365     sourceClass.addConstructor(constructor);
    1366   }
    1367
    1368   final public void ExplicitConstructorInvocation() throws ParseException {
    1369     if (jj_2_13(2147483647)) {
    1370       jj_consume_token(THIS);
    1371       Arguments();
    1372       jj_consume_token(SEMICOLON);
    1373     } else {
    1374       switch (jj_nt.kind) {
    1375       case BOOLEAN:
    1376       case BYTE:
    1377       case CHAR:
    1378       case DOUBLE:
    1379       case FALSE:
    1380       case FLOAT:
    1381       case INT:
    1382       case LONG:
    1383       case NEW:
    1384       case NULL:
    1385       case SHORT:
    1386       case SUPER:
    1387       case THIS:
    1388       case TRUE:
    1389       case VOID:
    1390       case INTEGER_LITERAL:
    1391       case FLOATING_POINT_LITERAL:
    1392       case CHARACTER_LITERAL:
    1393       case STRING_LITERAL:
    1394       case IDENTIFIER:
    1395       case LPAREN:
    1396         if (jj_2_12(2)) {
    1397           PrimaryExpression();
    1398           jj_consume_token(DOT);
    1399         } else {
    1400           ;
    1401         }
    1402         jj_consume_token(SUPER);
    1403         Arguments();
    1404         jj_consume_token(SEMICOLON);
    1405         break;
    1406       default:
    1407         jj_la1[45] = jj_gen;
    1408         jj_consume_token(-1);
    1409         throw new ParseException();
    1410       }
    1411     }
    1412   }
    1413
    1414   final public void Initializer() throws ParseException {
    1415     switch (jj_nt.kind) {
    1416     case STATIC:
    1417       jj_consume_token(STATIC);
    1418       break;
    1419     default:
    1420       jj_la1[46] = jj_gen;
    1421       ;
    1422     }
    1423     Block();
    1424   }
    1425
    1426 /*
    1427  * Type, name and expression syntax follows.
    1428  */
    1429   final public void Field_Type(FieldImpl fieldImpl) throws ParseException {
    1430    Token typeToken;
    1431    String type;
    1432     switch (jj_nt.kind) {
    1433     case BOOLEAN:
    1434     case BYTE:
    1435     case CHAR:
    1436     case DOUBLE:
    1437     case FLOAT:
    1438     case INT:
    1439     case LONG:
    1440     case SHORT:
    1441       typeToken = PrimitiveType();
    1442       if( fieldImpl != null ) {
    1443         fieldImpl.setType(typeToken.image);
    1444         setToken( fieldImpl, typeToken );
    1445       }
    1446       break;
    1447     case IDENTIFIER:
    1448       type = Name();
    1449       if( fieldImpl != null ) {
    1450         fieldImpl.setType(type);
    1451         setToken( fieldImpl, _nameToken );
    1452       }
    1453       break;
    1454     default:
    1455       jj_la1[47] = jj_gen;
    1456       jj_consume_token(-1);
    1457       throw new ParseException();
    1458     }
    1459     label_20:
    1460     while (true) {
    1461       switch (jj_nt.kind) {
    1462       case LBRACKET:
    1463         ;
    1464         break;
    1465       default:
    1466         jj_la1[48] = jj_gen;
    1467         break label_20;
    1468       }
    1469       jj_consume_token(LBRACKET);
    1470       jj_consume_token(RBRACKET);
    1471      if( fieldImpl != null ) {
    1472         fieldImpl.setDimension(fieldImpl.getDimension() + 1);
    1473      }
    1474     }
    1475   }
    1476
    1477   final public void MethodResult_Type(MethodImpl methodImpl) throws ParseException {
    1478    Token typeToken;
    1479    String type;
    1480     switch (jj_nt.kind) {
    1481     case BOOLEAN:
    1482     case BYTE:
    1483     case CHAR:
    1484     case DOUBLE:
    1485     case FLOAT:
    1486     case INT:
    1487     case LONG:
    1488     case SHORT:
    1489       typeToken = PrimitiveType();
    1490       if( methodImpl != null ) {
    1491         methodImpl.setReturnType(typeToken.image);
    1492         setToken( methodImpl, typeToken );
    1493       }
    1494       break;
    1495     case IDENTIFIER:
    1496       type = Name();
    1497       if( methodImpl != null ) {
    1498         methodImpl.setReturnType(type);
    1499         setToken( methodImpl, _nameToken );
    1500       }
    1501       break;
    1502     default:
    1503       jj_la1[49] = jj_gen;
    1504       jj_consume_token(-1);
    1505       throw new ParseException();
    1506     }
    1507     label_21:
    1508     while (true) {
    1509       switch (jj_nt.kind) {
    1510       case LBRACKET:
    1511         ;
    1512         break;
    1513       default:
    1514         jj_la1[50] = jj_gen;
    1515         break label_21;
    1516       }
    1517       jj_consume_token(LBRACKET);
    1518       jj_consume_token(RBRACKET);
    1519      if( methodImpl != null ) {
    1520         methodImpl.setReturnDimension(methodImpl.getReturnType().getDimension() + 1);
    1521      }
    1522     }
    1523   }
    1524
    1525   final public void Parameter_Type() throws ParseException {
    1526    Token primitive;
    1527    String name;
    1528     switch (jj_nt.kind) {
    1529     case BOOLEAN:
    1530     case BYTE:
    1531     case CHAR:
    1532     case DOUBLE:
    1533     case FLOAT:
    1534     case INT:
    1535     case LONG:
    1536     case SHORT:
    1537       primitive = PrimitiveType();
    1538        _parameter.type = primitive.image;
    1539       break;
    1540     case IDENTIFIER:
    1541       name = Name();
    1542        _parameter.type = name;
    1543       break;
    1544     default:
    1545       jj_la1[51] = jj_gen;
    1546       jj_consume_token(-1);
    1547       throw new ParseException();
    1548     }
    1549     label_22:
    1550     while (true) {
    1551       switch (jj_nt.kind) {
    1552       case LBRACKET:
    1553         ;
    1554         break;
    1555       default:
    1556         jj_la1[52] = jj_gen;
    1557         break label_22;
    1558       }
    1559       jj_consume_token(LBRACKET);
    1560       jj_consume_token(RBRACKET);
    1561               _parameter.dimension++;
    1562     }
    1563   }
    1564
    1565   final public void Type() throws ParseException {
    1566     switch (jj_nt.kind) {
    1567     case BOOLEAN:
    1568     case BYTE:
    1569     case CHAR:
    1570     case DOUBLE:
    1571     case FLOAT:
    1572     case INT:
    1573     case LONG:
    1574     case SHORT:
    1575       PrimitiveType();
    1576       break;
    1577     case IDENTIFIER:
    1578       Name();
    1579       break;
    1580     default:
    1581       jj_la1[53] = jj_gen;
    1582       jj_consume_token(-1);
    1583       throw new ParseException();
    1584     }
    1585     label_23:
    1586     while (true) {
    1587       switch (jj_nt.kind) {
    1588       case LBRACKET:
    1589         ;
    1590         break;
    1591       default:
    1592         jj_la1[54] = jj_gen;
    1593         break label_23;
    1594       }
    1595       jj_consume_token(LBRACKET);
    1596       jj_consume_token(RBRACKET);
    1597     }
    1598   }
    1599
    1600   final public Token PrimitiveType() throws ParseException {
    1601    Token t = null;
    1602     switch (jj_nt.kind) {
    1603     case BOOLEAN:
    1604       t = jj_consume_token(BOOLEAN);
    1605                 {if (true) return t;}
    1606       break;
    1607     case CHAR:
    1608       t = jj_consume_token(CHAR);
    1609              {if (true) return t;}
    1610       break;
    1611     case BYTE:
    1612       t = jj_consume_token(BYTE);
    1613              {if (true) return t;}
    1614       break;
    1615     case SHORT:
    1616       t = jj_consume_token(SHORT);
    1617               {if (true) return t;}
    1618       break;
    1619     case INT:
    1620       t = jj_consume_token(INT);
    1621             {if (true) return t;}
    1622       break;
    1623     case LONG:
    1624       t = jj_consume_token(LONG);
    1625              {if (true) return t;}
    1626       break;
    1627     case FLOAT:
    1628       t = jj_consume_token(FLOAT);
    1629               {if (true) return t;}
    1630       break;
    1631     case DOUBLE:
    1632       t = jj_consume_token(DOUBLE);
    1633                {if (true) return t;}
    1634       break;
    1635     default:
    1636       jj_la1[55] = jj_gen;
    1637       jj_consume_token(-1);
    1638       throw new ParseException();
    1639     }
    1640     throw new Error("Missing return statement in function");
    1641   }
    1642
    1643   final public void ResultType(MethodImpl methodImpl) throws ParseException {
    1644    Token t = null;
    1645     switch (jj_nt.kind) {
    1646     case VOID:
    1647       t = jj_consume_token(VOID);
    1648      if( methodImpl != null ) {
    1649         methodImpl.setReturnType( "void" );
    1650         methodImpl.setReturnDimension( 0 );
    1651         setToken( methodImpl, t );
    1652      }
    1653       break;
    1654     case BOOLEAN:
    1655     case BYTE:
    1656     case CHAR:
    1657     case DOUBLE:
    1658     case FLOAT:
    1659     case INT:
    1660     case LONG:
    1661     case SHORT:
    1662     case IDENTIFIER:
    1663       MethodResult_Type(methodImpl);
    1664       break;
    1665     default:
    1666       jj_la1[56] = jj_gen;
    1667       jj_consume_token(-1);
    1668       throw new ParseException();
    1669     }
    1670   }
    1671
    1672   final public String Name() throws ParseException {
    1673    // reset the buffer
    1674    clearNameBuffer();
    1675    Token t = null;
    1676     _nameToken = jj_consume_token(IDENTIFIER);
    1677      _nameBuffer.append(_nameToken.image);
    1678     label_24:
    1679     while (true) {
    1680       if (jj_2_14(2)) {
    1681         ;
    1682       } else {
    1683         break label_24;
    1684       }
    1685       jj_consume_token(DOT);
    1686       t = jj_consume_token(IDENTIFIER);
    1687      _nameBuffer.append(".").append(t.image);
    1688     }
    1689      {if (true) return _nameBuffer.toString();}
    1690     throw new Error("Missing return statement in function");
    1691   }
    1692
    1693   final public void ExecutableMemberThrows_Name(AbstractExecutableMember member) throws ParseException {
    1694    // reset the buffer
    1695    clearNameBuffer();
    1696    Token t = null;
    1697     t = jj_consume_token(IDENTIFIER);
    1698      _nameBuffer.append(t.image);
    1699     label_25:
    1700     while (true) {
    1701       switch (jj_nt.kind) {
    1702       case DOT:
    1703         ;
    1704         break;
    1705       default:
    1706         jj_la1[57] = jj_gen;
    1707         break label_25;
    1708       }
    1709       jj_consume_token(DOT);
    1710       t = jj_consume_token(IDENTIFIER);
    1711      _nameBuffer.append(".").append(t.image);
    1712     }
    1713      if( member != null ) {
    1714         member.addThrownException( _nameBuffer.toString() );
    1715      }
    1716   }
    1717
    1718   final public void Interfaces_Name() throws ParseException {
    1719    SourceClass sourceClass = currentClass();
    1720
    1721    // reset the buffer
    1722    clearNameBuffer();
    1723    Token t = null;
    1724     t = jj_consume_token(IDENTIFIER);
    1725      _nameBuffer.append(t.image);
    1726     label_26:
    1727     while (true) {
    1728       switch (jj_nt.kind) {
    1729       case DOT:
    1730         ;
    1731         break;
    1732       default:
    1733         jj_la1[58] = jj_gen;
    1734         break label_26;
    1735       }
    1736       jj_consume_token(DOT);
    1737       t = jj_consume_token(IDENTIFIER);
    1738      _nameBuffer.append(".").append(t.image);
    1739     }
    1740      sourceClass.addInterface( _nameBuffer.toString() );
    1741   }
    1742
    1743   final public void NameList() throws ParseException {
    1744     Name();
    1745     label_27:
    1746     while (true) {
    1747       switch (jj_nt.kind) {
    1748       case COMMA:
    1749         ;
    1750         break;
    1751       default:
    1752         jj_la1[59] = jj_gen;
    1753         break label_27;
    1754       }
    1755       jj_consume_token(COMMA);
    1756       Name();
    1757     }
    1758   }
    1759
    1760   final public void ExecutableMemberThrows_NameList(AbstractExecutableMember member) throws ParseException {
    1761     ExecutableMemberThrows_Name(member);
    1762     label_28:
    1763     while (true) {
    1764       switch (jj_nt.kind) {
    1765       case COMMA:
    1766         ;
    1767         break;
    1768       default:
    1769         jj_la1[60] = jj_gen;
    1770         break label_28;
    1771       }
    1772       jj_consume_token(COMMA);
    1773       ExecutableMemberThrows_Name(member);
    1774     }
    1775   }
    1776
    1777   final public void Interfaces_NameList() throws ParseException {
    1778     Interfaces_Name();
    1779     label_29:
    1780     while (true) {
    1781       switch (jj_nt.kind) {
    1782       case COMMA:
    1783         ;
    1784         break;
    1785       default:
    1786         jj_la1[61] = jj_gen;
    1787         break label_29;
    1788       }
    1789       jj_consume_token(COMMA);
    1790       Interfaces_Name();
    1791     }
    1792   }
    1793
    1794 /*
    1795  * Expression syntax follows.
    1796  */
    1797   final public void Expression() throws ParseException {
    1798     ConditionalExpression();
    1799     switch (jj_nt.kind) {
    1800     case ASSIGN:
    1801     case PLUSASSIGN:
    1802     case MINUSASSIGN:
    1803     case STARASSIGN:
    1804     case SLASHASSIGN:
    1805     case ANDASSIGN:
    1806     case ORASSIGN:
    1807     case XORASSIGN:
    1808     case REMASSIGN:
    1809     case LSHIFTASSIGN:
    1810     case RSIGNEDSHIFTASSIGN:
    1811     case RUNSIGNEDSHIFTASSIGN:
    1812       AssignmentOperator();
    1813       Expression();
    1814       break;
    1815     default:
    1816       jj_la1[62] = jj_gen;
    1817       ;
    1818     }
    1819   }
    1820
    1821   final public void AssignmentOperator() throws ParseException {
    1822     switch (jj_nt.kind) {
    1823     case ASSIGN:
    1824       jj_consume_token(ASSIGN);
    1825       break;
    1826     case STARASSIGN:
    1827       jj_consume_token(STARASSIGN);
    1828       break;
    1829     case SLASHASSIGN:
    1830       jj_consume_token(SLASHASSIGN);
    1831       break;
    1832     case REMASSIGN:
    1833       jj_consume_token(REMASSIGN);
    1834       break;
    1835     case PLUSASSIGN:
    1836       jj_consume_token(PLUSASSIGN);
    1837       break;
    1838     case MINUSASSIGN:
    1839       jj_consume_token(MINUSASSIGN);
    1840       break;
    1841     case LSHIFTASSIGN:
    1842       jj_consume_token(LSHIFTASSIGN);
    1843       break;
    1844     case RSIGNEDSHIFTASSIGN:
    1845       jj_consume_token(RSIGNEDSHIFTASSIGN);
    1846       break;
    1847     case RUNSIGNEDSHIFTASSIGN:
    1848       jj_consume_token(RUNSIGNEDSHIFTASSIGN);
    1849       break;
    1850     case ANDASSIGN:
    1851       jj_consume_token(ANDASSIGN);
    1852       break;
    1853     case XORASSIGN:
    1854       jj_consume_token(XORASSIGN);
    1855       break;
    1856     case ORASSIGN:
    1857       jj_consume_token(ORASSIGN);
    1858       break;
    1859     default:
    1860       jj_la1[63] = jj_gen;
    1861       jj_consume_token(-1);
    1862       throw new ParseException();
    1863     }
    1864   }
    1865
    1866   final public void ConditionalExpression() throws ParseException {
    1867     ConditionalOrExpression();
    1868     switch (jj_nt.kind) {
    1869     case HOOK:
    1870       jj_consume_token(HOOK);
    1871       Expression();
    1872       jj_consume_token(COLON);
    1873       ConditionalExpression();
    1874       break;
    1875     default:
    1876       jj_la1[64] = jj_gen;
    1877       ;
    1878     }
    1879   }
    1880
    1881   final public void ConditionalOrExpression() throws ParseException {
    1882     ConditionalAndExpression();
    1883     label_30:
    1884     while (true) {
    1885       switch (jj_nt.kind) {
    1886       case SC_OR:
    1887         ;
    1888         break;
    1889       default:
    1890         jj_la1[65] = jj_gen;
    1891         break label_30;
    1892       }
    1893       jj_consume_token(SC_OR);
    1894       ConditionalAndExpression();
    1895     }
    1896   }
    1897
    1898   final public void ConditionalAndExpression() throws ParseException {
    1899     InclusiveOrExpression();
    1900     label_31:
    1901     while (true) {
    1902       switch (jj_nt.kind) {
    1903       case SC_AND:
    1904         ;
    1905         break;
    1906       default:
    1907         jj_la1[66] = jj_gen;
    1908         break label_31;
    1909       }
    1910       jj_consume_token(SC_AND);
    1911       InclusiveOrExpression();
    1912     }
    1913   }
    1914
    1915   final public void InclusiveOrExpression() throws ParseException {
    1916     ExclusiveOrExpression();
    1917     label_32:
    1918     while (true) {
    1919       switch (jj_nt.kind) {
    1920       case BIT_OR:
    1921         ;
    1922         break;
    1923       default:
    1924         jj_la1[67] = jj_gen;
    1925         break label_32;
    1926       }
    1927       jj_consume_token(BIT_OR);
    1928       ExclusiveOrExpression();
    1929     }
    1930   }
    1931
    1932   final public void ExclusiveOrExpression() throws ParseException {
    1933     AndExpression();
    1934     label_33:
    1935     while (true) {
    1936       switch (jj_nt.kind) {
    1937       case XOR:
    1938         ;
    1939         break;
    1940       default:
    1941         jj_la1[68] = jj_gen;
    1942         break label_33;
    1943       }
    1944       jj_consume_token(XOR);
    1945       AndExpression();
    1946     }
    1947   }
    1948
    1949   final public void AndExpression() throws ParseException {
    1950     EqualityExpression();
    1951     label_34:
    1952     while (true) {
    1953       switch (jj_nt.kind) {
    1954       case BIT_AND:
    1955         ;
    1956         break;
    1957       default:
    1958         jj_la1[69] = jj_gen;
    1959         break label_34;
    1960       }
    1961       jj_consume_token(BIT_AND);
    1962       EqualityExpression();
    1963     }
    1964   }
    1965
    1966   final public void EqualityExpression() throws ParseException {
    1967     InstanceOfExpression();
    1968     label_35:
    1969     while (true) {
    1970       switch (jj_nt.kind) {
    1971       case EQ:
    1972       case NE:
    1973         ;
    1974         break;
    1975       default:
    1976         jj_la1[70] = jj_gen;
    1977         break label_35;
    1978       }
    1979       switch (jj_nt.kind) {
    1980       case EQ:
    1981         jj_consume_token(EQ);
    1982         break;
    1983       case NE:
    1984         jj_consume_token(NE);
    1985         break;
    1986       default:
    1987         jj_la1[71] = jj_gen;
    1988         jj_consume_token(-1);
    1989         throw new ParseException();
    1990       }
    1991       InstanceOfExpression();
    1992     }
    1993   }
    1994
    1995   final public void InstanceOfExpression() throws ParseException {
    1996     RelationalExpression();
    1997     switch (jj_nt.kind) {
    1998     case INSTANCEOF:
    1999       jj_consume_token(INSTANCEOF);
    2000       Type();
    2001       break;
    2002     default:
    2003       jj_la1[72] = jj_gen;
    2004       ;
    2005     }
    2006   }
    2007
    2008   final public void RelationalExpression() throws ParseException {
    2009     ShiftExpression();
    2010     label_36:
    2011     while (true) {
    2012       switch (jj_nt.kind) {
    2013       case GT:
    2014       case LT:
    2015       case LE:
    2016       case GE:
    2017         ;
    2018         break;
    2019       default:
    2020         jj_la1[73] = jj_gen;
    2021         break label_36;
    2022       }
    2023       switch (jj_nt.kind) {
    2024       case LT:
    2025         jj_consume_token(LT);
    2026         break;
    2027       case GT:
    2028         jj_consume_token(GT);
    2029         break;
    2030       case LE:
    2031         jj_consume_token(LE);
    2032         break;
    2033       case GE:
    2034         jj_consume_token(GE);
    2035         break;
    2036       default:
    2037         jj_la1[74] = jj_gen;
    2038         jj_consume_token(-1);
    2039         throw new ParseException();
    2040       }
    2041       ShiftExpression();
    2042     }
    2043   }
    2044
    2045   final public void ShiftExpression() throws ParseException {
    2046     AdditiveExpression();
    2047     label_37:
    2048     while (true) {
    2049       switch (jj_nt.kind) {
    2050       case LSHIFT:
    2051       case RSIGNEDSHIFT:
    2052       case RUNSIGNEDSHIFT:
    2053         ;
    2054         break;
    2055       default:
    2056         jj_la1[75] = jj_gen;
    2057         break label_37;
    2058       }
    2059       switch (jj_nt.kind) {
    2060       case LSHIFT:
    2061         jj_consume_token(LSHIFT);
    2062         break;
    2063       case RSIGNEDSHIFT:
    2064         jj_consume_token(RSIGNEDSHIFT);
    2065         break;
    2066       case RUNSIGNEDSHIFT:
    2067         jj_consume_token(RUNSIGNEDSHIFT);
    2068         break;
    2069       default:
    2070         jj_la1[76] = jj_gen;
    2071         jj_consume_token(-1);
    2072         throw new ParseException();
    2073       }
    2074       AdditiveExpression();
    2075     }
    2076   }
    2077
    2078   final public void AdditiveExpression() throws ParseException {
    2079     MultiplicativeExpression();
    2080     label_38:
    2081     while (true) {
    2082       switch (jj_nt.kind) {
    2083       case PLUS:
    2084       case MINUS:
    2085         ;
    2086         break;
    2087       default:
    2088         jj_la1[77] = jj_gen;
    2089         break label_38;
    2090       }
    2091       switch (jj_nt.kind) {
    2092       case PLUS:
    2093         jj_consume_token(PLUS);
    2094         break;
    2095       case MINUS:
    2096         jj_consume_token(MINUS);
    2097         break;
    2098       default:
    2099         jj_la1[78] = jj_gen;
    2100         jj_consume_token(-1);
    2101         throw new ParseException();
    2102       }
    2103       MultiplicativeExpression();
    2104     }
    2105   }
    2106
    2107   final public void MultiplicativeExpression() throws ParseException {
    2108     UnaryExpression();
    2109     label_39:
    2110     while (true) {
    2111       switch (jj_nt.kind) {
    2112       case STAR:
    2113       case SLASH:
    2114       case REM:
    2115         ;
    2116         break;
    2117       default:
    2118         jj_la1[79] = jj_gen;
    2119         break label_39;
    2120       }
    2121       switch (jj_nt.kind) {
    2122       case STAR:
    2123         jj_consume_token(STAR);
    2124         break;
    2125       case SLASH:
    2126         jj_consume_token(SLASH);
    2127         break;
    2128       case REM:
    2129         jj_consume_token(REM);
    2130         break;
    2131       default:
    2132         jj_la1[80] = jj_gen;
    2133         jj_consume_token(-1);
    2134         throw new ParseException();
    2135       }
    2136       UnaryExpression();
    2137     }
    2138   }
    2139
    2140   final public void UnaryExpression() throws ParseException {
    2141     switch (jj_nt.kind) {
    2142     case PLUS:
    2143     case MINUS:
    2144       switch (jj_nt.kind) {
    2145       case PLUS:
    2146         jj_consume_token(PLUS);
    2147         break;
    2148       case MINUS:
    2149         jj_consume_token(MINUS);
    2150         break;
    2151       default:
    2152         jj_la1[81] = jj_gen;
    2153         jj_consume_token(-1);
    2154         throw new ParseException();
    2155       }
    2156       UnaryExpression();
    2157       break;
    2158     case INCR:
    2159       PreIncrementExpression();
    2160       break;
    2161     case DECR:
    2162       PreDecrementExpression();
    2163       break;
    2164     case BOOLEAN:
    2165     case BYTE:
    2166     case CHAR:
    2167     case DOUBLE:
    2168     case FALSE:
    2169     case FLOAT:
    2170     case INT:
    2171     case LONG:
    2172     case NEW:
    2173     case NULL:
    2174     case SHORT:
    2175     case SUPER:
    2176     case THIS:
    2177     case TRUE:
    2178     case VOID:
    2179     case INTEGER_LITERAL:
    2180     case FLOATING_POINT_LITERAL:
    2181     case CHARACTER_LITERAL:
    2182     case STRING_LITERAL:
    2183     case IDENTIFIER:
    2184     case LPAREN:
    2185     case BANG:
    2186     case TILDE:
    2187       UnaryExpressionNotPlusMinus();
    2188       break;
    2189     default:
    2190       jj_la1[82] = jj_gen;
    2191       jj_consume_token(-1);
    2192       throw new ParseException();
    2193     }
    2194   }
    2195
    2196   final public void PreIncrementExpression() throws ParseException {
    2197     jj_consume_token(INCR);
    2198     PrimaryExpression();
    2199   }
    2200
    2201   final public void PreDecrementExpression() throws ParseException {
    2202     jj_consume_token(DECR);
    2203     PrimaryExpression();
    2204   }
    2205
    2206   final public void UnaryExpressionNotPlusMinus() throws ParseException {
    2207     switch (jj_nt.kind) {
    2208     case BANG:
    2209     case TILDE:
    2210       switch (jj_nt.kind) {
    2211       case TILDE:
    2212         jj_consume_token(TILDE);
    2213         break;
    2214       case BANG:
    2215         jj_consume_token(BANG);
    2216         break;
    2217       default:
    2218         jj_la1[83] = jj_gen;
    2219         jj_consume_token(-1);
    2220         throw new ParseException();
    2221       }
    2222       UnaryExpression();
    2223       break;
    2224     default:
    2225       jj_la1[84] = jj_gen;
    2226       if (jj_2_15(2147483647)) {
    2227         CastExpression();
    2228       } else {
    2229         switch (jj_nt.kind) {
    2230         case BOOLEAN:
    2231         case BYTE:
    2232         case CHAR:
    2233         case DOUBLE:
    2234         case FALSE:
    2235         case FLOAT:
    2236         case INT:
    2237         case LONG:
    2238         case NEW:
    2239         case NULL:
    2240         case SHORT:
    2241         case SUPER:
    2242         case THIS:
    2243         case TRUE:
    2244         case VOID:
    2245         case INTEGER_LITERAL:
    2246         case FLOATING_POINT_LITERAL:
    2247         case CHARACTER_LITERAL:
    2248         case STRING_LITERAL:
    2249         case IDENTIFIER:
    2250         case LPAREN:
    2251           PostfixExpression();
    2252           break;
    2253         default:
    2254           jj_la1[85] = jj_gen;
    2255           jj_consume_token(-1);
    2256           throw new ParseException();
    2257         }
    2258       }
    2259     }
    2260   }
    2261
    2262 // This production is to determine lookahead only.  The LOOKAHEAD specifications
    2263 // below are not used, but they are there just to indicate that we know about
    2264 // this.
    2265   final public void CastLookahead() throws ParseException {
    2266     if (jj_2_16(2)) {
    2267       jj_consume_token(LPAREN);
    2268       PrimitiveType();
    2269     } else if (jj_2_17(2147483647)) {
    2270       jj_consume_token(LPAREN);
    2271       Name();
    2272       jj_consume_token(LBRACKET);
    2273       jj_consume_token(RBRACKET);
    2274     } else {
    2275       switch (jj_nt.kind) {
    2276       case LPAREN:
    2277         jj_consume_token(LPAREN);
    2278         Name();
    2279         jj_consume_token(RPAREN);
    2280         switch (jj_nt.kind) {
    2281         case TILDE:
    2282           jj_consume_token(TILDE);
    2283           break;
    2284         case BANG:
    2285           jj_consume_token(BANG);
    2286           break;
    2287         case LPAREN:
    2288           jj_consume_token(LPAREN);
    2289           break;
    2290         case IDENTIFIER:
    2291           jj_consume_token(IDENTIFIER);
    2292           break;
    2293         case THIS:
    2294           jj_consume_token(THIS);
    2295           break;
    2296         case SUPER:
    2297           jj_consume_token(SUPER);
    2298           break;
    2299         case NEW:
    2300           jj_consume_token(NEW);
    2301           break;
    2302         case FALSE:
    2303         case NULL:
    2304         case TRUE:
    2305         case INTEGER_LITERAL:
    2306         case FLOATING_POINT_LITERAL:
    2307         case CHARACTER_LITERAL:
    2308         case STRING_LITERAL:
    2309           Literal();
    2310           break;
    2311         default:
    2312           jj_la1[86] = jj_gen;
    2313           jj_consume_token(-1);
    2314           throw new ParseException();
    2315         }
    2316         break;
    2317       default:
    2318         jj_la1[87] = jj_gen;
    2319         jj_consume_token(-1);
    2320         throw new ParseException();
    2321       }
    2322     }
    2323   }
    2324
    2325   final public void PostfixExpression() throws ParseException {
    2326     PrimaryExpression();
    2327     switch (jj_nt.kind) {
    2328     case INCR:
    2329     case DECR:
    2330       switch (jj_nt.kind) {
    2331       case INCR:
    2332         jj_consume_token(INCR);
    2333         break;
    2334       case DECR:
    2335         jj_consume_token(DECR);
    2336         break;
    2337       default:
    2338         jj_la1[88] = jj_gen;
    2339         jj_consume_token(-1);
    2340         throw new ParseException();
    2341       }
    2342       break;
    2343     default:
    2344       jj_la1[89] = jj_gen;
    2345       ;
    2346     }
    2347   }
    2348
    2349   final public void CastExpression() throws ParseException {
    2350     if (jj_2_18(2147483647)) {
    2351       jj_consume_token(LPAREN);
    2352       Type();
    2353       jj_consume_token(RPAREN);
    2354       UnaryExpression();
    2355     } else {
    2356       switch (jj_nt.kind) {
    2357       case LPAREN:
    2358         jj_consume_token(LPAREN);
    2359         Type();
    2360         jj_consume_token(RPAREN);
    2361         UnaryExpressionNotPlusMinus();
    2362         break;
    2363       default:
    2364         jj_la1[90] = jj_gen;
    2365         jj_consume_token(-1);
    2366         throw new ParseException();
    2367       }
    2368     }
    2369   }
    2370
    2371   final public void PrimaryExpression() throws ParseException {
    2372     PrimaryPrefix();
    2373     label_40:
    2374     while (true) {
    2375       if (jj_2_19(2)) {
    2376         ;
    2377       } else {
    2378         break label_40;
    2379       }
    2380       PrimarySuffix();
    2381     }
    2382   }
    2383
    2384   final public void PrimaryPrefix() throws ParseException {
    2385     switch (jj_nt.kind) {
    2386     case FALSE:
    2387     case NULL:
    2388     case TRUE:
    2389     case INTEGER_LITERAL:
    2390     case FLOATING_POINT_LITERAL:
    2391     case CHARACTER_LITERAL:
    2392     case STRING_LITERAL:
    2393       Literal();
    2394       break;
    2395     case THIS:
    2396       jj_consume_token(THIS);
    2397       break;
    2398     case SUPER:
    2399       jj_consume_token(SUPER);
    2400       jj_consume_token(DOT);
    2401       jj_consume_token(IDENTIFIER);
    2402       break;
    2403     case LPAREN:
    2404       jj_consume_token(LPAREN);
    2405       Expression();
    2406       jj_consume_token(RPAREN);
    2407       break;
    2408     case NEW:
    2409       AllocationExpression();
    2410       break;
    2411     default:
    2412       jj_la1[91] = jj_gen;
    2413       if (jj_2_20(2147483647)) {
    2414         ResultType(null);
    2415         jj_consume_token(DOT);
    2416         jj_consume_token(CLASS);
    2417       } else {
    2418         switch (jj_nt.kind) {
    2419         case IDENTIFIER:
    2420           Name();
    2421           break;
    2422         default:
    2423           jj_la1[92] = jj_gen;
    2424           jj_consume_token(-1);
    2425           throw new ParseException();
    2426         }
    2427       }
    2428     }
    2429   }
    2430
    2431   final public void PrimarySuffix() throws ParseException {
    2432     if (jj_2_21(2)) {
    2433       jj_consume_token(DOT);
    2434       jj_consume_token(THIS);
    2435     } else if (jj_2_22(2)) {
    2436       jj_consume_token(DOT);
    2437       jj_consume_token(SUPER);
    2438     } else if (jj_2_23(2)) {
    2439       jj_consume_token(DOT);
    2440       AllocationExpression();
    2441     } else {
    2442       switch (jj_nt.kind) {
    2443       case LBRACKET:
    2444         jj_consume_token(LBRACKET);
    2445         Expression();
    2446         jj_consume_token(RBRACKET);
    2447         break;
    2448       case DOT:
    2449         jj_consume_token(DOT);
    2450         jj_consume_token(IDENTIFIER);
    2451         break;
    2452       case LPAREN:
    2453         Arguments();
    2454         break;
    2455       default:
    2456         jj_la1[93] = jj_gen;
    2457         jj_consume_token(-1);
    2458         throw new ParseException();
    2459       }
    2460     }
    2461   }
    2462
    2463   final public void Literal() throws ParseException {
    2464     switch (jj_nt.kind) {
    2465     case INTEGER_LITERAL:
    2466       jj_consume_token(INTEGER_LITERAL);
    2467       break;
    2468     case FLOATING_POINT_LITERAL:
    2469       jj_consume_token(FLOATING_POINT_LITERAL);
    2470       break;
    2471     case CHARACTER_LITERAL:
    2472       jj_consume_token(CHARACTER_LITERAL);
    2473       break;
    2474     case STRING_LITERAL:
    2475       jj_consume_token(STRING_LITERAL);
    2476       break;
    2477     case FALSE:
    2478     case TRUE:
    2479       BooleanLiteral();
    2480       break;
    2481     case NULL:
    2482       NullLiteral();
    2483       break;
    2484     default:
    2485       jj_la1[94] = jj_gen;
    2486       jj_consume_token(-1);
    2487       throw new ParseException();
    2488     }
    2489   }
    2490
    2491   final public void BooleanLiteral() throws ParseException {
    2492     switch (jj_nt.kind) {
    2493     case TRUE:
    2494       jj_consume_token(TRUE);
    2495       break;
    2496     case FALSE:
    2497       jj_consume_token(FALSE);
    2498       break;
    2499     default:
    2500       jj_la1[95] = jj_gen;
    2501       jj_consume_token(-1);
    2502       throw new ParseException();
    2503     }
    2504   }
    2505
    2506   final public void NullLiteral() throws ParseException {
    2507     jj_consume_token(NULL);
    2508   }
    2509
    2510   final public void Arguments() throws ParseException {
    2511     jj_consume_token(LPAREN);
    2512     switch (jj_nt.kind) {
    2513     case BOOLEAN:
    2514     case BYTE:
    2515     case CHAR:
    2516     case DOUBLE:
    2517     case FALSE:
    2518     case FLOAT:
    2519     case INT:
    2520     case LONG:
    2521     case NEW:
    2522     case NULL:
    2523     case SHORT:
    2524     case SUPER:
    2525     case THIS:
    2526     case TRUE:
    2527     case VOID:
    2528     case INTEGER_LITERAL:
    2529     case FLOATING_POINT_LITERAL:
    2530     case CHARACTER_LITERAL:
    2531     case STRING_LITERAL:
    2532     case IDENTIFIER:
    2533     case LPAREN:
    2534     case BANG:
    2535     case TILDE:
    2536     case INCR:
    2537     case DECR:
    2538     case PLUS:
    2539     case MINUS:
    2540       ArgumentList();
    2541       break;
    2542     default:
    2543       jj_la1[96] = jj_gen;
    2544       ;
    2545     }
    2546     jj_consume_token(RPAREN);
    2547   }
    2548
    2549   final public void ArgumentList() throws ParseException {
    2550     Expression();
    2551     label_41:
    2552     while (true) {
    2553       switch (jj_nt.kind) {
    2554       case COMMA:
    2555         ;
    2556         break;
    2557       default:
    2558         jj_la1[97] = jj_gen;
    2559         break label_41;
    2560       }
    2561       jj_consume_token(COMMA);
    2562       Expression();
    2563     }
    2564   }
    2565
    2566 /***
    2567  * @todo Anonymous classes will cause NPE. Need to check for nullity in a lot of places
    2568  */
    2569   final public void AllocationExpression() throws ParseException {
    2570    String realisedClass;
    2571     if (jj_2_24(2)) {
    2572       jj_consume_token(NEW);
    2573       PrimitiveType();
    2574       ArrayDimsAndInits();
    2575     } else {
    2576       switch (jj_nt.kind) {
    2577       case NEW:
    2578         jj_consume_token(NEW);
    2579         realisedClass = Name();
    2580         switch (jj_nt.kind) {
    2581         case LBRACKET:
    2582           ArrayDimsAndInits();
    2583           break;
    2584         case LPAREN:
    2585           Arguments();
    2586           switch (jj_nt.kind) {
    2587           case LBRACE:
    2588             // ANONYMOUS CLASS
    2589             SourceClass containingClass = currentClass();
    2590         pushAndGet();
    2591             ClassBody();
    2592         // Don't care about anonymous classes. They don't have javadocs
    2593         // _xJavaDoc.addSourceClass(anonymousClass);
    2594         currentClass().setName(containingClass.getNextAnonymousClassName());
    2595         currentClass().setRealised(realisedClass);
    2596         popAndAddInner();
    2597             break;
    2598           default:
    2599             jj_la1[98] = jj_gen;
    2600             ;
    2601           }
    2602           break;
    2603         default:
    2604           jj_la1[99] = jj_gen;
    2605           jj_consume_token(-1);
    2606           throw new ParseException();
    2607         }
    2608         break;
    2609       default:
    2610         jj_la1[100] = jj_gen;
    2611         jj_consume_token(-1);
    2612         throw new ParseException();
    2613       }
    2614     }
    2615   }
    2616
    2617 /*
    2618  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
    2619  * if there is an expression between the "[...]".
    2620  */
    2621   final public void ArrayDimsAndInits() throws ParseException {
    2622     if (jj_2_27(2)) {
    2623       label_42:
    2624       while (true) {
    2625         jj_consume_token(LBRACKET);
    2626         Expression();
    2627         jj_consume_token(RBRACKET);
    2628         if (jj_2_25(2)) {
    2629           ;
    2630         } else {
    2631           break label_42;
    2632         }
    2633       }
    2634       label_43:
    2635       while (true) {
    2636         if (jj_2_26(2)) {
    2637           ;
    2638         } else {
    2639           break label_43;
    2640         }
    2641         jj_consume_token(LBRACKET);
    2642         jj_consume_token(RBRACKET);
    2643       }
    2644     } else {
    2645       switch (jj_nt.kind) {
    2646       case LBRACKET:
    2647         label_44:
    2648         while (true) {
    2649           jj_consume_token(LBRACKET);
    2650           jj_consume_token(RBRACKET);
    2651           switch (jj_nt.kind) {
    2652           case LBRACKET:
    2653             ;
    2654             break;
    2655           default:
    2656             jj_la1[101] = jj_gen;
    2657             break label_44;
    2658           }
    2659         }
    2660         ArrayInitializer();
    2661         break;
    2662       default:
    2663         jj_la1[102] = jj_gen;
    2664         jj_consume_token(-1);
    2665         throw new ParseException();
    2666       }
    2667     }
    2668   }
    2669
    2670 /*
    2671  * Statement syntax follows.
    2672  */
    2673   final public void Statement() throws ParseException {
    2674     if (jj_2_28(2)) {
    2675       LabeledStatement();
    2676     } else {
    2677       switch (jj_nt.kind) {
    2678       case LBRACE:
    2679         Block();
    2680         break;
    2681       case SEMICOLON:
    2682         EmptyStatement();
    2683         break;
    2684       case BOOLEAN:
    2685       case BYTE:
    2686       case CHAR:
    2687       case DOUBLE:
    2688       case FALSE:
    2689       case FLOAT:
    2690       case INT:
    2691       case LONG:
    2692       case NEW:
    2693       case NULL:
    2694       case SHORT:
    2695       case SUPER:
    2696       case THIS:
    2697       case TRUE:
    2698       case VOID:
    2699       case INTEGER_LITERAL:
    2700       case FLOATING_POINT_LITERAL:
    2701       case CHARACTER_LITERAL:
    2702       case STRING_LITERAL:
    2703       case IDENTIFIER:
    2704       case LPAREN:
    2705       case INCR:
    2706       case DECR:
    2707         StatementExpression();
    2708         jj_consume_token(SEMICOLON);
    2709         break;
    2710       case SWITCH:
    2711         SwitchStatement();
    2712         break;
    2713       case IF:
    2714         IfStatement();
    2715         break;
    2716       case WHILE:
    2717         WhileStatement();
    2718         break;
    2719       case DO:
    2720         DoStatement();
    2721         break;
    2722       case FOR:
    2723         ForStatement();
    2724         break;
    2725       case BREAK:
    2726         BreakStatement();
    2727         break;
    2728       case CONTINUE:
    2729         ContinueStatement();
    2730         break;
    2731       case RETURN:
    2732         ReturnStatement();
    2733         break;
    2734       case THROW:
    2735         ThrowStatement();
    2736         break;
    2737       case SYNCHRONIZED:
    2738         SynchronizedStatement();
    2739         break;
    2740       case TRY:
    2741         TryStatement();
    2742         break;
    2743       case ASSERT:
    2744         AssertStatement();
    2745         break;
    2746       default:
    2747         jj_la1[103] = jj_gen;
    2748         jj_consume_token(-1);
    2749         throw new ParseException();
    2750       }
    2751     }
    2752   }
    2753
    2754   final public void LabeledStatement() throws ParseException {
    2755     jj_consume_token(IDENTIFIER);
    2756     jj_consume_token(COLON);
    2757     Statement();
    2758   }
    2759
    2760   final public void Block() throws ParseException {
    2761     jj_consume_token(LBRACE);
    2762     label_45:
    2763     while (true) {
    2764       switch (jj_nt.kind) {
    2765       case BOOLEAN:
    2766       case BREAK:
    2767       case BYTE:
    2768       case CHAR:
    2769       case CLASS:
    2770       case CONTINUE:
    2771       case DO:
    2772       case DOUBLE:
    2773       case FALSE:
    2774       case FINAL:
    2775       case FLOAT:
    2776       case FOR:
    2777       case IF:
    2778       case INT:
    2779       case INTERFACE:
    2780       case LONG:
    2781       case NEW:
    2782       case NULL:
    2783       case RETURN:
    2784       case SHORT:
    2785       case SUPER:
    2786       case SWITCH:
    2787       case SYNCHRONIZED:
    2788       case THIS:
    2789       case THROW:
    2790       case TRUE:
    2791       case TRY:
    2792       case VOID:
    2793       case WHILE:
    2794       case ASSERT:
    2795       case INTEGER_LITERAL:
    2796       case FLOATING_POINT_LITERAL:
    2797       case CHARACTER_LITERAL:
    2798       case STRING_LITERAL:
    2799       case IDENTIFIER:
    2800       case LPAREN:
    2801       case LBRACE:
    2802       case SEMICOLON:
    2803       case INCR:
    2804       case DECR:
    2805         ;
    2806         break;
    2807       default:
    2808         jj_la1[104] = jj_gen;
    2809         break label_45;
    2810       }
    2811       BlockStatement();
    2812     }
    2813     jj_consume_token(RBRACE);
    2814   }
    2815
    2816   final public void Method_Block() throws ParseException {
    2817     jj_consume_token(LBRACE);
    2818     label_46:
    2819     while (true) {
    2820       switch (jj_nt.kind) {
    2821       case BOOLEAN:
    2822       case BREAK:
    2823       case BYTE:
    2824       case CHAR:
    2825       case CLASS:
    2826       case CONTINUE:
    2827       case DO:
    2828       case DOUBLE:
    2829       case FALSE:
    2830       case FINAL:
    2831       case FLOAT:
    2832       case FOR:
    2833       case IF:
    2834       case INT:
    2835       case INTERFACE:
    2836       case LONG:
    2837       case NEW:
    2838       case NULL:
    2839       case RETURN:
    2840       case SHORT:
    2841       case SUPER:
    2842       case SWITCH:
    2843       case SYNCHRONIZED:
    2844       case THIS:
    2845       case THROW:
    2846       case TRUE:
    2847       case TRY:
    2848       case VOID:
    2849       case WHILE:
    2850       case ASSERT:
    2851       case INTEGER_LITERAL:
    2852       case FLOATING_POINT_LITERAL:
    2853       case CHARACTER_LITERAL:
    2854       case STRING_LITERAL:
    2855       case IDENTIFIER:
    2856       case LPAREN:
    2857       case LBRACE:
    2858       case SEMICOLON:
    2859       case INCR:
    2860       case DECR:
    2861         ;
    2862         break;
    2863       default:
    2864         jj_la1[105] = jj_gen;
    2865         break label_46;
    2866       }
    2867       Method_BlockStatement();
    2868     }
    2869     jj_consume_token(RBRACE);
    2870     switch (jj_nt.kind) {
    2871     case SEMICOLON:
    2872       jj_consume_token(SEMICOLON);
    2873       break;
    2874     default:
    2875       jj_la1[106] = jj_gen;
    2876       ;
    2877     }
    2878   }
    2879
    2880 /***
    2881  * @todo not sure if the UnmodifiedClassDeclaration/UnmodifiedInterfaceDeclaration
    2882  * ever get called, now that we have two different blocks. It would be nice to remove them
    2883  */
    2884   final public void BlockStatement() throws ParseException {
    2885     if (jj_2_29(2147483647)) {
    2886       LocalVariableDeclaration();
    2887       jj_consume_token(SEMICOLON);
    2888     } else {
    2889       switch (jj_nt.kind) {
    2890       case BOOLEAN:
    2891       case BREAK:
    2892       case BYTE:
    2893       case CHAR:
    2894       case CONTINUE:
    2895       case DO:
    2896       case DOUBLE:
    2897       case FALSE:
    2898       case FLOAT:
    2899       case FOR:
    2900       case IF:
    2901       case INT:
    2902       case LONG:
    2903       case NEW:
    2904       case NULL:
    2905       case RETURN:
    2906       case SHORT:
    2907       case SUPER:
    2908       case SWITCH:
    2909       case SYNCHRONIZED:
    2910       case THIS:
    2911       case THROW:
    2912       case TRUE:
    2913       case TRY:
    2914       case VOID:
    2915       case WHILE:
    2916       case ASSERT:
    2917       case INTEGER_LITERAL:
    2918       case FLOATING_POINT_LITERAL:
    2919       case CHARACTER_LITERAL:
    2920       case STRING_LITERAL:
    2921       case IDENTIFIER:
    2922       case LPAREN:
    2923       case LBRACE:
    2924       case SEMICOLON:
    2925       case INCR:
    2926       case DECR:
    2927         Statement();
    2928         break;
    2929       case CLASS:
    2930      pushAndGet();
    2931         UnmodifiedClassDeclaration();
    2932      popAndAddInner();
    2933         break;
    2934       case INTERFACE:
    2935      pushAndGet();
    2936         UnmodifiedInterfaceDeclaration();
    2937      popAndAddInner();
    2938         break;
    2939       default:
    2940         jj_la1[107] = jj_gen;
    2941         jj_consume_token(-1);
    2942         throw new ParseException();
    2943       }
    2944     }
    2945   }
    2946
    2947   final public void Method_BlockStatement() throws ParseException {
    2948     if (jj_2_30(2147483647)) {
    2949       LocalVariableDeclaration();
    2950       jj_consume_token(SEMICOLON);
    2951     } else {
    2952       switch (jj_nt.kind) {
    2953       case BOOLEAN:
    2954       case BREAK:
    2955       case BYTE:
    2956       case CHAR:
    2957       case CONTINUE:
    2958       case DO:
    2959       case DOUBLE:
    2960       case FALSE:
    2961       case FLOAT:
    2962       case FOR:
    2963       case IF:
    2964       case INT:
    2965       case LONG:
    2966       case NEW:
    2967       case NULL:
    2968       case RETURN:
    2969       case SHORT:
    2970       case SUPER:
    2971       case SWITCH:
    2972       case SYNCHRONIZED:
    2973       case THIS:
    2974       case THROW:
    2975       case TRUE:
    2976       case TRY:
    2977       case VOID:
    2978       case WHILE:
    2979       case ASSERT:
    2980       case INTEGER_LITERAL:
    2981       case FLOATING_POINT_LITERAL:
    2982       case CHARACTER_LITERAL:
    2983       case STRING_LITERAL:
    2984       case IDENTIFIER:
    2985       case LPAREN:
    2986       case LBRACE:
    2987       case SEMICOLON:
    2988       case INCR:
    2989       case DECR:
    2990         Statement();
    2991         break;
    2992       case CLASS:
    2993      pushAndGet();
    2994         UnmodifiedClassDeclaration();
    2995      popAndAddInner();
    2996         break;
    2997       case INTERFACE:
    2998      pushAndGet();
    2999         UnmodifiedInterfaceDeclaration();
    3000      popAndAddInner();
    3001         break;
    3002       default:
    3003         jj_la1[108] = jj_gen;
    3004         jj_consume_token(-1);
    3005         throw new ParseException();
    3006       }
    3007     }
    3008   }
    3009
    3010   final public void LocalVariableDeclaration() throws ParseException {
    3011     switch (jj_nt.kind) {
    3012     case FINAL:
    3013       jj_consume_token(FINAL);
    3014       break;
    3015     default:
    3016       jj_la1[109] = jj_gen;
    3017       ;
    3018     }
    3019     Type();
    3020     VariableDeclarator();
    3021     label_47:
    3022     while (true) {
    3023       switch (jj_nt.kind) {
    3024       case COMMA:
    3025         ;
    3026         break;
    3027       default:
    3028         jj_la1[110] = jj_gen;
    3029         break label_47;
    3030       }
    3031       jj_consume_token(COMMA);
    3032       VariableDeclarator();
    3033     }
    3034   }
    3035
    3036   final public void EmptyStatement() throws ParseException {
    3037     jj_consume_token(SEMICOLON);
    3038   }
    3039
    3040   final public void StatementExpression() throws ParseException {
    3041     switch (jj_nt.kind) {
    3042     case INCR:
    3043       PreIncrementExpression();
    3044       break;
    3045     case DECR:
    3046       PreDecrementExpression();
    3047       break;
    3048     case BOOLEAN:
    3049     case BYTE:
    3050     case CHAR:
    3051     case DOUBLE:
    3052     case FALSE:
    3053     case FLOAT:
    3054     case INT:
    3055     case LONG:
    3056     case NEW:
    3057     case NULL:
    3058     case SHORT:
    3059     case SUPER:
    3060     case THIS:
    3061     case TRUE:
    3062     case VOID:
    3063     case INTEGER_LITERAL:
    3064     case FLOATING_POINT_LITERAL:
    3065     case CHARACTER_LITERAL:
    3066     case STRING_LITERAL:
    3067     case IDENTIFIER:
    3068     case LPAREN:
    3069       PrimaryExpression();
    3070       switch (jj_nt.kind) {
    3071       case ASSIGN:
    3072       case INCR:
    3073       case DECR:
    3074       case PLUSASSIGN:
    3075       case MINUSASSIGN:
    3076       case STARASSIGN:
    3077       case SLASHASSIGN:
    3078       case ANDASSIGN:
    3079       case ORASSIGN:
    3080       case XORASSIGN:
    3081       case REMASSIGN:
    3082       case LSHIFTASSIGN:
    3083       case RSIGNEDSHIFTASSIGN:
    3084       case RUNSIGNEDSHIFTASSIGN:
    3085         switch (jj_nt.kind) {
    3086         case INCR:
    3087           jj_consume_token(INCR);
    3088           break;
    3089         case DECR:
    3090           jj_consume_token(DECR);
    3091           break;
    3092         case ASSIGN:
    3093         case PLUSASSIGN:
    3094         case MINUSASSIGN:
    3095         case STARASSIGN:
    3096         case SLASHASSIGN:
    3097         case ANDASSIGN:
    3098         case ORASSIGN:
    3099         case XORASSIGN:
    3100         case REMASSIGN:
    3101         case LSHIFTASSIGN:
    3102         case RSIGNEDSHIFTASSIGN:
    3103         case RUNSIGNEDSHIFTASSIGN:
    3104           AssignmentOperator();
    3105           Expression();
    3106           break;
    3107         default:
    3108           jj_la1[111] = jj_gen;
    3109           jj_consume_token(-1);
    3110           throw new ParseException();
    3111         }
    3112         break;
    3113       default:
    3114         jj_la1[112] = jj_gen;
    3115         ;
    3116       }
    3117       break;
    3118     default:
    3119       jj_la1[113] = jj_gen;
    3120       jj_consume_token(-1);
    3121       throw new ParseException();
    3122     }
    3123   }
    3124
    3125   final public void SwitchStatement() throws ParseException {
    3126     jj_consume_token(SWITCH);
    3127     jj_consume_token(LPAREN);
    3128     Expression();
    3129     jj_consume_token(RPAREN);
    3130     jj_consume_token(LBRACE);
    3131     label_48:
    3132     while (true) {
    3133       switch (jj_nt.kind) {
    3134       case CASE:
    3135       case _DEFAULT:
    3136         ;
    3137         break;
    3138       default:
    3139         jj_la1[114] = jj_gen;
    3140         break label_48;
    3141       }
    3142       SwitchLabel();
    3143       label_49:
    3144       while (true) {
    3145         switch (jj_nt.kind) {
    3146         case BOOLEAN:
    3147         case BREAK:
    3148         case BYTE:
    3149         case CHAR:
    3150         case CLASS:
    3151         case CONTINUE:
    3152         case DO:
    3153         case DOUBLE:
    3154         case FALSE:
    3155         case FINAL:
    3156         case FLOAT:
    3157         case FOR:
    3158         case IF:
    3159         case INT:
    3160         case INTERFACE:
    3161         case LONG:
    3162         case NEW:
    3163         case NULL:
    3164         case RETURN:
    3165         case SHORT:
    3166         case SUPER:
    3167         case SWITCH:
    3168         case SYNCHRONIZED:
    3169         case THIS:
    3170         case THROW:
    3171         case TRUE:
    3172         case TRY:
    3173         case VOID:
    3174         case WHILE:
    3175         case ASSERT:
    3176         case INTEGER_LITERAL:
    3177         case FLOATING_POINT_LITERAL:
    3178         case CHARACTER_LITERAL:
    3179         case STRING_LITERAL:
    3180         case IDENTIFIER:
    3181         case LPAREN:
    3182         case LBRACE:
    3183         case SEMICOLON:
    3184         case INCR:
    3185         case DECR:
    3186           ;
    3187           break;
    3188         default:
    3189           jj_la1[115] = jj_gen;
    3190           break label_49;
    3191         }
    3192         BlockStatement();
    3193       }
    3194     }
    3195     jj_consume_token(RBRACE);
    3196   }
    3197
    3198   final public void SwitchLabel() throws ParseException {
    3199     switch (jj_nt.kind) {
    3200     case CASE:
    3201       jj_consume_token(CASE);
    3202       Expression();
    3203       jj_consume_token(COLON);
    3204       break;
    3205     case _DEFAULT:
    3206       jj_consume_token(_DEFAULT);
    3207       jj_consume_token(COLON);
    3208       break;
    3209     default:
    3210       jj_la1[116] = jj_gen;
    3211       jj_consume_token(-1);
    3212       throw new ParseException();
    3213     }
    3214   }
    3215
    3216   final public void IfStatement() throws ParseException {
    3217     jj_consume_token(IF);
    3218     jj_consume_token(LPAREN);
    3219     Expression();
    3220     jj_consume_token(RPAREN);
    3221     Statement();
    3222     switch (jj_nt.kind) {
    3223     case ELSE:
    3224       jj_consume_token(ELSE);
    3225       Statement();
    3226       break;
    3227     default:
    3228       jj_la1[117] = jj_gen;
    3229       ;
    3230     }
    3231   }
    3232
    3233   final public void WhileStatement() throws ParseException {
    3234     jj_consume_token(WHILE);
    3235     jj_consume_token(LPAREN);
    3236     Expression();
    3237     jj_consume_token(RPAREN);
    3238     Statement();
    3239   }
    3240
    3241   final public void DoStatement() throws ParseException {
    3242     jj_consume_token(DO);
    3243     Statement();
    3244     jj_consume_token(WHILE);
    3245     jj_consume_token(LPAREN);
    3246     Expression();
    3247     jj_consume_token(RPAREN);
    3248     jj_consume_token(SEMICOLON);
    3249   }
    3250
    3251   final public void ForStatement() throws ParseException {
    3252     jj_consume_token(FOR);
    3253     jj_consume_token(LPAREN);
    3254     switch (jj_nt.kind) {
    3255     case BOOLEAN:
    3256     case BYTE:
    3257     case CHAR:
    3258     case DOUBLE:
    3259     case FALSE:
    3260     case FINAL:
    3261     case FLOAT:
    3262     case INT:
    3263     case LONG:
    3264     case NEW:
    3265     case NULL:
    3266     case SHORT:
    3267     case SUPER:
    3268     case THIS:
    3269     case TRUE:
    3270     case VOID:
    3271     case INTEGER_LITERAL:
    3272     case FLOATING_POINT_LITERAL:
    3273     case CHARACTER_LITERAL:
    3274     case STRING_LITERAL:
    3275     case IDENTIFIER:
    3276     case LPAREN:
    3277     case INCR:
    3278     case DECR:
    3279       ForInit();
    3280       break;
    3281     default:
    3282       jj_la1[118] = jj_gen;
    3283       ;
    3284     }
    3285     jj_consume_token(SEMICOLON);
    3286     switch (jj_nt.kind) {
    3287     case BOOLEAN:
    3288     case BYTE:
    3289     case CHAR:
    3290     case DOUBLE:
    3291     case FALSE:
    3292     case FLOAT:
    3293     case INT:
    3294     case LONG:
    3295     case NEW:
    3296     case NULL:
    3297     case SHORT:
    3298     case SUPER:
    3299     case THIS:
    3300     case TRUE:
    3301     case VOID:
    3302     case INTEGER_LITERAL:
    3303     case FLOATING_POINT_LITERAL:
    3304     case CHARACTER_LITERAL:
    3305     case STRING_LITERAL:
    3306     case IDENTIFIER:
    3307     case LPAREN:
    3308     case BANG:
    3309     case TILDE:
    3310     case INCR:
    3311     case DECR:
    3312     case PLUS:
    3313     case MINUS:
    3314       Expression();
    3315       break;
    3316     default:
    3317       jj_la1[119] = jj_gen;
    3318       ;
    3319     }
    3320     jj_consume_token(SEMICOLON);
    3321     switch (jj_nt.kind) {
    3322     case BOOLEAN:
    3323     case BYTE:
    3324     case CHAR:
    3325     case DOUBLE:
    3326     case FALSE:
    3327     case FLOAT:
    3328     case INT:
    3329     case LONG:
    3330     case NEW:
    3331     case NULL:
    3332     case SHORT:
    3333     case SUPER:
    3334     case THIS:
    3335     case TRUE:
    3336     case VOID:
    3337     case INTEGER_LITERAL:
    3338     case FLOATING_POINT_LITERAL:
    3339     case CHARACTER_LITERAL:
    3340     case STRING_LITERAL:
    3341     case IDENTIFIER:
    3342     case LPAREN:
    3343     case INCR:
    3344     case DECR:
    3345       ForUpdate();
    3346       break;
    3347     default:
    3348       jj_la1[120] = jj_gen;
    3349       ;
    3350     }
    3351     jj_consume_token(RPAREN);
    3352     Statement();
    3353   }
    3354
    3355   final public void ForInit() throws ParseException {
    3356     if (jj_2_31(2147483647)) {
    3357       LocalVariableDeclaration();
    3358     } else {
    3359       switch (jj_nt.kind) {
    3360       case BOOLEAN:
    3361       case BYTE:
    3362       case CHAR:
    3363       case DOUBLE:
    3364       case FALSE:
    3365       case FLOAT:
    3366       case INT:
    3367       case LONG:
    3368       case NEW:
    3369       case NULL:
    3370       case SHORT:
    3371       case SUPER:
    3372       case THIS:
    3373       case TRUE:
    3374       case VOID:
    3375       case INTEGER_LITERAL:
    3376       case FLOATING_POINT_LITERAL:
    3377       case CHARACTER_LITERAL:
    3378       case STRING_LITERAL:
    3379       case IDENTIFIER:
    3380       case LPAREN:
    3381       case INCR:
    3382       case DECR:
    3383         StatementExpressionList();
    3384         break;
    3385       default:
    3386         jj_la1[121] = jj_gen;
    3387         jj_consume_token(-1);
    3388         throw new ParseException();
    3389       }
    3390     }
    3391   }
    3392
    3393   final public void StatementExpressionList() throws ParseException {
    3394     StatementExpression();
    3395     label_50:
    3396     while (true) {
    3397       switch (jj_nt.kind) {
    3398       case COMMA:
    3399         ;
    3400         break;
    3401       default:
    3402         jj_la1[122] = jj_gen;
    3403         break label_50;
    3404       }
    3405       jj_consume_token(COMMA);
    3406       StatementExpression();
    3407     }
    3408   }
    3409
    3410   final public void ForUpdate() throws ParseException {
    3411     StatementExpressionList();
    3412   }
    3413
    3414   final public void BreakStatement() throws ParseException {
    3415     jj_consume_token(BREAK);
    3416     switch (jj_nt.kind) {
    3417     case IDENTIFIER:
    3418       jj_consume_token(IDENTIFIER);
    3419       break;
    3420     default:
    3421       jj_la1[123] = jj_gen;
    3422       ;
    3423     }
    3424     jj_consume_token(SEMICOLON);
    3425   }
    3426
    3427   final public void ContinueStatement() throws ParseException {
    3428     jj_consume_token(CONTINUE);
    3429     switch (jj_nt.kind) {
    3430     case IDENTIFIER:
    3431       jj_consume_token(IDENTIFIER);
    3432       break;
    3433     default:
    3434       jj_la1[124] = jj_gen;
    3435       ;
    3436     }
    3437     jj_consume_token(SEMICOLON);
    3438   }
    3439
    3440   final public void ReturnStatement() throws ParseException {
    3441     jj_consume_token(RETURN);
    3442     switch (jj_nt.kind) {
    3443     case BOOLEAN:
    3444     case BYTE:
    3445     case CHAR:
    3446     case DOUBLE:
    3447     case FALSE:
    3448     case FLOAT:
    3449     case INT:
    3450     case LONG:
    3451     case NEW:
    3452     case NULL:
    3453     case SHORT:
    3454     case SUPER:
    3455     case THIS:
    3456     case TRUE:
    3457     case VOID:
    3458     case INTEGER_LITERAL:
    3459     case FLOATING_POINT_LITERAL:
    3460     case CHARACTER_LITERAL:
    3461     case STRING_LITERAL:
    3462     case IDENTIFIER:
    3463     case LPAREN:
    3464     case BANG:
    3465     case TILDE:
    3466     case INCR:
    3467     case DECR:
    3468     case PLUS:
    3469     case MINUS:
    3470       Expression();
    3471       break;
    3472     default:
    3473       jj_la1[125] = jj_gen;
    3474       ;
    3475     }
    3476     jj_consume_token(SEMICOLON);
    3477   }
    3478
    3479   final public void ThrowStatement() throws ParseException {
    3480     jj_consume_token(THROW);
    3481     Expression();
    3482     jj_consume_token(SEMICOLON);
    3483   }
    3484
    3485   final public void SynchronizedStatement() throws ParseException {
    3486     jj_consume_token(SYNCHRONIZED);
    3487     jj_consume_token(LPAREN);
    3488     Expression();
    3489     jj_consume_token(RPAREN);
    3490     Block();
    3491   }
    3492
    3493   final public void TryStatement() throws ParseException {
    3494     jj_consume_token(TRY);
    3495     Block();
    3496     label_51:
    3497     while (true) {
    3498       switch (jj_nt.kind) {
    3499       case CATCH:
    3500         ;
    3501         break;
    3502       default:
    3503         jj_la1[126] = jj_gen;
    3504         break label_51;
    3505       }
    3506       jj_consume_token(CATCH);
    3507       jj_consume_token(LPAREN);
    3508       FormalParameter(null);
    3509       jj_consume_token(RPAREN);
    3510       Block();
    3511     }
    3512     switch (jj_nt.kind) {
    3513     case FINALLY:
    3514       jj_consume_token(FINALLY);
    3515       Block();
    3516       break;
    3517     default:
    3518       jj_la1[127] = jj_gen;
    3519       ;
    3520     }
    3521   }
    3522
    3523   final public void AssertStatement() throws ParseException {
    3524     jj_consume_token(ASSERT);
    3525     Expression();
    3526     switch (jj_nt.kind) {
    3527     case COLON:
    3528       jj_consume_token(COLON);
    3529       Expression();
    3530       break;
    3531     default:
    3532       jj_la1[128] = jj_gen;
    3533       ;
    3534     }
    3535     jj_consume_token(SEMICOLON);
    3536   }
    3537
    3538   final private boolean jj_2_1(int xla) {
    3539     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3540     boolean retval = !jj_3_1();
    3541     jj_save(0, xla);
    3542     return retval;
    3543   }
    3544
    3545   final private boolean jj_2_2(int xla) {
    3546     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3547     boolean retval = !jj_3_2();
    3548     jj_save(1, xla);
    3549     return retval;
    3550   }
    3551
    3552   final private boolean jj_2_3(int xla) {
    3553     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3554     boolean retval = !jj_3_3();
    3555     jj_save(2, xla);
    3556     return retval;
    3557   }
    3558
    3559   final private boolean jj_2_4(int xla) {
    3560     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3561     boolean retval = !jj_3_4();
    3562     jj_save(3, xla);
    3563     return retval;
    3564   }
    3565
    3566   final private boolean jj_2_5(int xla) {
    3567     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3568     boolean retval = !jj_3_5();
    3569     jj_save(4, xla);
    3570     return retval;
    3571   }
    3572
    3573   final private boolean jj_2_6(int xla) {
    3574     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3575     boolean retval = !jj_3_6();
    3576     jj_save(5, xla);
    3577     return retval;
    3578   }
    3579
    3580   final private boolean jj_2_7(int xla) {
    3581     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3582     boolean retval = !jj_3_7();
    3583     jj_save(6, xla);
    3584     return retval;
    3585   }
    3586
    3587   final private boolean jj_2_8(int xla) {
    3588     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3589     boolean retval = !jj_3_8();
    3590     jj_save(7, xla);
    3591     return retval;
    3592   }
    3593
    3594   final private boolean jj_2_9(int xla) {
    3595     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3596     boolean retval = !jj_3_9();
    3597     jj_save(8, xla);
    3598     return retval;
    3599   }
    3600
    3601   final private boolean jj_2_10(int xla) {
    3602     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3603     boolean retval = !jj_3_10();
    3604     jj_save(9, xla);
    3605     return retval;
    3606   }
    3607
    3608   final private boolean jj_2_11(int xla) {
    3609     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3610     boolean retval = !jj_3_11();
    3611     jj_save(10, xla);
    3612     return retval;
    3613   }
    3614
    3615   final private boolean jj_2_12(int xla) {
    3616     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3617     boolean retval = !jj_3_12();
    3618     jj_save(11, xla);
    3619     return retval;
    3620   }
    3621
    3622   final private boolean jj_2_13(int xla) {
    3623     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3624     boolean retval = !jj_3_13();
    3625     jj_save(12, xla);
    3626     return retval;
    3627   }
    3628
    3629   final private boolean jj_2_14(int xla) {
    3630     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3631     boolean retval = !jj_3_14();
    3632     jj_save(13, xla);
    3633     return retval;
    3634   }
    3635
    3636   final private boolean jj_2_15(int xla) {
    3637     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3638     boolean retval = !jj_3_15();
    3639     jj_save(14, xla);
    3640     return retval;
    3641   }
    3642
    3643   final private boolean jj_2_16(int xla) {
    3644     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3645     boolean retval = !jj_3_16();
    3646     jj_save(15, xla);
    3647     return retval;
    3648   }
    3649
    3650   final private boolean jj_2_17(int xla) {
    3651     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3652     boolean retval = !jj_3_17();
    3653     jj_save(16, xla);
    3654     return retval;
    3655   }
    3656
    3657   final private boolean jj_2_18(int xla) {
    3658     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3659     boolean retval = !jj_3_18();
    3660     jj_save(17, xla);
    3661     return retval;
    3662   }
    3663
    3664   final private boolean jj_2_19(int xla) {
    3665     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3666     boolean retval = !jj_3_19();
    3667     jj_save(18, xla);
    3668     return retval;
    3669   }
    3670
    3671   final private boolean jj_2_20(int xla) {
    3672     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3673     boolean retval = !jj_3_20();
    3674     jj_save(19, xla);
    3675     return retval;
    3676   }
    3677
    3678   final private boolean jj_2_21(int xla) {
    3679     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3680     boolean retval = !jj_3_21();
    3681     jj_save(20, xla);
    3682     return retval;
    3683   }
    3684
    3685   final private boolean jj_2_22(int xla) {
    3686     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3687     boolean retval = !jj_3_22();
    3688     jj_save(21, xla);
    3689     return retval;
    3690   }
    3691
    3692   final private boolean jj_2_23(int xla) {
    3693     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3694     boolean retval = !jj_3_23();
    3695     jj_save(22, xla);
    3696     return retval;
    3697   }
    3698
    3699   final private boolean jj_2_24(int xla) {
    3700     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3701     boolean retval = !jj_3_24();
    3702     jj_save(23, xla);
    3703     return retval;
    3704   }
    3705
    3706   final private boolean jj_2_25(int xla) {
    3707     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3708     boolean retval = !jj_3_25();
    3709     jj_save(24, xla);
    3710     return retval;
    3711   }
    3712
    3713   final private boolean jj_2_26(int xla) {
    3714     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3715     boolean retval = !jj_3_26();
    3716     jj_save(25, xla);
    3717     return retval;
    3718   }
    3719
    3720   final private boolean jj_2_27(int xla) {
    3721     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3722     boolean retval = !jj_3_27();
    3723     jj_save(26, xla);
    3724     return retval;
    3725   }
    3726
    3727   final private boolean jj_2_28(int xla) {
    3728     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3729     boolean retval = !jj_3_28();
    3730     jj_save(27, xla);
    3731     return retval;
    3732   }
    3733
    3734   final private boolean jj_2_29(int xla) {
    3735     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3736     boolean retval = !jj_3_29();
    3737     jj_save(28, xla);
    3738     return retval;
    3739   }
    3740
    3741   final private boolean jj_2_30(int xla) {
    3742     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3743     boolean retval = !jj_3_30();
    3744     jj_save(29, xla);
    3745     return retval;
    3746   }
    3747
    3748   final private boolean jj_2_31(int xla) {
    3749     jj_la = xla; jj_lastpos = jj_scanpos = token;
    3750     boolean retval = !jj_3_31();
    3751     jj_save(30, xla);
    3752     return retval;
    3753   }
    3754
    3755   final private boolean jj_3R_170() {
    3756     Token xsp;
    3757     xsp = jj_scanpos;
    3758     if (jj_3R_180()) {
    3759     jj_scanpos = xsp;
    3760     if (jj_3R_181()) {
    3761     jj_scanpos = xsp;
    3762     if (jj_3R_182()) {
    3763     jj_scanpos = xsp;
    3764     if (jj_3R_183()) {
    3765     jj_scanpos = xsp;
    3766     if (jj_3R_184()) {
    3767     jj_scanpos = xsp;
    3768     if (jj_3R_185()) return true;
    3769     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3770     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3771     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3772     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3773     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3774     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3775     return false;
    3776   }
    3777
    3778   final private boolean jj_3R_180() {
    3779     if (jj_scan_token(INTEGER_LITERAL)) return true;
    3780     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3781     return false;
    3782   }
    3783
    3784   final private boolean jj_3R_147() {
    3785     if (jj_scan_token(NATIVE)) return true;
    3786     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3787     return false;
    3788   }
    3789
    3790   final private boolean jj_3R_132() {
    3791     if (jj_3R_64()) return true;
    3792     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3793     return false;
    3794   }
    3795
    3796   final private boolean jj_3R_164() {
    3797     if (jj_scan_token(SUPER)) return true;
    3798     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3799     return false;
    3800   }
    3801
    3802   final private boolean jj_3R_131() {
    3803     if (jj_scan_token(DOT)) return true;
    3804     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3805     if (jj_scan_token(IDENTIFIER)) return true;
    3806     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3807     return false;
    3808   }
    3809
    3810   final private boolean jj_3R_130() {
    3811     if (jj_scan_token(LBRACKET)) return true;
    3812     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3813     if (jj_3R_70()) return true;
    3814     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3815     if (jj_scan_token(RBRACKET)) return true;
    3816     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3817     return false;
    3818   }
    3819
    3820   final private boolean jj_3R_95() {
    3821     if (jj_scan_token(STRICTFP)) return true;
    3822     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3823     return false;
    3824   }
    3825
    3826   final private boolean jj_3_23() {
    3827     if (jj_scan_token(DOT)) return true;
    3828     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3829     if (jj_3R_69()) return true;
    3830     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3831     return false;
    3832   }
    3833
    3834   final private boolean jj_3R_88() {
    3835     if (jj_scan_token(STRICTFP)) return true;
    3836     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3837     return false;
    3838   }
    3839
    3840   final private boolean jj_3R_332() {
    3841     if (jj_scan_token(STRICTFP)) return true;
    3842     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3843     return false;
    3844   }
    3845
    3846   final private boolean jj_3R_146() {
    3847     if (jj_scan_token(FINAL)) return true;
    3848     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3849     return false;
    3850   }
    3851
    3852   final private boolean jj_3R_163() {
    3853     if (jj_scan_token(THIS)) return true;
    3854     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3855     return false;
    3856   }
    3857
    3858   final private boolean jj_3_22() {
    3859     if (jj_scan_token(DOT)) return true;
    3860     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3861     if (jj_scan_token(SUPER)) return true;
    3862     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3863     return false;
    3864   }
    3865
    3866   final private boolean jj_3_20() {
    3867     if (jj_3R_68()) return true;
    3868     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3869     if (jj_scan_token(DOT)) return true;
    3870     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3871     if (jj_scan_token(CLASS)) return true;
    3872     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3873     return false;
    3874   }
    3875
    3876   final private boolean jj_3R_331() {
    3877     if (jj_scan_token(PRIVATE)) return true;
    3878     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3879     return false;
    3880   }
    3881
    3882   final private boolean jj_3_21() {
    3883     if (jj_scan_token(DOT)) return true;
    3884     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3885     if (jj_scan_token(THIS)) return true;
    3886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3887     return false;
    3888   }
    3889
    3890   final private boolean jj_3R_67() {
    3891     Token xsp;
    3892     xsp = jj_scanpos;
    3893     if (jj_3_21()) {
    3894     jj_scanpos = xsp;
    3895     if (jj_3_22()) {
    3896     jj_scanpos = xsp;
    3897     if (jj_3_23()) {
    3898     jj_scanpos = xsp;
    3899     if (jj_3R_130()) {
    3900     jj_scanpos = xsp;
    3901     if (jj_3R_131()) {
    3902     jj_scanpos = xsp;
    3903     if (jj_3R_132()) return true;
    3904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3905     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3906     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3907     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3908     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3909     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3910     return false;
    3911   }
    3912
    3913   final private boolean jj_3R_330() {
    3914     if (jj_scan_token(PROTECTED)) return true;
    3915     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3916     return false;
    3917   }
    3918
    3919   final private boolean jj_3R_94() {
    3920     if (jj_scan_token(PRIVATE)) return true;
    3921     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3922     return false;
    3923   }
    3924
    3925   final private boolean jj_3R_157() {
    3926     if (jj_3R_57()) return true;
    3927     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3928     return false;
    3929   }
    3930
    3931   final private boolean jj_3R_87() {
    3932     if (jj_scan_token(PRIVATE)) return true;
    3933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3934     return false;
    3935   }
    3936
    3937   final private boolean jj_3_19() {
    3938     if (jj_3R_67()) return true;
    3939     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3940     return false;
    3941   }
    3942
    3943   final private boolean jj_3R_329() {
    3944     if (jj_scan_token(PUBLIC)) return true;
    3945     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3946     return false;
    3947   }
    3948
    3949   final private boolean jj_3R_156() {
    3950     if (jj_3R_68()) return true;
    3951     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3952     if (jj_scan_token(DOT)) return true;
    3953     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3954     if (jj_scan_token(CLASS)) return true;
    3955     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3956     return false;
    3957   }
    3958
    3959   final private boolean jj_3R_145() {
    3960     if (jj_scan_token(ABSTRACT)) return true;
    3961     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3962     return false;
    3963   }
    3964
    3965   final private boolean jj_3R_155() {
    3966     if (jj_3R_69()) return true;
    3967     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3968     return false;
    3969   }
    3970
    3971   final private boolean jj_3R_430() {
    3972     if (jj_scan_token(DECR)) return true;
    3973     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3974     return false;
    3975   }
    3976
    3977   final private boolean jj_3R_328() {
    3978     if (jj_scan_token(FINAL)) return true;
    3979     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3980     return false;
    3981   }
    3982
    3983   final private boolean jj_3R_162() {
    3984     if (jj_scan_token(IDENTIFIER)) return true;
    3985     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3986     return false;
    3987   }
    3988
    3989   final private boolean jj_3R_154() {
    3990     if (jj_scan_token(LPAREN)) return true;
    3991     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3992     if (jj_3R_70()) return true;
    3993     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3994     if (jj_scan_token(RPAREN)) return true;
    3995     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3996     return false;
    3997   }
    3998
    3999   final private boolean jj_3R_153() {
    4000     if (jj_scan_token(SUPER)) return true;
    4001     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4002     if (jj_scan_token(DOT)) return true;
    4003     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4004     if (jj_scan_token(IDENTIFIER)) return true;
    4005     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4006     return false;
    4007   }
    4008
    4009   final private boolean jj_3R_327() {
    4010     if (jj_scan_token(ABSTRACT)) return true;
    4011     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4012     return false;
    4013   }
    4014
    4015   final private boolean jj_3R_152() {
    4016     if (jj_scan_token(THIS)) return true;
    4017     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4018     return false;
    4019   }
    4020
    4021   final private boolean jj_3R_93() {
    4022     if (jj_scan_token(PROTECTED)) return true;
    4023     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4024     return false;
    4025   }
    4026
    4027   final private boolean jj_3R_161() {
    4028     if (jj_scan_token(LPAREN)) return true;
    4029     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4030     return false;
    4031   }
    4032
    4033   final private boolean jj_3R_429() {
    4034     if (jj_scan_token(INCR)) return true;
    4035     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4036     return false;
    4037   }
    4038
    4039   final private boolean jj_3R_423() {
    4040     Token xsp;
    4041     xsp = jj_scanpos;
    4042     if (jj_3R_429()) {
    4043     jj_scanpos = xsp;
    4044     if (jj_3R_430()) return true;
    4045     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4046     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4047     return false;
    4048   }
    4049
    4050   final private boolean jj_3R_151() {
    4051     if (jj_3R_170()) return true;
    4052     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4053     return false;
    4054   }
    4055
    4056   final private boolean jj_3R_118() {
    4057     Token xsp;
    4058     xsp = jj_scanpos;
    4059     if (jj_3R_151()) {
    4060     jj_scanpos = xsp;
    4061     if (jj_3R_152()) {
    4062     jj_scanpos = xsp;
    4063     if (jj_3R_153()) {
    4064     jj_scanpos = xsp;
    4065     if (jj_3R_154()) {
    4066     jj_scanpos = xsp;
    4067     if (jj_3R_155()) {
    4068     jj_scanpos = xsp;
    4069     if (jj_3R_156()) {
    4070     jj_scanpos = xsp;
    4071     if (jj_3R_157()) return true;
    4072     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4073     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4074     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4075     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4076     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4077     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4078     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4079     return false;
    4080   }
    4081
    4082   final private boolean jj_3R_326() {
    4083     if (jj_scan_token(STATIC)) return true;
    4084     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4085     return false;
    4086   }
    4087
    4088   final private boolean jj_3R_295() {
    4089     Token xsp;
    4090     xsp = jj_scanpos;
    4091     if (jj_3R_326()) {
    4092     jj_scanpos = xsp;
    4093     if (jj_3R_327()) {
    4094     jj_scanpos = xsp;
    4095     if (jj_3R_328()) {
    4096     jj_scanpos = xsp;
    4097     if (jj_3R_329()) {
    4098     jj_scanpos = xsp;
    4099     if (jj_3R_330()) {
    4100     jj_scanpos = xsp;
    4101     if (jj_3R_331()) {
    4102     jj_scanpos = xsp;
    4103     if (jj_3R_332()) return true;
    4104     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4105     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4106     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4107     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4108     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4109     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4110     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4111     return false;
    4112   }
    4113
    4114   final private boolean jj_3R_144() {
    4115     if (jj_scan_token(STATIC)) return true;
    4116     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4117     return false;
    4118   }
    4119
    4120   final private boolean jj_3R_86() {
    4121     if (jj_scan_token(PROTECTED)) return true;
    4122     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4123     return false;
    4124   }
    4125
    4126   final private boolean jj_3R_281() {
    4127     Token xsp;
    4128     while (true) {
    4129       xsp = jj_scanpos;
    4130       if (jj_3R_295()) { jj_scanpos = xsp; break; }
    4131       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4132     }
    4133     if (jj_3R_191()) return true;
    4134     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4135     return false;
    4136   }
    4137
    4138   final private boolean jj_3R_160() {
    4139     if (jj_scan_token(BANG)) return true;
    4140     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4141     return false;
    4142   }
    4143
    4144   final private boolean jj_3_18() {
    4145     if (jj_scan_token(LPAREN)) return true;
    4146     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4147     if (jj_3R_66()) return true;
    4148     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4149     return false;
    4150   }
    4151
    4152   final private boolean jj_3R_63() {
    4153     if (jj_3R_118()) return true;
    4154     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4155     Token xsp;
    4156     while (true) {
    4157       xsp = jj_scanpos;
    4158       if (jj_3_19()) { jj_scanpos = xsp; break; }
    4159       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4160     }
    4161     return false;
    4162   }
    4163
    4164   final private boolean jj_3R_92() {
    4165     if (jj_scan_token(PUBLIC)) return true;
    4166     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4167     return false;
    4168   }
    4169
    4170   final private boolean jj_3R_159() {
    4171     if (jj_scan_token(TILDE)) return true;
    4172     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4173     return false;
    4174   }
    4175
    4176   final private boolean jj_3R_397() {
    4177     if (jj_scan_token(LPAREN)) return true;
    4178     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4179     if (jj_3R_73()) return true;
    4180     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4181     if (jj_scan_token(RPAREN)) return true;
    4182     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4183     if (jj_3R_316()) return true;
    4184     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4185     return false;
    4186   }
    4187
    4188   final private boolean jj_3R_85() {
    4189     if (jj_scan_token(PUBLIC)) return true;
    4190     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4191     return false;
    4192   }
    4193
    4194   final private boolean jj_3R_143() {
    4195     if (jj_scan_token(PRIVATE)) return true;
    4196     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4197     return false;
    4198   }
    4199
    4200   final private boolean jj_3R_396() {
    4201     if (jj_scan_token(LPAREN)) return true;
    4202     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4203     if (jj_3R_73()) return true;
    4204     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4205     if (jj_scan_token(RPAREN)) return true;
    4206     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4207     if (jj_3R_279()) return true;
    4208     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4209     return false;
    4210   }
    4211
    4212   final private boolean jj_3R_383() {
    4213     Token xsp;
    4214     xsp = jj_scanpos;
    4215     if (jj_3R_396()) {
    4216     jj_scanpos = xsp;
    4217     if (jj_3R_397()) return true;
    4218     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4219     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4220     return false;
    4221   }
    4222
    4223   final private boolean jj_3R_98() {
    4224     if (jj_scan_token(PRIVATE)) return true;
    4225     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4226     return false;
    4227   }
    4228
    4229   final private boolean jj_3R_91() {
    4230     if (jj_scan_token(FINAL)) return true;
    4231     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4232     return false;
    4233   }
    4234
    4235   final private boolean jj_3_17() {
    4236     if (jj_scan_token(LPAREN)) return true;
    4237     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4238     if (jj_3R_57()) return true;
    4239     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4240     if (jj_scan_token(LBRACKET)) return true;
    4241     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4242     return false;
    4243   }
    4244
    4245   final private boolean jj_3R_384() {
    4246     if (jj_3R_63()) return true;
    4247     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4248     Token xsp;
    4249     xsp = jj_scanpos;
    4250     if (jj_3R_423()) jj_scanpos = xsp;
    4251     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4252     return false;
    4253   }
    4254
    4255   final private boolean jj_3R_84() {
    4256     if (jj_scan_token(FINAL)) return true;
    4257     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4258     return false;
    4259   }
    4260
    4261   final private boolean jj_3R_142() {
    4262     if (jj_scan_token(PROTECTED)) return true;
    4263     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4264     return false;
    4265   }
    4266
    4267   final private boolean jj_3R_121() {
    4268     if (jj_scan_token(LPAREN)) return true;
    4269     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4270     if (jj_3R_57()) return true;
    4271     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4272     if (jj_scan_token(RPAREN)) return true;
    4273     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4274     Token xsp;
    4275     xsp = jj_scanpos;
    4276     if (jj_3R_159()) {
    4277     jj_scanpos = xsp;
    4278     if (jj_3R_160()) {
    4279     jj_scanpos = xsp;
    4280     if (jj_3R_161()) {
    4281     jj_scanpos = xsp;
    4282     if (jj_3R_162()) {
    4283     jj_scanpos = xsp;
    4284     if (jj_3R_163()) {
    4285     jj_scanpos = xsp;
    4286     if (jj_3R_164()) {
    4287     jj_scanpos = xsp;
    4288     if (jj_3R_165()) {
    4289     jj_scanpos = xsp;
    4290     if (jj_3R_166()) return true;
    4291     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4292     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4293     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4294     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4295     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4296     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4297     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4298     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4299     return false;
    4300   }
    4301
    4302   final private boolean jj_3R_97() {
    4303     if (jj_scan_token(PROTECTED)) return true;
    4304     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4305     return false;
    4306   }
    4307
    4308   final private boolean jj_3R_120() {
    4309     if (jj_scan_token(LPAREN)) return true;
    4310     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4311     if (jj_3R_57()) return true;
    4312     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4313     if (jj_scan_token(LBRACKET)) return true;
    4314     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4315     if (jj_scan_token(RBRACKET)) return true;
    4316     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4317     return false;
    4318   }
    4319
    4320   final private boolean jj_3R_90() {
    4321     if (jj_scan_token(ABSTRACT)) return true;
    4322     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4323     return false;
    4324   }
    4325
    4326   final private boolean jj_3_16() {
    4327     if (jj_scan_token(LPAREN)) return true;
    4328     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4329     if (jj_3R_66()) return true;
    4330     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4331     return false;
    4332   }
    4333
    4334   final private boolean jj_3R_65() {
    4335     Token xsp;
    4336     xsp = jj_scanpos;
    4337     if (jj_3_16()) {
    4338     jj_scanpos = xsp;
    4339     if (jj_3R_120()) {
    4340     jj_scanpos = xsp;
    4341     if (jj_3R_121()) return true;
    4342     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4343     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4344     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4345     return false;
    4346   }
    4347
    4348   final private boolean jj_3_15() {
    4349     if (jj_3R_65()) return true;
    4350     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4351     return false;
    4352   }
    4353
    4354   final private boolean jj_3R_83() {
    4355     if (jj_scan_token(ABSTRACT)) return true;
    4356     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4357     return false;
    4358   }
    4359
    4360   final private boolean jj_3R_141() {
    4361     if (jj_scan_token(PUBLIC)) return true;
    4362     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4363     return false;
    4364   }
    4365
    4366   final private boolean jj_3R_99() {
    4367     Token xsp;
    4368     xsp = jj_scanpos;
    4369     if (jj_3R_141()) {
    4370     jj_scanpos = xsp;
    4371     if (jj_3R_142()) {
    4372     jj_scanpos = xsp;
    4373     if (jj_3R_143()) {
    4374     jj_scanpos = xsp;
    4375     if (jj_3R_144()) {
    4376     jj_scanpos = xsp;
    4377     if (jj_3R_145()) {
    4378     jj_scanpos = xsp;
    4379     if (jj_3R_146()) {
    4380     jj_scanpos = xsp;
    4381     if (jj_3R_147()) {
    4382     jj_scanpos = xsp;
    4383     if (jj_3R_148()) {
    4384     jj_scanpos = xsp;
    4385     if (jj_3R_149()) return true;
    4386     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4387     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4388     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4389     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4390     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4391     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4392     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4393     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4394     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4395     return false;
    4396   }
    4397
    4398   final private boolean jj_3R_382() {
    4399     if (jj_scan_token(BANG)) return true;
    4400     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4401     return false;
    4402   }
    4403
    4404   final private boolean jj_3_6() {
    4405     if (jj_3R_58()) return true;
    4406     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4407     return false;
    4408   }
    4409
    4410   final private boolean jj_3R_96() {
    4411     if (jj_scan_token(PUBLIC)) return true;
    4412     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4413     return false;
    4414   }
    4415
    4416   final private boolean jj_3R_56() {
    4417     Token xsp;
    4418     xsp = jj_scanpos;
    4419     if (jj_3R_96()) {
    4420     jj_scanpos = xsp;
    4421     if (jj_3R_97()) {
    4422     jj_scanpos = xsp;
    4423     if (jj_3R_98()) return true;
    4424     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4425     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4426     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4427     return false;
    4428   }
    4429
    4430   final private boolean jj_3R_58() {
    4431     Token xsp;
    4432     while (true) {
    4433       xsp = jj_scanpos;
    4434       if (jj_3R_99()) { jj_scanpos = xsp; break; }
    4435       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4436     }
    4437     if (jj_3R_68()) return true;
    4438     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4439     if (jj_scan_token(IDENTIFIER)) return true;
    4440     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4441     if (jj_scan_token(LPAREN)) return true;
    4442     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4443     return false;
    4444   }
    4445
    4446   final private boolean jj_3R_368() {
    4447     if (jj_3R_384()) return true;
    4448     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4449     return false;
    4450   }
    4451
    4452   final private boolean jj_3_5() {
    4453     Token xsp;
    4454     xsp = jj_scanpos;
    4455     if (jj_3R_56()) jj_scanpos = xsp;
    4456     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4457     if (jj_3R_57()) return true;
    4458     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4459     if (jj_scan_token(LPAREN)) return true;
    4460     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4461     return false;
    4462   }
    4463
    4464   final private boolean jj_3R_380() {
    4465     if (jj_scan_token(REM)) return true;
    4466     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4467     return false;
    4468   }
    4469
    4470   final private boolean jj_3R_55() {
    4471     Token xsp;
    4472     xsp = jj_scanpos;
    4473     if (jj_3R_89()) {
    4474     jj_scanpos = xsp;
    4475     if (jj_3R_90()) {
    4476     jj_scanpos = xsp;
    4477     if (jj_3R_91()) {
    4478     jj_scanpos = xsp;
    4479     if (jj_3R_92()) {
    4480     jj_scanpos = xsp;
    4481     if (jj_3R_93()) {
    4482     jj_scanpos = xsp;
    4483     if (jj_3R_94()) {
    4484     jj_scanpos = xsp;
    4485     if (jj_3R_95()) return true;
    4486     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4487     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4488     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4489     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4490     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4491     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4492     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4493     return false;
    4494   }
    4495
    4496   final private boolean jj_3R_89() {
    4497     if (jj_scan_token(STATIC)) return true;
    4498     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4499     return false;
    4500   }
    4501
    4502   final private boolean jj_3R_381() {
    4503     if (jj_scan_token(TILDE)) return true;
    4504     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4505     return false;
    4506   }
    4507
    4508   final private boolean jj_3R_367() {
    4509     if (jj_3R_383()) return true;
    4510     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4511     return false;
    4512   }
    4513
    4514   final private boolean jj_3_4() {
    4515     Token xsp;
    4516     while (true) {
    4517       xsp = jj_scanpos;
    4518       if (jj_3R_55()) { jj_scanpos = xsp; break; }
    4519       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4520     }
    4521     if (jj_scan_token(INTERFACE)) return true;
    4522     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4523     return false;
    4524   }
    4525
    4526   final private boolean jj_3R_365() {
    4527     if (jj_scan_token(MINUS)) return true;
    4528     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4529     return false;
    4530   }
    4531
    4532   final private boolean jj_3R_54() {
    4533     Token xsp;
    4534     xsp = jj_scanpos;
    4535     if (jj_3R_82()) {
    4536     jj_scanpos = xsp;
    4537     if (jj_3R_83()) {
    4538     jj_scanpos = xsp;
    4539     if (jj_3R_84()) {
    4540     jj_scanpos = xsp;
    4541     if (jj_3R_85()) {
    4542     jj_scanpos = xsp;
    4543     if (jj_3R_86()) {
    4544     jj_scanpos = xsp;
    4545     if (jj_3R_87()) {
    4546     jj_scanpos = xsp;
    4547     if (jj_3R_88()) return true;
    4548     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4549     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4550     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4551     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4552     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4553     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4554     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4555     return false;
    4556   }
    4557
    4558   final private boolean jj_3R_82() {
    4559     if (jj_scan_token(STATIC)) return true;
    4560     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4561     return false;
    4562   }
    4563
    4564   final private boolean jj_3R_366() {
    4565     Token xsp;
    4566     xsp = jj_scanpos;
    4567     if (jj_3R_381()) {
    4568     jj_scanpos = xsp;
    4569     if (jj_3R_382()) return true;
    4570     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4571     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4572     if (jj_3R_279()) return true;
    4573     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4574     return false;
    4575   }
    4576
    4577   final private boolean jj_3R_316() {
    4578     Token xsp;
    4579     xsp = jj_scanpos;
    4580     if (jj_3R_366()) {
    4581     jj_scanpos = xsp;
    4582     if (jj_3R_367()) {
    4583     jj_scanpos = xsp;
    4584     if (jj_3R_368()) return true;
    4585     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4586     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4587     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4588     return false;
    4589   }
    4590
    4591   final private boolean jj_3R_277() {
    4592     if (jj_3R_284()) return true;
    4593     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4594     return false;
    4595   }
    4596
    4597   final private boolean jj_3_3() {
    4598     Token xsp;
    4599     while (true) {
    4600       xsp = jj_scanpos;
    4601       if (jj_3R_54()) { jj_scanpos = xsp; break; }
    4602       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4603     }
    4604     if (jj_scan_token(CLASS)) return true;
    4605     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4606     return false;
    4607   }
    4608
    4609   final private boolean jj_3R_379() {
    4610     if (jj_scan_token(SLASH)) return true;
    4611     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4612     return false;
    4613   }
    4614
    4615   final private boolean jj_3R_313() {
    4616     if (jj_scan_token(RUNSIGNEDSHIFT)) return true;
    4617     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4618     return false;
    4619   }
    4620
    4621   final private boolean jj_3R_276() {
    4622     if (jj_3R_283()) return true;
    4623     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4624     return false;
    4625   }
    4626
    4627   final private boolean jj_3R_364() {
    4628     if (jj_scan_token(PLUS)) return true;
    4629     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4630     return false;
    4631   }
    4632
    4633   final private boolean jj_3R_275() {
    4634     if (jj_3R_282()) return true;
    4635     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4636     return false;
    4637   }
    4638
    4639   final private boolean jj_3R_254() {
    4640     if (jj_scan_token(DECR)) return true;
    4641     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4642     if (jj_3R_63()) return true;
    4643     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4644     return false;
    4645   }
    4646
    4647   final private boolean jj_3R_310() {
    4648     Token xsp;
    4649     xsp = jj_scanpos;
    4650     if (jj_3R_364()) {
    4651     jj_scanpos = xsp;
    4652     if (jj_3R_365()) return true;
    4653     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4654     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4655     if (jj_3R_272()) return true;
    4656     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4657     return false;
    4658   }
    4659
    4660   final private boolean jj_3R_289() {
    4661     if (jj_scan_token(GE)) return true;
    4662     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4663     return false;
    4664   }
    4665
    4666   final private boolean jj_3R_378() {
    4667     if (jj_scan_token(STAR)) return true;
    4668     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4669     return false;
    4670   }
    4671
    4672   final private boolean jj_3R_274() {
    4673     if (jj_3R_281()) return true;
    4674     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4675     return false;
    4676   }
    4677
    4678   final private boolean jj_3R_363() {
    4679     Token xsp;
    4680     xsp = jj_scanpos;
    4681     if (jj_3R_378()) {
    4682     jj_scanpos = xsp;
    4683     if (jj_3R_379()) {
    4684     jj_scanpos = xsp;
    4685     if (jj_3R_380()) return true;
    4686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4687     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4688     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4689     if (jj_3R_279()) return true;
    4690     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4691     return false;
    4692   }
    4693
    4694   final private boolean jj_3R_312() {
    4695     if (jj_scan_token(RSIGNEDSHIFT)) return true;
    4696     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4697     return false;
    4698   }
    4699
    4700   final private boolean jj_3R_273() {
    4701     if (jj_3R_280()) return true;
    4702     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4703     return false;
    4704   }
    4705
    4706   final private boolean jj_3R_253() {
    4707     if (jj_scan_token(INCR)) return true;
    4708     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4709     if (jj_3R_63()) return true;
    4710     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4711     return false;
    4712   }
    4713
    4714   final private boolean jj_3R_288() {
    4715     if (jj_scan_token(LE)) return true;
    4716     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4717     return false;
    4718   }
    4719
    4720   final private boolean jj_3_2() {
    4721     if (jj_3R_53()) return true;
    4722     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4723     return false;
    4724   }
    4725
    4726   final private boolean jj_3R_268() {
    4727     Token xsp;
    4728     xsp = jj_scanpos;
    4729     if (jj_3_2()) {
    4730     jj_scanpos = xsp;
    4731     if (jj_3R_273()) {
    4732     jj_scanpos = xsp;
    4733     if (jj_3R_274()) {
    4734     jj_scanpos = xsp;
    4735     if (jj_3R_275()) {
    4736     jj_scanpos = xsp;
    4737     if (jj_3R_276()) {
    4738     jj_scanpos = xsp;
    4739     if (jj_3R_277()) return true;
    4740     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4741     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4742     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4743     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4744     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4745     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4746     return false;
    4747   }
    4748
    4749   final private boolean jj_3R_315() {
    4750     if (jj_scan_token(MINUS)) return true;
    4751     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4752     return false;
    4753   }
    4754
    4755   final private boolean jj_3R_311() {
    4756     if (jj_scan_token(LSHIFT)) return true;
    4757     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4758     return false;
    4759   }
    4760
    4761   final private boolean jj_3R_293() {
    4762     if (jj_3R_316()) return true;
    4763     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4764     return false;
    4765   }
    4766
    4767   final private boolean jj_3R_285() {
    4768     Token xsp;
    4769     xsp = jj_scanpos;
    4770     if (jj_3R_311()) {
    4771     jj_scanpos = xsp;
    4772     if (jj_3R_312()) {
    4773     jj_scanpos = xsp;
    4774     if (jj_3R_313()) return true;
    4775     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4776     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4777     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4778     if (jj_3R_267()) return true;
    4779     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4780     return false;
    4781   }
    4782
    4783   final private boolean jj_3R_287() {
    4784     if (jj_scan_token(GT)) return true;
    4785     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4786     return false;
    4787   }
    4788
    4789   final private boolean jj_3R_292() {
    4790     if (jj_3R_254()) return true;
    4791     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4792     return false;
    4793   }
    4794
    4795   final private boolean jj_3R_314() {
    4796     if (jj_scan_token(PLUS)) return true;
    4797     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4798     return false;
    4799   }
    4800
    4801   final private boolean jj_3R_227() {
    4802     if (jj_scan_token(ORASSIGN)) return true;
    4803     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4804     return false;
    4805   }
    4806
    4807   final private boolean jj_3R_291() {
    4808     if (jj_3R_253()) return true;
    4809     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4810     return false;
    4811   }
    4812
    4813   final private boolean jj_3R_279() {
    4814     Token xsp;
    4815     xsp = jj_scanpos;
    4816     if (jj_3R_290()) {
    4817     jj_scanpos = xsp;
    4818     if (jj_3R_291()) {
    4819     jj_scanpos = xsp;
    4820     if (jj_3R_292()) {
    4821     jj_scanpos = xsp;
    4822     if (jj_3R_293()) return true;
    4823     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4824     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4825     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4826     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4827     return false;
    4828   }
    4829
    4830   final private boolean jj_3R_290() {
    4831     Token xsp;
    4832     xsp = jj_scanpos;
    4833     if (jj_3R_314()) {
    4834     jj_scanpos = xsp;
    4835     if (jj_3R_315()) return true;
    4836     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4837     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4838     if (jj_3R_279()) return true;
    4839     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4840     return false;
    4841   }
    4842
    4843   final private boolean jj_3R_271() {
    4844     if (jj_scan_token(NE)) return true;
    4845     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4846     return false;
    4847   }
    4848
    4849   final private boolean jj_3R_286() {
    4850     if (jj_scan_token(LT)) return true;
    4851     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4852     return false;
    4853   }
    4854
    4855   final private boolean jj_3R_278() {
    4856     Token xsp;
    4857     xsp = jj_scanpos;
    4858     if (jj_3R_286()) {
    4859     jj_scanpos = xsp;
    4860     if (jj_3R_287()) {
    4861     jj_scanpos = xsp;
    4862     if (jj_3R_288()) {
    4863     jj_scanpos = xsp;
    4864     if (jj_3R_289()) return true;
    4865     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4866     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4867     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4868     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4869     if (jj_3R_262()) return true;
    4870     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4871     return false;
    4872   }
    4873
    4874   final private boolean jj_3R_323() {
    4875     if (jj_scan_token(STRICTFP)) return true;
    4876     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4877     return false;
    4878   }
    4879
    4880   final private boolean jj_3R_226() {
    4881     if (jj_scan_token(XORASSIGN)) return true;
    4882     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4883     return false;
    4884   }
    4885
    4886   final private boolean jj_3R_269() {
    4887     if (jj_scan_token(INSTANCEOF)) return true;
    4888     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4889     if (jj_3R_73()) return true;
    4890     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4891     return false;
    4892   }
    4893
    4894   final private boolean jj_3R_272() {
    4895     if (jj_3R_279()) return true;
    4896     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4897     Token xsp;
    4898     while (true) {
    4899       xsp = jj_scanpos;
    4900       if (jj_3R_363()) { jj_scanpos = xsp; break; }
    4901       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4902     }
    4903     return false;
    4904   }
    4905
    4906   final private boolean jj_3R_322() {
    4907     if (jj_scan_token(PRIVATE)) return true;
    4908     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4909     return false;
    4910   }
    4911
    4912   final private boolean jj_3R_270() {
    4913     if (jj_scan_token(EQ)) return true;
    4914     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4915     return false;
    4916   }
    4917
    4918   final private boolean jj_3R_266() {
    4919     Token xsp;
    4920     xsp = jj_scanpos;
    4921     if (jj_3R_270()) {
    4922     jj_scanpos = xsp;
    4923     if (jj_3R_271()) return true;
    4924     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4925     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4926     if (jj_3R_252()) return true;
    4927     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4928     return false;
    4929   }
    4930
    4931   final private boolean jj_3R_225() {
    4932     if (jj_scan_token(ANDASSIGN)) return true;
    4933     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4934     return false;
    4935   }
    4936
    4937   final private boolean jj_3R_267() {
    4938     if (jj_3R_272()) return true;
    4939     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4940     Token xsp;
    4941     while (true) {
    4942       xsp = jj_scanpos;
    4943       if (jj_3R_310()) { jj_scanpos = xsp; break; }
    4944       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4945     }
    4946     return false;
    4947   }
    4948
    4949   final private boolean jj_3R_321() {
    4950     if (jj_scan_token(PROTECTED)) return true;
    4951     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4952     return false;
    4953   }
    4954
    4955   final private boolean jj_3R_320() {
    4956     if (jj_scan_token(PUBLIC)) return true;
    4957     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4958     return false;
    4959   }
    4960
    4961   final private boolean jj_3R_262() {
    4962     if (jj_3R_267()) return true;
    4963     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4964     Token xsp;
    4965     while (true) {
    4966       xsp = jj_scanpos;
    4967       if (jj_3R_285()) { jj_scanpos = xsp; break; }
    4968       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4969     }
    4970     return false;
    4971   }
    4972
    4973   final private boolean jj_3R_261() {
    4974     if (jj_scan_token(BIT_AND)) return true;
    4975     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4976     if (jj_3R_244()) return true;
    4977     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4978     return false;
    4979   }
    4980
    4981   final private boolean jj_3R_319() {
    4982     if (jj_scan_token(FINAL)) return true;
    4983     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4984     return false;
    4985   }
    4986
    4987   final private boolean jj_3R_224() {
    4988     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
    4989     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4990     return false;
    4991   }
    4992
    4993   final private boolean jj_3R_258() {
    4994     if (jj_3R_262()) return true;
    4995     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    4996     Token xsp;
    4997     while (true) {
    4998       xsp = jj_scanpos;
    4999       if (jj_3R_278()) { jj_scanpos = xsp; break; }
    5000       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5001     }
    5002     return false;
    5003   }
    5004
    5005   final private boolean jj_3R_318() {
    5006     if (jj_scan_token(ABSTRACT)) return true;
    5007     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5008     return false;
    5009   }
    5010
    5011   final private boolean jj_3R_251() {
    5012     if (jj_scan_token(BIT_OR)) return true;
    5013     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5014     if (jj_3R_196()) return true;
    5015     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5016     return false;
    5017   }
    5018
    5019   final private boolean jj_3R_317() {
    5020     if (jj_scan_token(STATIC)) return true;
    5021     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5022     return false;
    5023   }
    5024
    5025   final private boolean jj_3R_294() {
    5026     Token xsp;
    5027     xsp = jj_scanpos;
    5028     if (jj_3R_317()) {
    5029     jj_scanpos = xsp;
    5030     if (jj_3R_318()) {
    5031     jj_scanpos = xsp;
    5032     if (jj_3R_319()) {
    5033     jj_scanpos = xsp;
    5034     if (jj_3R_320()) {
    5035     jj_scanpos = xsp;
    5036     if (jj_3R_321()) {
    5037     jj_scanpos = xsp;
    5038     if (jj_3R_322()) {
    5039     jj_scanpos = xsp;
    5040     if (jj_3R_323()) return true;
    5041     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5042     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5043     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5044     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5045     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5046     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5047     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5048     return false;
    5049   }
    5050
    5051   final private boolean jj_3R_223() {
    5052     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
    5053     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5054     return false;
    5055   }
    5056
    5057   final private boolean jj_3R_252() {
    5058     if (jj_3R_258()) return true;
    5059     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5060     Token xsp;
    5061     xsp = jj_scanpos;
    5062     if (jj_3R_269()) jj_scanpos = xsp;
    5063     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5064     return false;
    5065   }
    5066
    5067   final private boolean jj_3R_257() {
    5068     if (jj_scan_token(XOR)) return true;
    5069     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5070     if (jj_3R_228()) return true;
    5071     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5072     return false;
    5073   }
    5074
    5075   final private boolean jj_3R_280() {
    5076     Token xsp;
    5077     while (true) {
    5078       xsp = jj_scanpos;
    5079       if (jj_3R_294()) { jj_scanpos = xsp; break; }
    5080       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5081     }
    5082     if (jj_3R_190()) return true;
    5083     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5084     return false;
    5085   }
    5086
    5087   final private boolean jj_3R_243() {
    5088     if (jj_scan_token(SC_AND)) return true;
    5089     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5090     if (jj_3R_187()) return true;
    5091     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5092     return false;
    5093   }
    5094
    5095   final private boolean jj_3R_265() {
    5096     if (jj_3R_268()) return true;
    5097     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5098     return false;
    5099   }
    5100
    5101   final private boolean jj_3R_244() {
    5102     if (jj_3R_252()) return true;
    5103     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5104     Token xsp;
    5105     while (true) {
    5106       xsp = jj_scanpos;
    5107       if (jj_3R_266()) { jj_scanpos = xsp; break; }
    5108       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5109     }
    5110     return false;
    5111   }
    5112
    5113   final private boolean jj_3R_215() {
    5114     if (jj_scan_token(SC_OR)) return true;
    5115     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5116     if (jj_3R_175()) return true;
    5117     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5118     return false;
    5119   }
    5120
    5121   final private boolean jj_3R_222() {
    5122     if (jj_scan_token(LSHIFTASSIGN)) return true;
    5123     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5124     return false;
    5125   }
    5126
    5127   final private boolean jj_3R_260() {
    5128     if (jj_scan_token(LBRACE)) return true;
    5129     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5130     Token xsp;
    5131     while (true) {
    5132       xsp = jj_scanpos;
    5133       if (jj_3R_265()) { jj_scanpos = xsp; break; }
    5134       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5135     }
    5136     if (jj_scan_token(RBRACE)) return true;
    5137     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5138     return false;
    5139   }
    5140
    5141   final private boolean jj_3R_228() {
    5142     if (jj_3R_244()) return true;
    5143     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5144     Token xsp;
    5145     while (true) {
    5146       xsp = jj_scanpos;
    5147       if (jj_3R_261()) { jj_scanpos = xsp; break; }
    5148       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5149     }
    5150     return false;
    5151   }
    5152
    5153   final private boolean jj_3R_194() {
    5154     if (jj_scan_token(HOOK)) return true;
    5155     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5156     if (jj_3R_70()) return true;
    5157     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5158     if (jj_scan_token(COLON)) return true;
    5159     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5160     if (jj_3R_136()) return true;
    5161     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5162     return false;
    5163   }
    5164
    5165   final private boolean jj_3R_221() {
    5166     if (jj_scan_token(MINUSASSIGN)) return true;
    5167     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5168     return false;
    5169   }
    5170
    5171   final private boolean jj_3R_196() {
    5172     if (jj_3R_228()) return true;
    5173     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5174     Token xsp;
    5175     while (true) {
    5176       xsp = jj_scanpos;
    5177       if (jj_3R_257()) { jj_scanpos = xsp; break; }
    5178       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5179     }
    5180     return false;
    5181   }
    5182
    5183   final private boolean jj_3R_220() {
    5184     if (jj_scan_token(PLUSASSIGN)) return true;
    5185     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5186     return false;
    5187   }
    5188
    5189   final private boolean jj_3R_325() {
    5190     if (jj_scan_token(IMPLEMENTS)) return true;
    5191     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5192     if (jj_3R_369()) return true;
    5193     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5194     return false;
    5195   }
    5196
    5197   final private boolean jj_3R_324() {
    5198     if (jj_scan_token(EXTENDS)) return true;
    5199     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5200     if (jj_3R_57()) return true;
    5201     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5202     return false;
    5203   }
    5204
    5205   final private boolean jj_3R_187() {
    5206     if (jj_3R_196()) return true;
    5207     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5208     Token xsp;
    5209     while (true) {
    5210       xsp = jj_scanpos;
    5211       if (jj_3R_251()) { jj_scanpos = xsp; break; }
    5212       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5213     }
    5214     return false;
    5215   }
    5216
    5217   final private boolean jj_3R_219() {
    5218     if (jj_scan_token(REMASSIGN)) return true;
    5219     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5220     return false;
    5221   }
    5222
    5223   final private boolean jj_3R_175() {
    5224     if (jj_3R_187()) return true;
    5225     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5226     Token xsp;
    5227     while (true) {
    5228       xsp = jj_scanpos;
    5229       if (jj_3R_243()) { jj_scanpos = xsp; break; }
    5230       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5231     }
    5232     return false;
    5233   }
    5234
    5235   final private boolean jj_3R_218() {
    5236     if (jj_scan_token(SLASHASSIGN)) return true;
    5237     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5238     return false;
    5239   }
    5240
    5241   final private boolean jj_3R_168() {
    5242     if (jj_3R_175()) return true;
    5243     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5244     Token xsp;
    5245     while (true) {
    5246       xsp = jj_scanpos;
    5247       if (jj_3R_215()) { jj_scanpos = xsp; break; }
    5248       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5249     }
    5250     return false;
    5251   }
    5252
    5253   final private boolean jj_3R_136() {
    5254     if (jj_3R_168()) return true;
    5255     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5256     Token xsp;
    5257     xsp = jj_scanpos;
    5258     if (jj_3R_194()) jj_scanpos = xsp;
    5259     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5260     return false;
    5261   }
    5262
    5263   final private boolean jj_3R_217() {
    5264     if (jj_scan_token(STARASSIGN)) return true;
    5265     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5266     return false;
    5267   }
    5268
    5269   final private boolean jj_3R_190() {
    5270     if (jj_scan_token(CLASS)) return true;
    5271     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5272     if (jj_scan_token(IDENTIFIER)) return true;
    5273     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5274     Token xsp;
    5275     xsp = jj_scanpos;
    5276     if (jj_3R_324()) jj_scanpos = xsp;
    5277     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5278     xsp = jj_scanpos;
    5279     if (jj_3R_325()) jj_scanpos = xsp;
    5280     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5281     if (jj_3R_260()) return true;
    5282     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5283     return false;
    5284   }
    5285
    5286   final private boolean jj_3R_195() {
    5287     Token xsp;
    5288     xsp = jj_scanpos;
    5289     if (jj_3R_216()) {
    5290     jj_scanpos = xsp;
    5291     if (jj_3R_217()) {
    5292     jj_scanpos = xsp;
    5293     if (jj_3R_218()) {
    5294     jj_scanpos = xsp;
    5295     if (jj_3R_219()) {
    5296     jj_scanpos = xsp;
    5297     if (jj_3R_220()) {
    5298     jj_scanpos = xsp;
    5299     if (jj_3R_221()) {
    5300     jj_scanpos = xsp;
    5301     if (jj_3R_222()) {
    5302     jj_scanpos = xsp;
    5303     if (jj_3R_223()) {
    5304     jj_scanpos = xsp;
    5305     if (jj_3R_224()) {
    5306     jj_scanpos = xsp;
    5307     if (jj_3R_225()) {
    5308     jj_scanpos = xsp;
    5309     if (jj_3R_226()) {
    5310     jj_scanpos = xsp;
    5311     if (jj_3R_227()) return true;
    5312     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5313     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5314     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5315     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5316     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5317     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5318     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5319     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5320     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5321     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5322     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5323     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5324     return false;
    5325   }
    5326
    5327   final private boolean jj_3R_216() {
    5328     if (jj_scan_token(ASSIGN)) return true;
    5329     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5330     return false;
    5331   }
    5332
    5333   final private boolean jj_3R_186() {
    5334     if (jj_3R_195()) return true;
    5335     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5336     if (jj_3R_70()) return true;
    5337     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5338     return false;
    5339   }
    5340
    5341   final private boolean jj_3R_70() {
    5342     if (jj_3R_136()) return true;
    5343     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5344     Token xsp;
    5345     xsp = jj_scanpos;
    5346     if (jj_3R_186()) jj_scanpos = xsp;
    5347     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5348     return false;
    5349   }
    5350
    5351   final private boolean jj_3R_79() {
    5352     if (jj_scan_token(STRICTFP)) return true;
    5353     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5354     return false;
    5355   }
    5356
    5357   final private boolean jj_3R_386() {
    5358     if (jj_scan_token(COMMA)) return true;
    5359     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5360     if (jj_3R_385()) return true;
    5361     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5362     return false;
    5363   }
    5364
    5365   final private boolean jj_3R_78() {
    5366     if (jj_scan_token(PUBLIC)) return true;
    5367     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5368     return false;
    5369   }
    5370
    5371   final private boolean jj_3R_369() {
    5372     if (jj_3R_385()) return true;
    5373     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5374     Token xsp;
    5375     while (true) {
    5376       xsp = jj_scanpos;
    5377       if (jj_3R_386()) { jj_scanpos = xsp; break; }
    5378       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5379     }
    5380     return false;
    5381   }
    5382
    5383   final private boolean jj_3R_374() {
    5384     if (jj_scan_token(COMMA)) return true;
    5385     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5386     if (jj_3R_373()) return true;
    5387     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5388     return false;
    5389   }
    5390
    5391   final private boolean jj_3R_339() {
    5392     if (jj_3R_373()) return true;
    5393     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5394     Token xsp;
    5395     while (true) {
    5396       xsp = jj_scanpos;
    5397       if (jj_3R_374()) { jj_scanpos = xsp; break; }
    5398       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5399     }
    5400     return false;
    5401   }
    5402
    5403   final private boolean jj_3R_77() {
    5404     if (jj_scan_token(FINAL)) return true;
    5405     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5406     return false;
    5407   }
    5408
    5409   final private boolean jj_3R_52() {
    5410     Token xsp;
    5411     xsp = jj_scanpos;
    5412     if (jj_3R_76()) {
    5413     jj_scanpos = xsp;
    5414     if (jj_3R_77()) {
    5415     jj_scanpos = xsp;
    5416     if (jj_3R_78()) {
    5417     jj_scanpos = xsp;
    5418     if (jj_3R_79()) return true;
    5419     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5420     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5421     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5422     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5423     return false;
    5424   }
    5425
    5426   final private boolean jj_3R_76() {
    5427     if (jj_scan_token(ABSTRACT)) return true;
    5428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5429     return false;
    5430   }
    5431
    5432   final private boolean jj_3_1() {
    5433     Token xsp;
    5434     while (true) {
    5435       xsp = jj_scanpos;
    5436       if (jj_3R_52()) { jj_scanpos = xsp; break; }
    5437       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5438     }
    5439     if (jj_scan_token(CLASS)) return true;
    5440     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5441     return false;
    5442   }
    5443
    5444   final private boolean jj_3R_398() {
    5445     if (jj_scan_token(DOT)) return true;
    5446     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5447     if (jj_scan_token(IDENTIFIER)) return true;
    5448     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5449     return false;
    5450   }
    5451
    5452   final private boolean jj_3R_385() {
    5453     if (jj_scan_token(IDENTIFIER)) return true;
    5454     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5455     Token xsp;
    5456     while (true) {
    5457       xsp = jj_scanpos;
    5458       if (jj_3R_398()) { jj_scanpos = xsp; break; }
    5459       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5460     }
    5461     return false;
    5462   }
    5463
    5464   final private boolean jj_3R_394() {
    5465     if (jj_scan_token(DOT)) return true;
    5466     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5467     if (jj_scan_token(IDENTIFIER)) return true;
    5468     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5469     return false;
    5470   }
    5471
    5472   final private boolean jj_3R_373() {
    5473     if (jj_scan_token(IDENTIFIER)) return true;
    5474     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5475     Token xsp;
    5476     while (true) {
    5477       xsp = jj_scanpos;
    5478       if (jj_3R_394()) { jj_scanpos = xsp; break; }
    5479       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5480     }
    5481     return false;
    5482   }
    5483
    5484   final private boolean jj_3_14() {
    5485     if (jj_scan_token(DOT)) return true;
    5486     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5487     if (jj_scan_token(IDENTIFIER)) return true;
    5488     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5489     return false;
    5490   }
    5491
    5492   final private boolean jj_3R_57() {
    5493     if (jj_scan_token(IDENTIFIER)) return true;
    5494     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5495     Token xsp;
    5496     while (true) {
    5497       xsp = jj_scanpos;
    5498       if (jj_3_14()) { jj_scanpos = xsp; break; }
    5499       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5500     }
    5501     return false;
    5502   }
    5503
    5504   final private boolean jj_3R_134() {
    5505     if (jj_3R_167()) return true;
    5506     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5507     return false;
    5508   }
    5509
    5510   final private boolean jj_3R_133() {
    5511     if (jj_scan_token(VOID)) return true;
    5512     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5513     return false;
    5514   }
    5515
    5516   final private boolean jj_3R_68() {
    5517     Token xsp;
    5518     xsp = jj_scanpos;
    5519     if (jj_3R_133()) {
    5520     jj_scanpos = xsp;
    5521     if (jj_3R_134()) return true;
    5522     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5523     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5524     return false;
    5525   }
    5526
    5527   final private boolean jj_3R_129() {
    5528     if (jj_scan_token(DOUBLE)) return true;
    5529     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5530     return false;
    5531   }
    5532
    5533   final private boolean jj_3R_128() {
    5534     if (jj_scan_token(FLOAT)) return true;
    5535     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5536     return false;
    5537   }
    5538
    5539   final private boolean jj_3R_138() {
    5540     if (jj_3R_57()) return true;
    5541     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5542     return false;
    5543   }
    5544
    5545   final private boolean jj_3R_127() {
    5546     if (jj_scan_token(LONG)) return true;
    5547     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5548     return false;
    5549   }
    5550
    5551   final private boolean jj_3R_126() {
    5552     if (jj_scan_token(INT)) return true;
    5553     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5554     return false;
    5555   }
    5556
    5557   final private boolean jj_3R_125() {
    5558     if (jj_scan_token(SHORT)) return true;
    5559     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5560     return false;
    5561   }
    5562
    5563   final private boolean jj_3R_124() {
    5564     if (jj_scan_token(BYTE)) return true;
    5565     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5566     return false;
    5567   }
    5568
    5569   final private boolean jj_3R_123() {
    5570     if (jj_scan_token(CHAR)) return true;
    5571     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5572     return false;
    5573   }
    5574
    5575   final private boolean jj_3R_122() {
    5576     if (jj_scan_token(BOOLEAN)) return true;
    5577     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5578     return false;
    5579   }
    5580
    5581   final private boolean jj_3R_66() {
    5582     Token xsp;
    5583     xsp = jj_scanpos;
    5584     if (jj_3R_122()) {
    5585     jj_scanpos = xsp;
    5586     if (jj_3R_123()) {
    5587     jj_scanpos = xsp;
    5588     if (jj_3R_124()) {
    5589     jj_scanpos = xsp;
    5590     if (jj_3R_125()) {
    5591     jj_scanpos = xsp;
    5592     if (jj_3R_126()) {
    5593     jj_scanpos = xsp;
    5594     if (jj_3R_127()) {
    5595     jj_scanpos = xsp;
    5596     if (jj_3R_128()) {
    5597     jj_scanpos = xsp;
    5598     if (jj_3R_129()) return true;
    5599     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5600     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5601     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5602     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5603     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5604     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5605     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5606     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5607     return false;
    5608   }
    5609
    5610   final private boolean jj_3R_139() {
    5611     if (jj_scan_token(LBRACKET)) return true;
    5612     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5613     if (jj_scan_token(RBRACKET)) return true;
    5614     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5615     return false;
    5616   }
    5617
    5618   final private boolean jj_3R_137() {
    5619     if (jj_3R_66()) return true;
    5620     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5621     return false;
    5622   }
    5623
    5624   final private boolean jj_3R_73() {
    5625     Token xsp;
    5626     xsp = jj_scanpos;
    5627     if (jj_3R_137()) {
    5628     jj_scanpos = xsp;
    5629     if (jj_3R_138()) return true;
    5630     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5631     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5632     while (true) {
    5633       xsp = jj_scanpos;
    5634       if (jj_3R_139()) { jj_scanpos = xsp; break; }
    5635       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5636     }
    5637     return false;
    5638   }
    5639
    5640   final private boolean jj_3R_401() {
    5641     if (jj_scan_token(LBRACKET)) return true;
    5642     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5643     if (jj_scan_token(RBRACKET)) return true;
    5644     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5645     return false;
    5646   }
    5647
    5648   final private boolean jj_3R_400() {
    5649     if (jj_3R_57()) return true;
    5650     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5651     return false;
    5652   }
    5653
    5654   final private boolean jj_3R_399() {
    5655     if (jj_3R_66()) return true;
    5656     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5657     return false;
    5658   }
    5659
    5660   final private boolean jj_3R_392() {
    5661     Token xsp;
    5662     xsp = jj_scanpos;
    5663     if (jj_3R_399()) {
    5664     jj_scanpos = xsp;
    5665     if (jj_3R_400()) return true;
    5666     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5667     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5668     while (true) {
    5669       xsp = jj_scanpos;
    5670       if (jj_3R_401()) { jj_scanpos = xsp; break; }
    5671       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5672     }
    5673     return false;
    5674   }
    5675
    5676   final private boolean jj_3R_174() {
    5677     if (jj_scan_token(LBRACKET)) return true;
    5678     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5679     if (jj_scan_token(RBRACKET)) return true;
    5680     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5681     return false;
    5682   }
    5683
    5684   final private boolean jj_3R_173() {
    5685     if (jj_3R_57()) return true;
    5686     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5687     return false;
    5688   }
    5689
    5690   final private boolean jj_3R_172() {
    5691     if (jj_3R_66()) return true;
    5692     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5693     return false;
    5694   }
    5695
    5696   final private boolean jj_3R_167() {
    5697     Token xsp;
    5698     xsp = jj_scanpos;
    5699     if (jj_3R_172()) {
    5700     jj_scanpos = xsp;
    5701     if (jj_3R_173()) return true;
    5702     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5703     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5704     while (true) {
    5705       xsp = jj_scanpos;
    5706       if (jj_3R_174()) { jj_scanpos = xsp; break; }
    5707       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5708     }
    5709     return false;
    5710   }
    5711
    5712   final private boolean jj_3R_422() {
    5713     if (jj_scan_token(COLON)) return true;
    5714     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5715     if (jj_3R_70()) return true;
    5716     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5717     return false;
    5718   }
    5719
    5720   final private boolean jj_3R_360() {
    5721     if (jj_scan_token(LBRACKET)) return true;
    5722     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5723     if (jj_scan_token(RBRACKET)) return true;
    5724     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5725     return false;
    5726   }
    5727
    5728   final private boolean jj_3R_359() {
    5729     if (jj_3R_57()) return true;
    5730     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5731     return false;
    5732   }
    5733
    5734   final private boolean jj_3R_298() {
    5735     if (jj_scan_token(THROWS)) return true;
    5736     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5737     if (jj_3R_339()) return true;
    5738     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5739     return false;
    5740   }
    5741
    5742   final private boolean jj_3R_242() {
    5743     if (jj_scan_token(ASSERT)) return true;
    5744     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5745     if (jj_3R_70()) return true;
    5746     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5747     Token xsp;
    5748     xsp = jj_scanpos;
    5749     if (jj_3R_422()) jj_scanpos = xsp;
    5750     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5751     if (jj_scan_token(SEMICOLON)) return true;
    5752     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5753     return false;
    5754   }
    5755
    5756   final private boolean jj_3R_358() {
    5757     if (jj_3R_66()) return true;
    5758     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5759     return false;
    5760   }
    5761
    5762   final private boolean jj_3R_307() {
    5763     Token xsp;
    5764     xsp = jj_scanpos;
    5765     if (jj_3R_358()) {
    5766     jj_scanpos = xsp;
    5767     if (jj_3R_359()) return true;
    5768     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5769     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5770     while (true) {
    5771       xsp = jj_scanpos;
    5772       if (jj_3R_360()) { jj_scanpos = xsp; break; }
    5773       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5774     }
    5775     return false;
    5776   }
    5777
    5778   final private boolean jj_3R_421() {
    5779     if (jj_scan_token(FINALLY)) return true;
    5780     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5781     if (jj_3R_81()) return true;
    5782     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5783     return false;
    5784   }
    5785
    5786   final private boolean jj_3R_420() {
    5787     if (jj_scan_token(CATCH)) return true;
    5788     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5789     if (jj_scan_token(LPAREN)) return true;
    5790     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5791     if (jj_3R_371()) return true;
    5792     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5793     if (jj_scan_token(RPAREN)) return true;
    5794     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5795     if (jj_3R_81()) return true;
    5796     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5797     return false;
    5798   }
    5799
    5800   final private boolean jj_3R_241() {
    5801     if (jj_scan_token(TRY)) return true;
    5802     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5803     if (jj_3R_81()) return true;
    5804     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5805     Token xsp;
    5806     while (true) {
    5807       xsp = jj_scanpos;
    5808       if (jj_3R_420()) { jj_scanpos = xsp; break; }
    5809       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5810     }
    5811     xsp = jj_scanpos;
    5812     if (jj_3R_421()) jj_scanpos = xsp;
    5813     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5814     return false;
    5815   }
    5816
    5817   final private boolean jj_3R_80() {
    5818     if (jj_scan_token(STATIC)) return true;
    5819     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5820     return false;
    5821   }
    5822
    5823   final private boolean jj_3_13() {
    5824     if (jj_scan_token(THIS)) return true;
    5825     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5826     if (jj_3R_64()) return true;
    5827     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5828     if (jj_scan_token(SEMICOLON)) return true;
    5829     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5830     return false;
    5831   }
    5832
    5833   final private boolean jj_3R_53() {
    5834     Token xsp;
    5835     xsp = jj_scanpos;
    5836     if (jj_3R_80()) jj_scanpos = xsp;
    5837     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5838     if (jj_3R_81()) return true;
    5839     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5840     return false;
    5841   }
    5842
    5843   final private boolean jj_3R_416() {
    5844     if (jj_3R_428()) return true;
    5845     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5846     return false;
    5847   }
    5848
    5849   final private boolean jj_3R_240() {
    5850     if (jj_scan_token(SYNCHRONIZED)) return true;
    5851     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5852     if (jj_scan_token(LPAREN)) return true;
    5853     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5854     if (jj_3R_70()) return true;
    5855     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5856     if (jj_scan_token(RPAREN)) return true;
    5857     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5858     if (jj_3R_81()) return true;
    5859     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5860     return false;
    5861   }
    5862
    5863   final private boolean jj_3R_419() {
    5864     if (jj_3R_70()) return true;
    5865     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5866     return false;
    5867   }
    5868
    5869   final private boolean jj_3_12() {
    5870     if (jj_3R_63()) return true;
    5871     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5872     if (jj_scan_token(DOT)) return true;
    5873     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5874     return false;
    5875   }
    5876
    5877   final private boolean jj_3R_418() {
    5878     if (jj_scan_token(IDENTIFIER)) return true;
    5879     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5880     return false;
    5881   }
    5882
    5883   final private boolean jj_3R_117() {
    5884     Token xsp;
    5885     xsp = jj_scanpos;
    5886     if (jj_3_12()) jj_scanpos = xsp;
    5887     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5888     if (jj_scan_token(SUPER)) return true;
    5889     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5890     if (jj_3R_64()) return true;
    5891     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5892     if (jj_scan_token(SEMICOLON)) return true;
    5893     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5894     return false;
    5895   }
    5896
    5897   final private boolean jj_3R_239() {
    5898     if (jj_scan_token(THROW)) return true;
    5899     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5900     if (jj_3R_70()) return true;
    5901     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5902     if (jj_scan_token(SEMICOLON)) return true;
    5903     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5904     return false;
    5905   }
    5906
    5907   final private boolean jj_3_11() {
    5908     if (jj_3R_62()) return true;
    5909     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5910     return false;
    5911   }
    5912
    5913   final private boolean jj_3R_116() {
    5914     if (jj_scan_token(THIS)) return true;
    5915     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5916     if (jj_3R_64()) return true;
    5917     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5918     if (jj_scan_token(SEMICOLON)) return true;
    5919     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5920     return false;
    5921   }
    5922
    5923   final private boolean jj_3R_62() {
    5924     Token xsp;
    5925     xsp = jj_scanpos;
    5926     if (jj_3R_116()) {
    5927     jj_scanpos = xsp;
    5928     if (jj_3R_117()) return true;
    5929     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5930     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5931     return false;
    5932   }
    5933
    5934   final private boolean jj_3R_439() {
    5935     if (jj_scan_token(COMMA)) return true;
    5936     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5937     if (jj_3R_230()) return true;
    5938     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5939     return false;
    5940   }
    5941
    5942   final private boolean jj_3R_238() {
    5943     if (jj_scan_token(RETURN)) return true;
    5944     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5945     Token xsp;
    5946     xsp = jj_scanpos;
    5947     if (jj_3R_419()) jj_scanpos = xsp;
    5948     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5949     if (jj_scan_token(SEMICOLON)) return true;
    5950     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5951     return false;
    5952   }
    5953
    5954   final private boolean jj_3R_417() {
    5955     if (jj_scan_token(IDENTIFIER)) return true;
    5956     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5957     return false;
    5958   }
    5959
    5960   final private boolean jj_3R_300() {
    5961     if (jj_3R_169()) return true;
    5962     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5963     return false;
    5964   }
    5965
    5966   final private boolean jj_3R_299() {
    5967     if (jj_3R_62()) return true;
    5968     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5969     return false;
    5970   }
    5971
    5972   final private boolean jj_3R_237() {
    5973     if (jj_scan_token(CONTINUE)) return true;
    5974     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5975     Token xsp;
    5976     xsp = jj_scanpos;
    5977     if (jj_3R_418()) jj_scanpos = xsp;
    5978     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5979     if (jj_scan_token(SEMICOLON)) return true;
    5980     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5981     return false;
    5982   }
    5983
    5984   final private boolean jj_3R_415() {
    5985     if (jj_3R_70()) return true;
    5986     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5987     return false;
    5988   }
    5989
    5990   final private boolean jj_3R_236() {
    5991     if (jj_scan_token(BREAK)) return true;
    5992     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5993     Token xsp;
    5994     xsp = jj_scanpos;
    5995     if (jj_3R_417()) jj_scanpos = xsp;
    5996     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5997     if (jj_scan_token(SEMICOLON)) return true;
    5998     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    5999     return false;
    6000   }
    6001
    6002   final private boolean jj_3R_337() {
    6003     if (jj_scan_token(PRIVATE)) return true;
    6004     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6005     return false;
    6006   }
    6007
    6008   final private boolean jj_3R_413() {
    6009     if (jj_scan_token(ELSE)) return true;
    6010     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6011     if (jj_3R_189()) return true;
    6012     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6013     return false;
    6014   }
    6015
    6016   final private boolean jj_3R_428() {
    6017     if (jj_3R_438()) return true;
    6018     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6019     return false;
    6020   }
    6021
    6022   final private boolean jj_3R_336() {
    6023     if (jj_scan_token(PROTECTED)) return true;
    6024     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6025     return false;
    6026   }
    6027
    6028   final private boolean jj_3R_372() {
    6029     if (jj_scan_token(COMMA)) return true;
    6030     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6031     if (jj_3R_371()) return true;
    6032     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6033     return false;
    6034   }
    6035
    6036   final private boolean jj_3R_75() {
    6037     if (jj_scan_token(FINAL)) return true;
    6038     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6039     return false;
    6040   }
    6041
    6042   final private boolean jj_3_31() {
    6043     Token xsp;
    6044     xsp = jj_scanpos;
    6045     if (jj_3R_75()) jj_scanpos = xsp;
    6046     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6047     if (jj_3R_73()) return true;
    6048     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6049     if (jj_scan_token(IDENTIFIER)) return true;
    6050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6051     return false;
    6052   }
    6053
    6054   final private boolean jj_3R_438() {
    6055     if (jj_3R_230()) return true;
    6056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6057     Token xsp;
    6058     while (true) {
    6059       xsp = jj_scanpos;
    6060       if (jj_3R_439()) { jj_scanpos = xsp; break; }
    6061       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6062     }
    6063     return false;
    6064   }
    6065
    6066   final private boolean jj_3R_335() {
    6067     if (jj_scan_token(PUBLIC)) return true;
    6068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6069     return false;
    6070   }
    6071
    6072   final private boolean jj_3R_296() {
    6073     Token xsp;
    6074     xsp = jj_scanpos;
    6075     if (jj_3R_335()) {
    6076     jj_scanpos = xsp;
    6077     if (jj_3R_336()) {
    6078     jj_scanpos = xsp;
    6079     if (jj_3R_337()) return true;
    6080     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6081     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6082     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6083     return false;
    6084   }
    6085
    6086   final private boolean jj_3R_282() {
    6087     Token xsp;
    6088     xsp = jj_scanpos;
    6089     if (jj_3R_296()) jj_scanpos = xsp;
    6090     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6091     if (jj_scan_token(IDENTIFIER)) return true;
    6092     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6093     if (jj_3R_297()) return true;
    6094     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6095     xsp = jj_scanpos;
    6096     if (jj_3R_298()) jj_scanpos = xsp;
    6097     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6098     if (jj_scan_token(LBRACE)) return true;
    6099     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6100     xsp = jj_scanpos;
    6101     if (jj_3R_299()) jj_scanpos = xsp;
    6102     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6103     while (true) {
    6104       xsp = jj_scanpos;
    6105       if (jj_3R_300()) { jj_scanpos = xsp; break; }
    6106       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6107     }
    6108     if (jj_scan_token(RBRACE)) return true;
    6109     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6110     return false;
    6111   }
    6112
    6113   final private boolean jj_3R_414() {
    6114     if (jj_3R_427()) return true;
    6115     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6116     return false;
    6117   }
    6118
    6119   final private boolean jj_3R_349() {
    6120     if (jj_scan_token(LBRACKET)) return true;
    6121     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6122     if (jj_scan_token(RBRACKET)) return true;
    6123     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6124     return false;
    6125   }
    6126
    6127   final private boolean jj_3R_437() {
    6128     if (jj_3R_438()) return true;
    6129     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6130     return false;
    6131   }
    6132
    6133   final private boolean jj_3R_436() {
    6134     if (jj_3R_188()) return true;
    6135     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6136     return false;
    6137   }
    6138
    6139   final private boolean jj_3R_427() {
    6140     Token xsp;
    6141     xsp = jj_scanpos;
    6142     if (jj_3R_436()) {
    6143     jj_scanpos = xsp;
    6144     if (jj_3R_437()) return true;
    6145     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6146     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6147     return false;
    6148   }
    6149
    6150   final private boolean jj_3R_391() {
    6151     if (jj_scan_token(FINAL)) return true;
    6152     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6153     return false;
    6154   }
    6155
    6156   final private boolean jj_3R_235() {
    6157     if (jj_scan_token(FOR)) return true;
    6158     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6159     if (jj_scan_token(LPAREN)) return true;
    6160     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6161     Token xsp;
    6162     xsp = jj_scanpos;
    6163     if (jj_3R_414()) jj_scanpos = xsp;
    6164     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6165     if (jj_scan_token(SEMICOLON)) return true;
    6166     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6167     xsp = jj_scanpos;
    6168     if (jj_3R_415()) jj_scanpos = xsp;
    6169     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6170     if (jj_scan_token(SEMICOLON)) return true;
    6171     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6172     xsp = jj_scanpos;
    6173     if (jj_3R_416()) jj_scanpos = xsp;
    6174     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6175     if (jj_scan_token(RPAREN)) return true;
    6176     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6177     if (jj_3R_189()) return true;
    6178     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6179     return false;
    6180   }
    6181
    6182   final private boolean jj_3R_371() {
    6183     Token xsp;
    6184     xsp = jj_scanpos;
    6185     if (jj_3R_391()) jj_scanpos = xsp;
    6186     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6187     if (jj_3R_392()) return true;
    6188     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6189     if (jj_3R_393()) return true;
    6190     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6191     return false;
    6192   }
    6193
    6194   final private boolean jj_3R_338() {
    6195     if (jj_3R_371()) return true;
    6196     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6197     Token xsp;
    6198     while (true) {
    6199       xsp = jj_scanpos;
    6200       if (jj_3R_372()) { jj_scanpos = xsp; break; }
    6201       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6202     }
    6203     return false;
    6204   }
    6205
    6206   final private boolean jj_3R_234() {
    6207     if (jj_scan_token(DO)) return true;
    6208     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6209     if (jj_3R_189()) return true;
    6210     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6211     if (jj_scan_token(WHILE)) return true;
    6212     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6213     if (jj_scan_token(LPAREN)) return true;
    6214     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6215     if (jj_3R_70()) return true;
    6216     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6217     if (jj_scan_token(RPAREN)) return true;
    6218     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6219     if (jj_scan_token(SEMICOLON)) return true;
    6220     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6221     return false;
    6222   }
    6223
    6224   final private boolean jj_3R_297() {
    6225     if (jj_scan_token(LPAREN)) return true;
    6226     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6227     Token xsp;
    6228     xsp = jj_scanpos;
    6229     if (jj_3R_338()) jj_scanpos = xsp;
    6230     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6231     if (jj_scan_token(RPAREN)) return true;
    6232     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6233     return false;
    6234   }
    6235
    6236   final private boolean jj_3R_233() {
    6237     if (jj_scan_token(WHILE)) return true;
    6238     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6239     if (jj_scan_token(LPAREN)) return true;
    6240     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6241     if (jj_3R_70()) return true;
    6242     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6243     if (jj_scan_token(RPAREN)) return true;
    6244     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6245     if (jj_3R_189()) return true;
    6246     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6247     return false;
    6248   }
    6249
    6250   final private boolean jj_3R_426() {
    6251     if (jj_3R_169()) return true;
    6252     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6253     return false;
    6254   }
    6255
    6256   final private boolean jj_3R_232() {
    6257     if (jj_scan_token(IF)) return true;
    6258     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6259     if (jj_scan_token(LPAREN)) return true;
    6260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6261     if (jj_3R_70()) return true;
    6262     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6263     if (jj_scan_token(RPAREN)) return true;
    6264     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6265     if (jj_3R_189()) return true;
    6266     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6267     Token xsp;
    6268     xsp = jj_scanpos;
    6269     if (jj_3R_413()) jj_scanpos = xsp;
    6270     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6271     return false;
    6272   }
    6273
    6274   final private boolean jj_3R_305() {
    6275     if (jj_scan_token(SEMICOLON)) return true;
    6276     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6277     return false;
    6278   }
    6279
    6280   final private boolean jj_3R_302() {
    6281     if (jj_scan_token(IDENTIFIER)) return true;
    6282     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6283     if (jj_3R_297()) return true;
    6284     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6285     Token xsp;
    6286     while (true) {
    6287       xsp = jj_scanpos;
    6288       if (jj_3R_349()) { jj_scanpos = xsp; break; }
    6289       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6290     }
    6291     return false;
    6292   }
    6293
    6294   final private boolean jj_3R_435() {
    6295     if (jj_scan_token(_DEFAULT)) return true;
    6296     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6297     if (jj_scan_token(COLON)) return true;
    6298     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6299     return false;
    6300   }
    6301
    6302   final private boolean jj_3R_434() {
    6303     if (jj_scan_token(CASE)) return true;
    6304     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6305     if (jj_3R_70()) return true;
    6306     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6307     if (jj_scan_token(COLON)) return true;
    6308     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6309     return false;
    6310   }
    6311
    6312   final private boolean jj_3R_425() {
    6313     Token xsp;
    6314     xsp = jj_scanpos;
    6315     if (jj_3R_434()) {
    6316     jj_scanpos = xsp;
    6317     if (jj_3R_435()) return true;
    6318     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6319     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6320     return false;
    6321   }
    6322
    6323   final private boolean jj_3R_404() {
    6324     if (jj_scan_token(COMMA)) return true;
    6325     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6326     if (jj_3R_403()) return true;
    6327     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6328     return false;
    6329   }
    6330
    6331   final private boolean jj_3R_412() {
    6332     if (jj_3R_425()) return true;
    6333     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6334     Token xsp;
    6335     while (true) {
    6336       xsp = jj_scanpos;
    6337       if (jj_3R_426()) { jj_scanpos = xsp; break; }
    6338       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6339     }
    6340     return false;
    6341   }
    6342
    6343   final private boolean jj_3R_304() {
    6344     if (jj_3R_350()) return true;
    6345     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6346     return false;
    6347   }
    6348
    6349   final private boolean jj_3R_303() {
    6350     if (jj_scan_token(THROWS)) return true;
    6351     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6352     if (jj_3R_339()) return true;
    6353     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6354     return false;
    6355   }
    6356
    6357   final private boolean jj_3R_231() {
    6358     if (jj_scan_token(SWITCH)) return true;
    6359     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6360     if (jj_scan_token(LPAREN)) return true;
    6361     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6362     if (jj_3R_70()) return true;
    6363     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6364     if (jj_scan_token(RPAREN)) return true;
    6365     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6366     if (jj_scan_token(LBRACE)) return true;
    6367     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6368     Token xsp;
    6369     while (true) {
    6370       xsp = jj_scanpos;
    6371       if (jj_3R_412()) { jj_scanpos = xsp; break; }
    6372       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6373     }
    6374     if (jj_scan_token(RBRACE)) return true;
    6375     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6376     return false;
    6377   }
    6378
    6379   final private boolean jj_3R_264() {
    6380     if (jj_scan_token(COMMA)) return true;
    6381     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6382     return false;
    6383   }
    6384
    6385   final private boolean jj_3R_433() {
    6386     if (jj_3R_195()) return true;
    6387     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6388     if (jj_3R_70()) return true;
    6389     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6390     return false;
    6391   }
    6392
    6393   final private boolean jj_3R_432() {
    6394     if (jj_scan_token(DECR)) return true;
    6395     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6396     return false;
    6397   }
    6398
    6399   final private boolean jj_3R_348() {
    6400     if (jj_scan_token(STRICTFP)) return true;
    6401     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6402     return false;
    6403   }
    6404
    6405   final private boolean jj_3R_431() {
    6406     if (jj_scan_token(INCR)) return true;
    6407     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6408     return false;
    6409   }
    6410
    6411   final private boolean jj_3R_424() {
    6412     Token xsp;
    6413     xsp = jj_scanpos;
    6414     if (jj_3R_431()) {
    6415     jj_scanpos = xsp;
    6416     if (jj_3R_432()) {
    6417     jj_scanpos = xsp;
    6418     if (jj_3R_433()) return true;
    6419     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6420     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6421     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6422     return false;
    6423   }
    6424
    6425   final private boolean jj_3R_247() {
    6426     if (jj_3R_63()) return true;
    6427     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6428     Token xsp;
    6429     xsp = jj_scanpos;
    6430     if (jj_3R_424()) jj_scanpos = xsp;
    6431     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6432     return false;
    6433   }
    6434
    6435   final private boolean jj_3R_347() {
    6436     if (jj_scan_token(SYNCHRONIZED)) return true;
    6437     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6438     return false;
    6439   }
    6440
    6441   final private boolean jj_3R_246() {
    6442     if (jj_3R_254()) return true;
    6443     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6444     return false;
    6445   }
    6446
    6447   final private boolean jj_3R_230() {
    6448     Token xsp;
    6449     xsp = jj_scanpos;
    6450     if (jj_3R_245()) {
    6451     jj_scanpos = xsp;
    6452     if (jj_3R_246()) {
    6453     jj_scanpos = xsp;
    6454     if (jj_3R_247()) return true;
    6455     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6456     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6457     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6458     return false;
    6459   }
    6460
    6461   final private boolean jj_3R_245() {
    6462     if (jj_3R_253()) return true;
    6463     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6464     return false;
    6465   }
    6466
    6467   final private boolean jj_3R_346() {
    6468     if (jj_scan_token(NATIVE)) return true;
    6469     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6470     return false;
    6471   }
    6472
    6473   final private boolean jj_3R_345() {
    6474     if (jj_scan_token(FINAL)) return true;
    6475     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6476     return false;
    6477   }
    6478
    6479   final private boolean jj_3R_229() {
    6480     if (jj_scan_token(SEMICOLON)) return true;
    6481     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6482     return false;
    6483   }
    6484
    6485   final private boolean jj_3R_344() {
    6486     if (jj_scan_token(ABSTRACT)) return true;
    6487     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6488     return false;
    6489   }
    6490
    6491   final private boolean jj_3R_197() {
    6492     if (jj_scan_token(FINAL)) return true;
    6493     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6494     return false;
    6495   }
    6496
    6497   final private boolean jj_3R_188() {
    6498     Token xsp;
    6499     xsp = jj_scanpos;
    6500     if (jj_3R_197()) jj_scanpos = xsp;
    6501     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6502     if (jj_3R_73()) return true;
    6503     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6504     if (jj_3R_403()) return true;
    6505     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6506     while (true) {
    6507       xsp = jj_scanpos;
    6508       if (jj_3R_404()) { jj_scanpos = xsp; break; }
    6509       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6510     }
    6511     return false;
    6512   }
    6513
    6514   final private boolean jj_3R_343() {
    6515     if (jj_scan_token(STATIC)) return true;
    6516     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6517     return false;
    6518   }
    6519
    6520   final private boolean jj_3R_342() {
    6521     if (jj_scan_token(PRIVATE)) return true;
    6522     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6523     return false;
    6524   }
    6525
    6526   final private boolean jj_3R_408() {
    6527     if (jj_3R_191()) return true;
    6528     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6529     return false;
    6530   }
    6531
    6532   final private boolean jj_3_10() {
    6533     if (jj_scan_token(COMMA)) return true;
    6534     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6535     if (jj_3R_61()) return true;
    6536     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6537     return false;
    6538   }
    6539
    6540   final private boolean jj_3R_74() {
    6541     if (jj_scan_token(FINAL)) return true;
    6542     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6543     return false;
    6544   }
    6545
    6546   final private boolean jj_3_30() {
    6547     Token xsp;
    6548     xsp = jj_scanpos;
    6549     if (jj_3R_74()) jj_scanpos = xsp;
    6550     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6551     if (jj_3R_73()) return true;
    6552     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6553     if (jj_scan_token(IDENTIFIER)) return true;
    6554     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6555     return false;
    6556   }
    6557
    6558   final private boolean jj_3R_341() {
    6559     if (jj_scan_token(PROTECTED)) return true;
    6560     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6561     return false;
    6562   }
    6563
    6564   final private boolean jj_3R_407() {
    6565     if (jj_3R_190()) return true;
    6566     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6567     return false;
    6568   }
    6569
    6570   final private boolean jj_3R_406() {
    6571     if (jj_3R_189()) return true;
    6572     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6573     return false;
    6574   }
    6575
    6576   final private boolean jj_3R_340() {
    6577     if (jj_scan_token(PUBLIC)) return true;
    6578     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6579     return false;
    6580   }
    6581
    6582   final private boolean jj_3R_301() {
    6583     Token xsp;
    6584     xsp = jj_scanpos;
    6585     if (jj_3R_340()) {
    6586     jj_scanpos = xsp;
    6587     if (jj_3R_341()) {
    6588     jj_scanpos = xsp;
    6589     if (jj_3R_342()) {
    6590     jj_scanpos = xsp;
    6591     if (jj_3R_343()) {
    6592     jj_scanpos = xsp;
    6593     if (jj_3R_344()) {
    6594     jj_scanpos = xsp;
    6595     if (jj_3R_345()) {
    6596     jj_scanpos = xsp;
    6597     if (jj_3R_346()) {
    6598     jj_scanpos = xsp;
    6599     if (jj_3R_347()) {
    6600     jj_scanpos = xsp;
    6601     if (jj_3R_348()) return true;
    6602     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6603     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6604     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6605     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6606     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6607     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6608     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6609     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6610     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6611     return false;
    6612   }
    6613
    6614   final private boolean jj_3R_405() {
    6615     if (jj_3R_188()) return true;
    6616     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6617     if (jj_scan_token(SEMICOLON)) return true;
    6618     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6619     return false;
    6620   }
    6621
    6622   final private boolean jj_3R_395() {
    6623     Token xsp;
    6624     xsp = jj_scanpos;
    6625     if (jj_3R_405()) {
    6626     jj_scanpos = xsp;
    6627     if (jj_3R_406()) {
    6628     jj_scanpos = xsp;
    6629     if (jj_3R_407()) {
    6630     jj_scanpos = xsp;
    6631     if (jj_3R_408()) return true;
    6632     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6633     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6634     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6635     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6636     return false;
    6637   }
    6638
    6639   final private boolean jj_3R_283() {
    6640     Token xsp;
    6641     while (true) {
    6642       xsp = jj_scanpos;
    6643       if (jj_3R_301()) { jj_scanpos = xsp; break; }
    6644       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6645     }
    6646     if (jj_3R_68()) return true;
    6647     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6648     if (jj_3R_302()) return true;
    6649     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6650     xsp = jj_scanpos;
    6651     if (jj_3R_303()) jj_scanpos = xsp;
    6652     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6653     xsp = jj_scanpos;
    6654     if (jj_3R_304()) {
    6655     jj_scanpos = xsp;
    6656     if (jj_3R_305()) return true;
    6657     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6658     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6659     return false;
    6660   }
    6661
    6662   final private boolean jj_3R_263() {
    6663     if (jj_3R_61()) return true;
    6664     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6665     Token xsp;
    6666     while (true) {
    6667       xsp = jj_scanpos;
    6668       if (jj_3_10()) { jj_scanpos = xsp; break; }
    6669       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6670     }
    6671     return false;
    6672   }
    6673
    6674   final private boolean jj_3R_179() {
    6675     if (jj_3R_191()) return true;
    6676     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6677     return false;
    6678   }
    6679
    6680   final private boolean jj_3R_72() {
    6681     if (jj_scan_token(FINAL)) return true;
    6682     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6683     return false;
    6684   }
    6685
    6686   final private boolean jj_3_29() {
    6687     Token xsp;
    6688     xsp = jj_scanpos;
    6689     if (jj_3R_72()) jj_scanpos = xsp;
    6690     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6691     if (jj_3R_73()) return true;
    6692     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6693     if (jj_scan_token(IDENTIFIER)) return true;
    6694     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6695     return false;
    6696   }
    6697
    6698   final private boolean jj_3R_411() {
    6699     if (jj_scan_token(LBRACKET)) return true;
    6700     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6701     if (jj_scan_token(RBRACKET)) return true;
    6702     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6703     return false;
    6704   }
    6705
    6706   final private boolean jj_3R_150() {
    6707     if (jj_scan_token(LBRACE)) return true;
    6708     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6709     Token xsp;
    6710     xsp = jj_scanpos;
    6711     if (jj_3R_263()) jj_scanpos = xsp;
    6712     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6713     xsp = jj_scanpos;
    6714     if (jj_3R_264()) jj_scanpos = xsp;
    6715     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6716     if (jj_scan_token(RBRACE)) return true;
    6717     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6718     return false;
    6719   }
    6720
    6721   final private boolean jj_3R_178() {
    6722     if (jj_3R_190()) return true;
    6723     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6724     return false;
    6725   }
    6726
    6727   final private boolean jj_3R_177() {
    6728     if (jj_3R_189()) return true;
    6729     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6730     return false;
    6731   }
    6732
    6733   final private boolean jj_3R_402() {
    6734     if (jj_scan_token(LBRACKET)) return true;
    6735     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6736     if (jj_scan_token(RBRACKET)) return true;
    6737     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6738     return false;
    6739   }
    6740
    6741   final private boolean jj_3R_115() {
    6742     if (jj_3R_70()) return true;
    6743     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6744     return false;
    6745   }
    6746
    6747   final private boolean jj_3R_362() {
    6748     if (jj_scan_token(ASSIGN)) return true;
    6749     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6750     if (jj_3R_61()) return true;
    6751     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6752     return false;
    6753   }
    6754
    6755   final private boolean jj_3R_114() {
    6756     if (jj_3R_150()) return true;
    6757     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6758     return false;
    6759   }
    6760
    6761   final private boolean jj_3R_61() {
    6762     Token xsp;
    6763     xsp = jj_scanpos;
    6764     if (jj_3R_114()) {
    6765     jj_scanpos = xsp;
    6766     if (jj_3R_115()) return true;
    6767     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6768     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6769     return false;
    6770   }
    6771
    6772   final private boolean jj_3R_169() {
    6773     Token xsp;
    6774     xsp = jj_scanpos;
    6775     if (jj_3R_176()) {
    6776     jj_scanpos = xsp;
    6777     if (jj_3R_177()) {
    6778     jj_scanpos = xsp;
    6779     if (jj_3R_178()) {
    6780     jj_scanpos = xsp;
    6781     if (jj_3R_179()) return true;
    6782     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6783     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6784     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6785     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6786     return false;
    6787   }
    6788
    6789   final private boolean jj_3R_176() {
    6790     if (jj_3R_188()) return true;
    6791     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6792     if (jj_scan_token(SEMICOLON)) return true;
    6793     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6794     return false;
    6795   }
    6796
    6797   final private boolean jj_3R_409() {
    6798     if (jj_scan_token(IDENTIFIER)) return true;
    6799     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6800     Token xsp;
    6801     while (true) {
    6802       xsp = jj_scanpos;
    6803       if (jj_3R_411()) { jj_scanpos = xsp; break; }
    6804       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6805     }
    6806     return false;
    6807   }
    6808
    6809   final private boolean jj_3R_376() {
    6810     if (jj_scan_token(SEMICOLON)) return true;
    6811     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6812     return false;
    6813   }
    6814
    6815   final private boolean jj_3R_410() {
    6816     if (jj_scan_token(ASSIGN)) return true;
    6817     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6818     if (jj_3R_61()) return true;
    6819     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6820     return false;
    6821   }
    6822
    6823   final private boolean jj_3R_377() {
    6824     if (jj_scan_token(LBRACKET)) return true;
    6825     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6826     if (jj_scan_token(RBRACKET)) return true;
    6827     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6828     return false;
    6829   }
    6830
    6831   final private boolean jj_3R_375() {
    6832     if (jj_3R_395()) return true;
    6833     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6834     return false;
    6835   }
    6836
    6837   final private boolean jj_3R_393() {
    6838     if (jj_scan_token(IDENTIFIER)) return true;
    6839     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6840     Token xsp;
    6841     while (true) {
    6842       xsp = jj_scanpos;
    6843       if (jj_3R_402()) { jj_scanpos = xsp; break; }
    6844       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6845     }
    6846     return false;
    6847   }
    6848
    6849   final private boolean jj_3R_350() {
    6850     if (jj_scan_token(LBRACE)) return true;
    6851     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6852     Token xsp;
    6853     while (true) {
    6854       xsp = jj_scanpos;
    6855       if (jj_3R_375()) { jj_scanpos = xsp; break; }
    6856       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6857     }
    6858     if (jj_scan_token(RBRACE)) return true;
    6859     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6860     xsp = jj_scanpos;
    6861     if (jj_3R_376()) jj_scanpos = xsp;
    6862     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6863     return false;
    6864   }
    6865
    6866   final private boolean jj_3R_140() {
    6867     if (jj_3R_169()) return true;
    6868     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6869     return false;
    6870   }
    6871
    6872   final private boolean jj_3R_81() {
    6873     if (jj_scan_token(LBRACE)) return true;
    6874     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6875     Token xsp;
    6876     while (true) {
    6877       xsp = jj_scanpos;
    6878       if (jj_3R_140()) { jj_scanpos = xsp; break; }
    6879       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6880     }
    6881     if (jj_scan_token(RBRACE)) return true;
    6882     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6883     return false;
    6884   }
    6885
    6886   final private boolean jj_3R_361() {
    6887     if (jj_scan_token(IDENTIFIER)) return true;
    6888     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6889     Token xsp;
    6890     while (true) {
    6891       xsp = jj_scanpos;
    6892       if (jj_3R_377()) { jj_scanpos = xsp; break; }
    6893       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6894     }
    6895     return false;
    6896   }
    6897
    6898   final private boolean jj_3R_71() {
    6899     if (jj_scan_token(IDENTIFIER)) return true;
    6900     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6901     if (jj_scan_token(COLON)) return true;
    6902     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6903     if (jj_3R_189()) return true;
    6904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6905     return false;
    6906   }
    6907
    6908   final private boolean jj_3R_212() {
    6909     if (jj_3R_242()) return true;
    6910     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6911     return false;
    6912   }
    6913
    6914   final private boolean jj_3R_403() {
    6915     if (jj_3R_409()) return true;
    6916     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6917     Token xsp;
    6918     xsp = jj_scanpos;
    6919     if (jj_3R_410()) jj_scanpos = xsp;
    6920     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6921     return false;
    6922   }
    6923
    6924   final private boolean jj_3R_113() {
    6925     if (jj_scan_token(STRICTFP)) return true;
    6926     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6927     return false;
    6928   }
    6929
    6930   final private boolean jj_3R_211() {
    6931     if (jj_3R_241()) return true;
    6932     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6933     return false;
    6934   }
    6935
    6936   final private boolean jj_3_26() {
    6937     if (jj_scan_token(LBRACKET)) return true;
    6938     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6939     if (jj_scan_token(RBRACKET)) return true;
    6940     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6941     return false;
    6942   }
    6943
    6944   final private boolean jj_3R_106() {
    6945     if (jj_scan_token(STRICTFP)) return true;
    6946     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6947     return false;
    6948   }
    6949
    6950   final private boolean jj_3R_210() {
    6951     if (jj_3R_240()) return true;
    6952     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6953     return false;
    6954   }
    6955
    6956   final private boolean jj_3R_209() {
    6957     if (jj_3R_239()) return true;
    6958     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6959     return false;
    6960   }
    6961
    6962   final private boolean jj_3R_308() {
    6963     if (jj_3R_361()) return true;
    6964     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6965     Token xsp;
    6966     xsp = jj_scanpos;
    6967     if (jj_3R_362()) jj_scanpos = xsp;
    6968     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6969     return false;
    6970   }
    6971
    6972   final private boolean jj_3R_208() {
    6973     if (jj_3R_238()) return true;
    6974     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6975     return false;
    6976   }
    6977
    6978   final private boolean jj_3R_207() {
    6979     if (jj_3R_237()) return true;
    6980     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6981     return false;
    6982   }
    6983
    6984   final private boolean jj_3R_206() {
    6985     if (jj_3R_236()) return true;
    6986     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6987     return false;
    6988   }
    6989
    6990   final private boolean jj_3R_112() {
    6991     if (jj_scan_token(PRIVATE)) return true;
    6992     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6993     return false;
    6994   }
    6995
    6996   final private boolean jj_3R_205() {
    6997     if (jj_3R_235()) return true;
    6998     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    6999     return false;
    7000   }
    7001
    7002   final private boolean jj_3R_105() {
    7003     if (jj_scan_token(PRIVATE)) return true;
    7004     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7005     return false;
    7006   }
    7007
    7008   final private boolean jj_3R_204() {
    7009     if (jj_3R_234()) return true;
    7010     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7011     return false;
    7012   }
    7013
    7014   final private boolean jj_3R_203() {
    7015     if (jj_3R_233()) return true;
    7016     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7017     return false;
    7018   }
    7019
    7020   final private boolean jj_3R_202() {
    7021     if (jj_3R_232()) return true;
    7022     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7023     return false;
    7024   }
    7025
    7026   final private boolean jj_3R_201() {
    7027     if (jj_3R_231()) return true;
    7028     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7029     return false;
    7030   }
    7031
    7032   final private boolean jj_3R_200() {
    7033     if (jj_3R_230()) return true;
    7034     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7035     if (jj_scan_token(SEMICOLON)) return true;
    7036     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7037     return false;
    7038   }
    7039
    7040   final private boolean jj_3R_309() {
    7041     if (jj_scan_token(COMMA)) return true;
    7042     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7043     if (jj_3R_308()) return true;
    7044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7045     return false;
    7046   }
    7047
    7048   final private boolean jj_3R_199() {
    7049     if (jj_3R_229()) return true;
    7050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7051     return false;
    7052   }
    7053
    7054   final private boolean jj_3R_111() {
    7055     if (jj_scan_token(PROTECTED)) return true;
    7056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7057     return false;
    7058   }
    7059
    7060   final private boolean jj_3R_198() {
    7061     if (jj_3R_81()) return true;
    7062     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7063     return false;
    7064   }
    7065
    7066   final private boolean jj_3R_104() {
    7067     if (jj_scan_token(PROTECTED)) return true;
    7068     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7069     return false;
    7070   }
    7071
    7072   final private boolean jj_3_28() {
    7073     if (jj_3R_71()) return true;
    7074     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7075     return false;
    7076   }
    7077
    7078   final private boolean jj_3R_189() {
    7079     Token xsp;
    7080     xsp = jj_scanpos;
    7081     if (jj_3_28()) {
    7082     jj_scanpos = xsp;
    7083     if (jj_3R_198()) {
    7084     jj_scanpos = xsp;
    7085     if (jj_3R_199()) {
    7086     jj_scanpos = xsp;
    7087     if (jj_3R_200()) {
    7088     jj_scanpos = xsp;
    7089     if (jj_3R_201()) {
    7090     jj_scanpos = xsp;
    7091     if (jj_3R_202()) {
    7092     jj_scanpos = xsp;
    7093     if (jj_3R_203()) {
    7094     jj_scanpos = xsp;
    7095     if (jj_3R_204()) {
    7096     jj_scanpos = xsp;
    7097     if (jj_3R_205()) {
    7098     jj_scanpos = xsp;
    7099     if (jj_3R_206()) {
    7100     jj_scanpos = xsp;
    7101     if (jj_3R_207()) {
    7102     jj_scanpos = xsp;
    7103     if (jj_3R_208()) {
    7104     jj_scanpos = xsp;
    7105     if (jj_3R_209()) {
    7106     jj_scanpos = xsp;
    7107     if (jj_3R_210()) {
    7108     jj_scanpos = xsp;
    7109     if (jj_3R_211()) {
    7110     jj_scanpos = xsp;
    7111     if (jj_3R_212()) 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     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7115     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7116     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7117     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7118     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7119     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7120     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7121     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7122     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7123     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7124     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7125     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7126     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7127     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7128     return false;
    7129   }
    7130
    7131   final private boolean jj_3R_357() {
    7132     if (jj_scan_token(VOLATILE)) return true;
    7133     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7134     return false;
    7135   }
    7136
    7137   final private boolean jj_3R_356() {
    7138     if (jj_scan_token(TRANSIENT)) return true;
    7139     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7140     return false;
    7141   }
    7142
    7143   final private boolean jj_3R_110() {
    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_259() {
    7150     if (jj_scan_token(LBRACKET)) return true;
    7151     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7152     if (jj_scan_token(RBRACKET)) return true;
    7153     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7154     return false;
    7155   }
    7156
    7157   final private boolean jj_3R_355() {
    7158     if (jj_scan_token(FINAL)) return true;
    7159     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7160     return false;
    7161   }
    7162
    7163   final private boolean jj_3R_103() {
    7164     if (jj_scan_token(PUBLIC)) return true;
    7165     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7166     return false;
    7167   }
    7168
    7169   final private boolean jj_3_25() {
    7170     if (jj_scan_token(LBRACKET)) return true;
    7171     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7172     if (jj_3R_70()) return true;
    7173     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7174     if (jj_scan_token(RBRACKET)) return true;
    7175     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7176     return false;
    7177   }
    7178
    7179   final private boolean jj_3R_255() {
    7180     Token xsp;
    7181     if (jj_3R_259()) return true;
    7182     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7183     while (true) {
    7184       xsp = jj_scanpos;
    7185       if (jj_3R_259()) { jj_scanpos = xsp; break; }
    7186       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7187     }
    7188     if (jj_3R_150()) return true;
    7189     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7190     return false;
    7191   }
    7192
    7193   final private boolean jj_3R_354() {
    7194     if (jj_scan_token(STATIC)) return true;
    7195     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7196     return false;
    7197   }
    7198
    7199   final private boolean jj_3_27() {
    7200     Token xsp;
    7201     if (jj_3_25()) return true;
    7202     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7203     while (true) {
    7204       xsp = jj_scanpos;
    7205       if (jj_3_25()) { jj_scanpos = xsp; break; }
    7206       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7207     }
    7208     while (true) {
    7209       xsp = jj_scanpos;
    7210       if (jj_3_26()) { jj_scanpos = xsp; break; }
    7211       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7212     }
    7213     return false;
    7214   }
    7215
    7216   final private boolean jj_3R_248() {
    7217     Token xsp;
    7218     xsp = jj_scanpos;
    7219     if (jj_3_27()) {
    7220     jj_scanpos = xsp;
    7221     if (jj_3R_255()) return true;
    7222     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7223     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7224     return false;
    7225   }
    7226
    7227   final private boolean jj_3R_109() {
    7228     if (jj_scan_token(FINAL)) return true;
    7229     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7230     return false;
    7231   }
    7232
    7233   final private boolean jj_3R_353() {
    7234     if (jj_scan_token(PRIVATE)) return true;
    7235     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7236     return false;
    7237   }
    7238
    7239   final private boolean jj_3R_102() {
    7240     if (jj_scan_token(FINAL)) return true;
    7241     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7242     return false;
    7243   }
    7244
    7245   final private boolean jj_3R_352() {
    7246     if (jj_scan_token(PROTECTED)) return true;
    7247     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7248     return false;
    7249   }
    7250
    7251   final private boolean jj_3R_351() {
    7252     if (jj_scan_token(PUBLIC)) return true;
    7253     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7254     return false;
    7255   }
    7256
    7257   final private boolean jj_3R_306() {
    7258     Token xsp;
    7259     xsp = jj_scanpos;
    7260     if (jj_3R_351()) {
    7261     jj_scanpos = xsp;
    7262     if (jj_3R_352()) {
    7263     jj_scanpos = xsp;
    7264     if (jj_3R_353()) {
    7265     jj_scanpos = xsp;
    7266     if (jj_3R_354()) {
    7267     jj_scanpos = xsp;
    7268     if (jj_3R_355()) {
    7269     jj_scanpos = xsp;
    7270     if (jj_3R_356()) {
    7271     jj_scanpos = xsp;
    7272     if (jj_3R_357()) return true;
    7273     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7274     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7275     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7276     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7277     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7278     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7279     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7280     return false;
    7281   }
    7282
    7283   final private boolean jj_3R_284() {
    7284     Token xsp;
    7285     while (true) {
    7286       xsp = jj_scanpos;
    7287       if (jj_3R_306()) { jj_scanpos = xsp; break; }
    7288       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7289     }
    7290     if (jj_3R_307()) return true;
    7291     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7292     if (jj_3R_308()) return true;
    7293     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7294     while (true) {
    7295       xsp = jj_scanpos;
    7296       if (jj_3R_309()) { jj_scanpos = xsp; break; }
    7297       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7298     }
    7299     if (jj_scan_token(SEMICOLON)) return true;
    7300     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7301     return false;
    7302   }
    7303
    7304   final private boolean jj_3R_108() {
    7305     if (jj_scan_token(ABSTRACT)) return true;
    7306     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7307     return false;
    7308   }
    7309
    7310   final private boolean jj_3R_101() {
    7311     if (jj_scan_token(ABSTRACT)) return true;
    7312     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7313     return false;
    7314   }
    7315
    7316   final private boolean jj_3R_256() {
    7317     if (jj_3R_260()) return true;
    7318     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7319     return false;
    7320   }
    7321
    7322   final private boolean jj_3R_250() {
    7323     if (jj_3R_64()) return true;
    7324     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7325     Token xsp;
    7326     xsp = jj_scanpos;
    7327     if (jj_3R_256()) jj_scanpos = xsp;
    7328     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7329     return false;
    7330   }
    7331
    7332   final private boolean jj_3R_249() {
    7333     if (jj_3R_248()) return true;
    7334     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7335     return false;
    7336   }
    7337
    7338   final private boolean jj_3_9() {
    7339     if (jj_3R_58()) return true;
    7340     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7341     return false;
    7342   }
    7343
    7344   final private boolean jj_3R_107() {
    7345     if (jj_scan_token(STATIC)) return true;
    7346     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7347     return false;
    7348   }
    7349
    7350   final private boolean jj_3R_60() {
    7351     Token xsp;
    7352     xsp = jj_scanpos;
    7353     if (jj_3R_107()) {
    7354     jj_scanpos = xsp;
    7355     if (jj_3R_108()) {
    7356     jj_scanpos = xsp;
    7357     if (jj_3R_109()) {
    7358     jj_scanpos = xsp;
    7359     if (jj_3R_110()) {
    7360     jj_scanpos = xsp;
    7361     if (jj_3R_111()) {
    7362     jj_scanpos = xsp;
    7363     if (jj_3R_112()) {
    7364     jj_scanpos = xsp;
    7365     if (jj_3R_113()) return true;
    7366     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7367     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7368     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7369     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7370     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7371     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7372     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7373     return false;
    7374   }
    7375
    7376   final private boolean jj_3_8() {
    7377     Token xsp;
    7378     while (true) {
    7379       xsp = jj_scanpos;
    7380       if (jj_3R_60()) { jj_scanpos = xsp; break; }
    7381       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7382     }
    7383     if (jj_scan_token(INTERFACE)) return true;
    7384     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7385     return false;
    7386   }
    7387
    7388   final private boolean jj_3R_171() {
    7389     if (jj_scan_token(COMMA)) return true;
    7390     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7391     if (jj_3R_70()) return true;
    7392     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7393     return false;
    7394   }
    7395
    7396   final private boolean jj_3R_100() {
    7397     if (jj_scan_token(STATIC)) return true;
    7398     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7399     return false;
    7400   }
    7401
    7402   final private boolean jj_3R_59() {
    7403     Token xsp;
    7404     xsp = jj_scanpos;
    7405     if (jj_3R_100()) {
    7406     jj_scanpos = xsp;
    7407     if (jj_3R_101()) {
    7408     jj_scanpos = xsp;
    7409     if (jj_3R_102()) {
    7410     jj_scanpos = xsp;
    7411     if (jj_3R_103()) {
    7412     jj_scanpos = xsp;
    7413     if (jj_3R_104()) {
    7414     jj_scanpos = xsp;
    7415     if (jj_3R_105()) {
    7416     jj_scanpos = xsp;
    7417     if (jj_3R_106()) return true;
    7418     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7419     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7420     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7421     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7422     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7423     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7424     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7425     return false;
    7426   }
    7427
    7428   final private boolean jj_3R_135() {
    7429     if (jj_scan_token(NEW)) return true;
    7430     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7431     if (jj_3R_57()) return true;
    7432     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7433     Token xsp;
    7434     xsp = jj_scanpos;
    7435     if (jj_3R_249()) {
    7436     jj_scanpos = xsp;
    7437     if (jj_3R_250()) return true;
    7438     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7439     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7440     return false;
    7441   }
    7442
    7443   final private boolean jj_3_7() {
    7444     Token xsp;
    7445     while (true) {
    7446       xsp = jj_scanpos;
    7447       if (jj_3R_59()) { jj_scanpos = xsp; break; }
    7448       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7449     }
    7450     if (jj_scan_token(CLASS)) return true;
    7451     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7452     return false;
    7453   }
    7454
    7455   final private boolean jj_3_24() {
    7456     if (jj_scan_token(NEW)) return true;
    7457     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7458     if (jj_3R_66()) return true;
    7459     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7460     if (jj_3R_248()) return true;
    7461     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7462     return false;
    7463   }
    7464
    7465   final private boolean jj_3R_69() {
    7466     Token xsp;
    7467     xsp = jj_scanpos;
    7468     if (jj_3_24()) {
    7469     jj_scanpos = xsp;
    7470     if (jj_3R_135()) return true;
    7471     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7472     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7473     return false;
    7474   }
    7475
    7476   final private boolean jj_3R_390() {
    7477     if (jj_3R_284()) return true;
    7478     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7479     return false;
    7480   }
    7481
    7482   final private boolean jj_3R_389() {
    7483     if (jj_3R_283()) return true;
    7484     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7485     return false;
    7486   }
    7487
    7488   final private boolean jj_3R_388() {
    7489     if (jj_3R_281()) return true;
    7490     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7491     return false;
    7492   }
    7493
    7494   final private boolean jj_3R_387() {
    7495     if (jj_3R_280()) return true;
    7496     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7497     return false;
    7498   }
    7499
    7500   final private boolean jj_3R_370() {
    7501     Token xsp;
    7502     xsp = jj_scanpos;
    7503     if (jj_3R_387()) {
    7504     jj_scanpos = xsp;
    7505     if (jj_3R_388()) {
    7506     jj_scanpos = xsp;
    7507     if (jj_3R_389()) {
    7508     jj_scanpos = xsp;
    7509     if (jj_3R_390()) return true;
    7510     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7511     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7512     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7513     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7514     return false;
    7515   }
    7516
    7517   final private boolean jj_3R_158() {
    7518     if (jj_3R_70()) return true;
    7519     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7520     Token xsp;
    7521     while (true) {
    7522       xsp = jj_scanpos;
    7523       if (jj_3R_171()) { jj_scanpos = xsp; break; }
    7524       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7525     }
    7526     return false;
    7527   }
    7528
    7529   final private boolean jj_3R_119() {
    7530     if (jj_3R_158()) return true;
    7531     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7532     return false;
    7533   }
    7534
    7535   final private boolean jj_3R_64() {
    7536     if (jj_scan_token(LPAREN)) return true;
    7537     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7538     Token xsp;
    7539     xsp = jj_scanpos;
    7540     if (jj_3R_119()) jj_scanpos = xsp;
    7541     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7542     if (jj_scan_token(RPAREN)) return true;
    7543     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7544     return false;
    7545   }
    7546
    7547   final private boolean jj_3R_334() {
    7548     if (jj_3R_370()) return true;
    7549     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7550     return false;
    7551   }
    7552
    7553   final private boolean jj_3R_193() {
    7554     if (jj_scan_token(NULL)) return true;
    7555     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7556     return false;
    7557   }
    7558
    7559   final private boolean jj_3R_333() {
    7560     if (jj_scan_token(EXTENDS)) return true;
    7561     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7562     if (jj_3R_369()) return true;
    7563     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7564     return false;
    7565   }
    7566
    7567   final private boolean jj_3R_149() {
    7568     if (jj_scan_token(STRICTFP)) return true;
    7569     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7570     return false;
    7571   }
    7572
    7573   final private boolean jj_3R_214() {
    7574     if (jj_scan_token(FALSE)) return true;
    7575     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7576     return false;
    7577   }
    7578
    7579   final private boolean jj_3R_192() {
    7580     Token xsp;
    7581     xsp = jj_scanpos;
    7582     if (jj_3R_213()) {
    7583     jj_scanpos = xsp;
    7584     if (jj_3R_214()) return true;
    7585     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7586     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7587     return false;
    7588   }
    7589
    7590   final private boolean jj_3R_213() {
    7591     if (jj_scan_token(TRUE)) return true;
    7592     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7593     return false;
    7594   }
    7595
    7596   final private boolean jj_3R_166() {
    7597     if (jj_3R_170()) return true;
    7598     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7599     return false;
    7600   }
    7601
    7602   final private boolean jj_3R_185() {
    7603     if (jj_3R_193()) return true;
    7604     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7605     return false;
    7606   }
    7607
    7608   final private boolean jj_3R_184() {
    7609     if (jj_3R_192()) return true;
    7610     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7611     return false;
    7612   }
    7613
    7614   final private boolean jj_3R_183() {
    7615     if (jj_scan_token(STRING_LITERAL)) return true;
    7616     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7617     return false;
    7618   }
    7619
    7620   final private boolean jj_3R_148() {
    7621     if (jj_scan_token(SYNCHRONIZED)) return true;
    7622     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7623     return false;
    7624   }
    7625
    7626   final private boolean jj_3R_182() {
    7627     if (jj_scan_token(CHARACTER_LITERAL)) return true;
    7628     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7629     return false;
    7630   }
    7631
    7632   final private boolean jj_3R_165() {
    7633     if (jj_scan_token(NEW)) return true;
    7634     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7635     return false;
    7636   }
    7637
    7638   final private boolean jj_3R_181() {
    7639     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
    7640     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7641     return false;
    7642   }
    7643
    7644   final private boolean jj_3R_191() {
    7645     if (jj_scan_token(INTERFACE)) return true;
    7646     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7647     if (jj_scan_token(IDENTIFIER)) return true;
    7648     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7649     Token xsp;
    7650     xsp = jj_scanpos;
    7651     if (jj_3R_333()) jj_scanpos = xsp;
    7652     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7653     if (jj_scan_token(LBRACE)) return true;
    7654     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7655     while (true) {
    7656       xsp = jj_scanpos;
    7657       if (jj_3R_334()) { jj_scanpos = xsp; break; }
    7658       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7659     }
    7660     if (jj_scan_token(RBRACE)) return true;
    7661     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    7662     return false;
    7663   }
    7664
    7665   public SimpleParserTokenManager token_source;
    7666   JavaCharStream jj_input_stream;
    7667   public Token token, jj_nt;
    7668   private Token jj_scanpos, jj_lastpos;
    7669   private int jj_la;
    7670   public boolean lookingAhead = false;
    7671   private boolean jj_semLA;
    7672   private int jj_gen;
    7673   final private int[] jj_la1 = new int[129];
    7674   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,};
    7675   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,};
    7676   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,};
    7677   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,};
    7678   final private JJCalls[] jj_2_rtns = new JJCalls[31];
    7679   private boolean jj_rescan = false;
    7680   private int jj_gc = 0;
    7681
    7682   public SimpleParser(java.io.InputStream stream) {
    7683     jj_input_stream = new JavaCharStream(stream, 1, 1);
    7684     token_source = new SimpleParserTokenManager(jj_input_stream);
    7685     token = new Token();
    7686     token.next = jj_nt = token_source.getNextToken();
    7687     jj_gen = 0;
    7688     for (int i = 0; i < 129; i++) jj_la1[i] = -1;
    7689     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    7690   }
    7691
    7692   public void ReInit(java.io.InputStream stream) {
    7693     jj_input_stream.ReInit(stream, 1, 1);
    7694     token_source.ReInit(jj_input_stream);
    7695     token = new Token();
    7696     token.next = jj_nt = token_source.getNextToken();
    7697     jj_gen = 0;
    7698     for (int i = 0; i < 129; i++) jj_la1[i] = -1;
    7699     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    7700   }
    7701
    7702   public SimpleParser(java.io.Reader stream) {
    7703     jj_input_stream = new JavaCharStream(stream, 1, 1);
    7704     token_source = new SimpleParserTokenManager(jj_input_stream);
    7705     token = new Token();
    7706     token.next = jj_nt = token_source.getNextToken();
    7707     jj_gen = 0;
    7708     for (int i = 0; i < 129; i++) jj_la1[i] = -1;
    7709     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    7710   }
    7711
    7712   public void ReInit(java.io.Reader stream) {
    7713     jj_input_stream.ReInit(stream, 1, 1);
    7714     token_source.ReInit(jj_input_stream);
    7715     token = new Token();
    7716     token.next = jj_nt = token_source.getNextToken();
    7717     jj_gen = 0;
    7718     for (int i = 0; i < 129; i++) jj_la1[i] = -1;
    7719     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    7720   }
    7721
    7722   public SimpleParser(SimpleParserTokenManager tm) {
    7723     token_source = tm;
    7724     token = new Token();
    7725     token.next = jj_nt = token_source.getNextToken();
    7726     jj_gen = 0;
    7727     for (int i = 0; i < 129; i++) jj_la1[i] = -1;
    7728     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    7729   }
    7730
    7731   public void ReInit(SimpleParserTokenManager tm) {
    7732     token_source = tm;
    7733     token = new Token();
    7734     token.next = jj_nt = token_source.getNextToken();
    7735     jj_gen = 0;
    7736     for (int i = 0; i < 129; i++) jj_la1[i] = -1;
    7737     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    7738   }
    7739
    7740   final private Token jj_consume_token(int kind) throws ParseException {
    7741     Token oldToken = token;
    7742     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    7743     else jj_nt = jj_nt.next = token_source.getNextToken();
    7744     if (token.kind == kind) {
    7745       jj_gen++;
    7746       if (++jj_gc > 100) {
    7747         jj_gc = 0;
    7748         for (int i = 0; i < jj_2_rtns.length; i++) {
    7749           JJCalls c = jj_2_rtns[i];
    7750           while (c != null) {
    7751             if (c.gen < jj_gen) c.first = null;
    7752             c = c.next;
    7753           }
    7754         }
    7755       }
    7756       return token;
    7757     }
    7758     jj_nt = token;
    7759     token = oldToken;
    7760     jj_kind = kind;
    7761     throw generateParseException();
    7762   }
    7763
    7764   final private boolean jj_scan_token(int kind) {
    7765     if (jj_scanpos == jj_lastpos) {
    7766       jj_la--;
    7767       if (jj_scanpos.next == null) {
    7768         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    7769       } else {
    7770         jj_lastpos = jj_scanpos = jj_scanpos.next;
    7771       }
    7772     } else {
    7773       jj_scanpos = jj_scanpos.next;
    7774     }
    7775     if (jj_rescan) {
    7776       int i = 0; Token tok = token;
    7777       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    7778       if (tok != null) jj_add_error_token(kind, i);
    7779     }
    7780     return (jj_scanpos.kind != kind);
    7781   }
    7782
    7783   final public Token getNextToken() {
    7784     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    7785     else jj_nt = jj_nt.next = token_source.getNextToken();
    7786     jj_gen++;
    7787     return token;
    7788   }
    7789
    7790   final public Token getToken(int index) {
    7791     Token t = lookingAhead ? jj_scanpos : token;
    7792     for (int i = 0; i < index; i++) {
    7793       if (t.next != null) t = t.next;
    7794       else t = t.next = token_source.getNextToken();
    7795     }
    7796     return t;
    7797   }
    7798
    7799   private java.util.Vector jj_expentries = new java.util.Vector();
    7800   private int[] jj_expentry;
    7801   private int jj_kind = -1;
    7802   private int[] jj_lasttokens = new int[100];
    7803   private int jj_endpos;
    7804
    7805   private void jj_add_error_token(int kind, int pos) {
    7806     if (pos >= 100) return;
    7807     if (pos == jj_endpos + 1) {
    7808       jj_lasttokens[jj_endpos++] = kind;
    7809     } else if (jj_endpos != 0) {
    7810       jj_expentry = new int[jj_endpos];
    7811       for (int i = 0; i < jj_endpos; i++) {
    7812         jj_expentry[i] = jj_lasttokens[i];
    7813       }
    7814       boolean exists = false;
    7815       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
    7816         int[] oldentry = (int[])(enum.nextElement());
    7817         if (oldentry.length == jj_expentry.length) {
    7818           exists = true;
    7819           for (int i = 0; i < jj_expentry.length; i++) {
    7820             if (oldentry[i] != jj_expentry[i]) {
    7821               exists = false;
    7822               break;
    7823             }
    7824           }
    7825           if (exists) break;
    7826         }
    7827       }
    7828       if (!exists) jj_expentries.addElement(jj_expentry);
    7829       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    7830     }
    7831   }
    7832
    7833   final public ParseException generateParseException() {
    7834     jj_expentries.removeAllElements();
    7835     boolean[] la1tokens = new boolean[122];
    7836     for (int i = 0; i < 122; i++) {
    7837       la1tokens[i] = false;
    7838     }
    7839     if (jj_kind >= 0) {
    7840       la1tokens[jj_kind] = true;
    7841       jj_kind = -1;
    7842     }
    7843     for (int i = 0; i < 129; i++) {
    7844       if (jj_la1[i] == jj_gen) {
    7845         for (int j = 0; j < 32; j++) {
    7846           if ((jj_la1_0[i] & (1<<j)) != 0) {
    7847             la1tokens[j] = true;
    7848           }
    7849           if ((jj_la1_1[i] & (1<<j)) != 0) {
    7850             la1tokens[32+j] = true;
    7851           }
    7852           if ((jj_la1_2[i] & (1<<j)) != 0) {
    7853             la1tokens[64+j] = true;
    7854           }
    7855           if ((jj_la1_3[i] & (1<<j)) != 0) {
    7856             la1tokens[96+j] = true;
    7857           }
    7858         }
    7859       }
    7860     }
    7861     for (int i = 0; i < 122; i++) {
    7862       if (la1tokens[i]) {
    7863         jj_expentry = new int[1];
    7864         jj_expentry[0] = i;
    7865         jj_expentries.addElement(jj_expentry);
    7866       }
    7867     }
    7868     jj_endpos = 0;
    7869     jj_rescan_token();
    7870     jj_add_error_token(0, 0);
    7871     int[][] exptokseq = new int[jj_expentries.size()][];
    7872     for (int i = 0; i < jj_expentries.size(); i++) {
    7873       exptokseq[i] = (int[])jj_expentries.elementAt(i);
    7874     }
    7875     return new ParseException(token, exptokseq, tokenImage);
    7876   }
    7877
    7878   final public void enable_tracing() {
    7879   }
    7880
    7881   final public void disable_tracing() {
    7882   }
    7883
    7884   final private void jj_rescan_token() {
    7885     jj_rescan = true;
    7886     for (int i = 0; i < 31; i++) {
    7887       JJCalls p = jj_2_rtns[i];
    7888       do {
    7889         if (p.gen > jj_gen) {
    7890           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    7891           switch (i) {
    7892             case 0: jj_3_1(); break;
    7893             case 1: jj_3_2(); break;
    7894             case 2: jj_3_3(); break;
    7895             case 3: jj_3_4(); break;
    7896             case 4: jj_3_5(); break;
    7897             case 5: jj_3_6(); break;
    7898             case 6: jj_3_7(); break;
    7899             case 7: jj_3_8(); break;
    7900             case 8: jj_3_9(); break;
    7901             case 9: jj_3_10(); break;
    7902             case 10: jj_3_11(); break;
    7903             case 11: jj_3_12(); break;
    7904             case 12: jj_3_13(); break;
    7905             case 13: jj_3_14(); break;
    7906             case 14: jj_3_15(); break;
    7907             case 15: jj_3_16(); break;
    7908             case 16: jj_3_17(); break;
    7909             case 17: jj_3_18(); break;
    7910             case 18: jj_3_19(); break;
    7911             case 19: jj_3_20(); break;
    7912             case 20: jj_3_21(); break;
    7913             case 21: jj_3_22(); break;
    7914             case 22: jj_3_23(); break;
    7915             case 23: jj_3_24(); break;
    7916             case 24: jj_3_25(); break;
    7917             case 25: jj_3_26(); break;
    7918             case 26: jj_3_27(); break;
    7919             case 27: jj_3_28(); break;
    7920             case 28: jj_3_29(); break;
    7921             case 29: jj_3_30(); break;
    7922             case 30: jj_3_31(); break;
    7923           }
    7924         }
    7925         p = p.next;
    7926       } while (p != null);
    7927     }
    7928     jj_rescan = false;
    7929   }
    7930
    7931   final private void jj_save(int index, int xla) {
    7932     JJCalls p = jj_2_rtns[index];
    7933     while (p.gen > jj_gen) {
    7934       if (p.next == null) { p = p.next = new JJCalls(); break; }
    7935       p = p.next;
    7936     }
    7937     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    7938   }
    7939
    7940   static final class JJCalls {
    7941     int gen;
    7942     Token first;
    7943     int arg;
    7944     JJCalls next;
    7945   }
    7946
    7947 }