    001    /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
    002    package org.apache.commons.jexl2.parser;
    003
    004    import java.io.Reader;
    005    import org.apache.commons.jexl2.JexlInfo;
    006
    007    public class Parser extends StringParser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
    008      protected JJTParserState jjtree = new JJTParserState();public ASTJexlScript parse(Reader reader, JexlInfo info)
    009            throws ParseException
    010        {
    011            ReInit(reader);
    012            /*
    013             *  lets do the 'Unique Init' in here to be
    014             *  safe - it's a pain to remember
    015             */
    016
    017            ASTJexlScript tree = JexlScript();
    018            tree.value = info;
    019            return tree;
    020        }
    021
    022        void jjtreeOpenNodeScope(Node n) {}
    023        void jjtreeCloseNodeScope(Node n) throws ParseException {
    024          if (n instanceof ASTAmbiguous && n.jjtGetNumChildren() > 0) {
    025              Token tok = this.getToken(0);
    026              StringBuilder strb = new StringBuilder("Ambiguous statement ");
    027              if (tok != null) {
    028                  strb.append("@");
    029                  strb.append(tok.beginLine);
    030                  strb.append(":");
    031                  strb.append(tok.beginColumn);
    032              }
    033              strb.append(", missing ';' between expressions");
    034             throw new ParseException(strb.toString());
    035          }
    036        }
    037
    038    /***************************************
    039     *      Statements
    040     ***************************************/
    041      final public ASTJexlScript JexlScript() throws ParseException {
    042                                  /*@bgen(jjtree) JexlScript */
    043      ASTJexlScript jjtn000 = new ASTJexlScript(JJTJEXLSCRIPT);
    044      boolean jjtc000 = true;
    045      jjtree.openNodeScope(jjtn000);
    046      jjtreeOpenNodeScope(jjtn000);
    047        try {
    048          label_1:
    049          while (true) {
    050            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    051            case INTEGER_LITERAL:
    052            case FLOAT_LITERAL:
    053            case IF:
    054            case FOR:
    055            case FOREACH:
    056            case WHILE:
    057            case NEW:
    058            case EMPTY:
    059            case SIZE:
    060            case NULL:
    061            case TRUE:
    062            case FALSE:
    063            case LPAREN:
    064            case LCURLY:
    065            case LBRACKET:
    066            case SEMICOL:
    067            case 57:
    068            case 63:
    069            case 64:
    070            case 65:
    071            case IDENTIFIER:
    072            case STRING_LITERAL:
    073              ;
    074              break;
    075            default:
    076              jj_la1[0] = jj_gen;
    077              break label_1;
    078            }
    079            Statement();
    080          }
    081          jj_consume_token(0);
    082         jjtree.closeNodeScope(jjtn000, true);
    083         jjtc000 = false;
    084         jjtreeCloseNodeScope(jjtn000);
    085         {if (true) return jjtn000;}
    086        } catch (Throwable jjte000) {
    087         if (jjtc000) {
    088           jjtree.clearNodeScope(jjtn000);
    089           jjtc000 = false;
    090         } else {
    091           jjtree.popNode();
    092         }
    093         if (jjte000 instanceof RuntimeException) {
    094           {if (true) throw (RuntimeException)jjte000;}
    095         }
    096         if (jjte000 instanceof ParseException) {
    097           {if (true) throw (ParseException)jjte000;}
    098         }
    099         {if (true) throw (Error)jjte000;}
    100        } finally {
    101         if (jjtc000) {
    102           jjtree.closeNodeScope(jjtn000, true);
    103           jjtreeCloseNodeScope(jjtn000);
    104         }
    105        }
    106        throw new Error("Missing return statement in function");
    107      }
    108
    109      final public void Statement() throws ParseException {
    110        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    111        case SEMICOL:
    112          jj_consume_token(SEMICOL);
    113          break;
    114        default:
    115          jj_la1[1] = jj_gen;
    116          if (jj_2_1(3)) {
    117            Block();
    118          } else {
    119            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    120            case IF:
    121              IfStatement();
    122              break;
    123            case FOR:
    124            case FOREACH:
    125              ForeachStatement();
    126              break;
    127            case WHILE:
    128              WhileStatement();
    129              break;
    130            case INTEGER_LITERAL:
    131            case FLOAT_LITERAL:
    132            case NEW:
    133            case EMPTY:
    134            case SIZE:
    135            case NULL:
    136            case TRUE:
    137            case FALSE:
    138            case LPAREN:
    139            case LCURLY:
    140            case LBRACKET:
    141            case 57:
    142            case 63:
    143            case 64:
    144            case 65:
    145            case IDENTIFIER:
    146            case STRING_LITERAL:
    147              ExpressionStatement();
    148              break;
    149            default:
    150              jj_la1[2] = jj_gen;
    151              jj_consume_token(-1);
    152              throw new ParseException();
    153            }
    154          }
    155        }
    156      }
    157
    158      final public void Block() throws ParseException {
    159                           /*@bgen(jjtree) Block */
    160      ASTBlock jjtn000 = new ASTBlock(JJTBLOCK);
    161      boolean jjtc000 = true;
    162      jjtree.openNodeScope(jjtn000);
    163      jjtreeOpenNodeScope(jjtn000);
    164        try {
    165          jj_consume_token(LCURLY);
    166          label_2:
    167          while (true) {
    168            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    169            case INTEGER_LITERAL:
    170            case FLOAT_LITERAL:
    171            case IF:
    172            case FOR:
    173            case FOREACH:
    174            case WHILE:
    175            case NEW:
    176            case EMPTY:
    177            case SIZE:
    178            case NULL:
    179            case TRUE:
    180            case FALSE:
    181            case LPAREN:
    182            case LCURLY:
    183            case LBRACKET:
    184            case SEMICOL:
    185            case 57:
    186            case 63:
    187            case 64:
    188            case 65:
    189            case IDENTIFIER:
    190            case STRING_LITERAL:
    191              ;
    192              break;
    193            default:
    194              jj_la1[3] = jj_gen;
    195              break label_2;
    196            }
    197            Statement();
    198          }
    199          jj_consume_token(RCURLY);
    200        } catch (Throwable jjte000) {
    201          if (jjtc000) {
    202            jjtree.clearNodeScope(jjtn000);
    203            jjtc000 = false;
    204          } else {
    205            jjtree.popNode();
    206          }
    207          if (jjte000 instanceof RuntimeException) {
    208            {if (true) throw (RuntimeException)jjte000;}
    209          }
    210          if (jjte000 instanceof ParseException) {
    211            {if (true) throw (ParseException)jjte000;}
    212          }
    213          {if (true) throw (Error)jjte000;}
    214        } finally {
    215          if (jjtc000) {
    216            jjtree.closeNodeScope(jjtn000, true);
    217            jjtreeCloseNodeScope(jjtn000);
    218          }
    219        }
    220      }
    221
    222      final public void ExpressionStatement() throws ParseException {
    223        Expression();
    224        label_3:
    225        while (true) {
    226          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    227          case INTEGER_LITERAL:
    228          case FLOAT_LITERAL:
    229          case NEW:
    230          case EMPTY:
    231          case SIZE:
    232          case NULL:
    233          case TRUE:
    234          case FALSE:
    235          case LPAREN:
    236          case LCURLY:
    237          case LBRACKET:
    238          case 57:
    239          case 63:
    240          case 64:
    241          case 65:
    242          case IDENTIFIER:
    243          case STRING_LITERAL:
    244            ;
    245            break;
    246          default:
    247            jj_la1[4] = jj_gen;
    248            break label_3;
    249          }
    250                                     ASTAmbiguous jjtn001 = new ASTAmbiguous(JJTAMBIGUOUS);
    251                                     boolean jjtc001 = true;
    252                                     jjtree.openNodeScope(jjtn001);
    253                                     jjtreeOpenNodeScope(jjtn001);
    254          try {
    255            Expression();
    256          } catch (Throwable jjte001) {
    257                                     if (jjtc001) {
    258                                       jjtree.clearNodeScope(jjtn001);
    259                                       jjtc001 = false;
    260                                     } else {
    261                                       jjtree.popNode();
    262                                     }
    263                                     if (jjte001 instanceof RuntimeException) {
    264                                       {if (true) throw (RuntimeException)jjte001;}
    265                                     }
    266                                     if (jjte001 instanceof ParseException) {
    267                                       {if (true) throw (ParseException)jjte001;}
    268                                     }
    269                                     {if (true) throw (Error)jjte001;}
    270          } finally {
    271                                     if (jjtc001) {
    272                                       jjtree.closeNodeScope(jjtn001, true);
    273                                       jjtreeCloseNodeScope(jjtn001);
    274                                     }
    275          }
    276        }
    277        if (jj_2_2(2)) {
    278          jj_consume_token(SEMICOL);
    279        } else {
    280          ;
    281        }
    282      }
    283
    284      final public void IfStatement() throws ParseException {
    285                          /*@bgen(jjtree) IfStatement */
    286      ASTIfStatement jjtn000 = new ASTIfStatement(JJTIFSTATEMENT);
    287      boolean jjtc000 = true;
    288      jjtree.openNodeScope(jjtn000);
    289      jjtreeOpenNodeScope(jjtn000);
    290        try {
    291          jj_consume_token(IF);
    292          jj_consume_token(LPAREN);
    293          Expression();
    294          jj_consume_token(RPAREN);
    295          Statement();
    296          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    297          case ELSE:
    298            jj_consume_token(ELSE);
    299            Statement();
    300            break;
    301          default:
    302            jj_la1[5] = jj_gen;
    303            ;
    304          }
    305        } catch (Throwable jjte000) {
    306          if (jjtc000) {
    307            jjtree.clearNodeScope(jjtn000);
    308            jjtc000 = false;
    309          } else {
    310            jjtree.popNode();
    311          }
    312          if (jjte000 instanceof RuntimeException) {
    313            {if (true) throw (RuntimeException)jjte000;}
    314          }
    315          if (jjte000 instanceof ParseException) {
    316            {if (true) throw (ParseException)jjte000;}
    317          }
    318          {if (true) throw (Error)jjte000;}
    319        } finally {
    320          if (jjtc000) {
    321            jjtree.closeNodeScope(jjtn000, true);
    322            jjtreeCloseNodeScope(jjtn000);
    323          }
    324        }
    325      }
    326
    327      final public void WhileStatement() throws ParseException {
    328                             /*@bgen(jjtree) WhileStatement */
    329      ASTWhileStatement jjtn000 = new ASTWhileStatement(JJTWHILESTATEMENT);
    330      boolean jjtc000 = true;
    331      jjtree.openNodeScope(jjtn000);
    332      jjtreeOpenNodeScope(jjtn000);
    333        try {
    334          jj_consume_token(WHILE);
    335          jj_consume_token(LPAREN);
    336          Expression();
    337          jj_consume_token(RPAREN);
    338          Statement();
    339        } catch (Throwable jjte000) {
    340          if (jjtc000) {
    341            jjtree.clearNodeScope(jjtn000);
    342            jjtc000 = false;
    343          } else {
    344            jjtree.popNode();
    345          }
    346          if (jjte000 instanceof RuntimeException) {
    347            {if (true) throw (RuntimeException)jjte000;}
    348          }
    349          if (jjte000 instanceof ParseException) {
    350            {if (true) throw (ParseException)jjte000;}
    351          }
    352          {if (true) throw (Error)jjte000;}
    353        } finally {
    354          if (jjtc000) {
    355            jjtree.closeNodeScope(jjtn000, true);
    356            jjtreeCloseNodeScope(jjtn000);
    357          }
    358        }
    359      }
    360
    361      final public void ForeachStatement() throws ParseException {
    362                               /*@bgen(jjtree) ForeachStatement */
    363      ASTForeachStatement jjtn000 = new ASTForeachStatement(JJTFOREACHSTATEMENT);
    364      boolean jjtc000 = true;
    365      jjtree.openNodeScope(jjtn000);
    366      jjtreeOpenNodeScope(jjtn000);
    367        try {
    368          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    369          case FOR:
    370            jj_consume_token(FOR);
    371            jj_consume_token(LPAREN);
    372            Reference();
    373            jj_consume_token(COLON);
    374            Expression();
    375            jj_consume_token(RPAREN);
    376            Statement();
    377            break;
    378          case FOREACH:
    379            jj_consume_token(FOREACH);
    380            jj_consume_token(LPAREN);
    381            Reference();
    382            jj_consume_token(IN);
    383            Expression();
    384            jj_consume_token(RPAREN);
    385            Statement();
    386            break;
    387          default:
    388            jj_la1[6] = jj_gen;
    389            jj_consume_token(-1);
    390            throw new ParseException();
    391          }
    392        } catch (Throwable jjte000) {
    393          if (jjtc000) {
    394            jjtree.clearNodeScope(jjtn000);
    395            jjtc000 = false;
    396          } else {
    397            jjtree.popNode();
    398          }
    399          if (jjte000 instanceof RuntimeException) {
    400            {if (true) throw (RuntimeException)jjte000;}
    401          }
    402          if (jjte000 instanceof ParseException) {
    403            {if (true) throw (ParseException)jjte000;}
    404          }
    405          {if (true) throw (Error)jjte000;}
    406        } finally {
    407          if (jjtc000) {
    408            jjtree.closeNodeScope(jjtn000, true);
    409            jjtreeCloseNodeScope(jjtn000);
    410          }
    411        }
    412      }
    413
    414    /***************************************
    415     *      Expression syntax
    416     ***************************************/
    417      final public void Expression() throws ParseException {
    418        if (jj_2_3(2147483647)) {
    419          Assignment();
    420        } else {
    421          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    422          case INTEGER_LITERAL:
    423          case FLOAT_LITERAL:
    424          case NEW:
    425          case EMPTY:
    426          case SIZE:
    427          case NULL:
    428          case TRUE:
    429          case FALSE:
    430          case LPAREN:
    431          case LCURLY:
    432          case LBRACKET:
    433          case 57:
    434          case 63:
    435          case 64:
    436          case 65:
    437          case IDENTIFIER:
    438          case STRING_LITERAL:
    439            ConditionalExpression();
    440            break;
    441          default:
    442            jj_la1[7] = jj_gen;
    443            jj_consume_token(-1);
    444            throw new ParseException();
    445          }
    446        }
    447      }
    448
    449      final public void Assignment() throws ParseException {
    450                                        /*@bgen(jjtree) #Assignment( 2) */
    451      ASTAssignment jjtn000 = new ASTAssignment(JJTASSIGNMENT);
    452      boolean jjtc000 = true;
    453      jjtree.openNodeScope(jjtn000);
    454      jjtreeOpenNodeScope(jjtn000);
    455        try {
    456          Reference();
    457          jj_consume_token(32);
    458          Expression();
    459        } catch (Throwable jjte000) {
    460          if (jjtc000) {
    461            jjtree.clearNodeScope(jjtn000);
    462            jjtc000 = false;
    463          } else {
    464            jjtree.popNode();
    465          }
    466          if (jjte000 instanceof RuntimeException) {
    467            {if (true) throw (RuntimeException)jjte000;}
    468          }
    469          if (jjte000 instanceof ParseException) {
    470            {if (true) throw (ParseException)jjte000;}
    471          }
    472          {if (true) throw (Error)jjte000;}
    473        } finally {
    474          if (jjtc000) {
    475            jjtree.closeNodeScope(jjtn000,  2);
    476            jjtreeCloseNodeScope(jjtn000);
    477          }
    478        }
    479      }
    480
    481    /***************************************
    482     *      Conditional & relational
    483     ***************************************/
    484      final public void ConditionalExpression() throws ParseException {
    485        ConditionalOrExpression();
    486        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    487        case 33:
    488        case 34:
    489          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    490          case 33:
    491            jj_consume_token(33);
    492            Expression();
    493            jj_consume_token(COLON);
    494                                   ASTTernaryNode jjtn001 = new ASTTernaryNode(JJTTERNARYNODE);
    495                                   boolean jjtc001 = true;
    496                                   jjtree.openNodeScope(jjtn001);
    497                                   jjtreeOpenNodeScope(jjtn001);
    498            try {
    499              Expression();
    500            } catch (Throwable jjte001) {
    501                                   if (jjtc001) {
    502                                     jjtree.clearNodeScope(jjtn001);
    503                                     jjtc001 = false;
    504                                   } else {
    505                                     jjtree.popNode();
    506                                   }
    507                                   if (jjte001 instanceof RuntimeException) {
    508                                     {if (true) throw (RuntimeException)jjte001;}
    509                                   }
    510                                   if (jjte001 instanceof ParseException) {
    511                                     {if (true) throw (ParseException)jjte001;}
    512                                   }
    513                                   {if (true) throw (Error)jjte001;}
    514            } finally {
    515                                   if (jjtc001) {
    516                                     jjtree.closeNodeScope(jjtn001,  3);
    517                                     jjtreeCloseNodeScope(jjtn001);
    518                                   }
    519            }
    520            break;
    521          case 34:
    522            jj_consume_token(34);
    523               ASTTernaryNode jjtn002 = new ASTTernaryNode(JJTTERNARYNODE);
    524               boolean jjtc002 = true;
    525               jjtree.openNodeScope(jjtn002);
    526               jjtreeOpenNodeScope(jjtn002);
    527            try {
    528              Expression();
    529            } catch (Throwable jjte002) {
    530               if (jjtc002) {
    531                 jjtree.clearNodeScope(jjtn002);
    532                 jjtc002 = false;
    533               } else {
    534                 jjtree.popNode();
    535               }
    536               if (jjte002 instanceof RuntimeException) {
    537                 {if (true) throw (RuntimeException)jjte002;}
    538               }
    539               if (jjte002 instanceof ParseException) {
    540                 {if (true) throw (ParseException)jjte002;}
    541               }
    542               {if (true) throw (Error)jjte002;}
    543            } finally {
    544               if (jjtc002) {
    545                 jjtree.closeNodeScope(jjtn002,  2);
    546                 jjtreeCloseNodeScope(jjtn002);
    547               }
    548            }
    549            break;
    550          default:
    551            jj_la1[8] = jj_gen;
    552            jj_consume_token(-1);
    553            throw new ParseException();
    554          }
    555          break;
    556        default:
    557          jj_la1[9] = jj_gen;
    558          ;
    559        }
    560      }
    561
    562      final public void ConditionalOrExpression() throws ParseException {
    563        ConditionalAndExpression();
    564        label_4:
    565        while (true) {
    566          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    567          case 35:
    568          case 36:
    569            ;
    570            break;
    571          default:
    572            jj_la1[10] = jj_gen;
    573            break label_4;
    574          }
    575          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    576          case 35:
    577            jj_consume_token(35);
    578               ASTOrNode jjtn001 = new ASTOrNode(JJTORNODE);
    579               boolean jjtc001 = true;
    580               jjtree.openNodeScope(jjtn001);
    581               jjtreeOpenNodeScope(jjtn001);
    582            try {
    583              ConditionalAndExpression();
    584            } catch (Throwable jjte001) {
    585               if (jjtc001) {
    586                 jjtree.clearNodeScope(jjtn001);
    587                 jjtc001 = false;
    588               } else {
    589                 jjtree.popNode();
    590               }
    591               if (jjte001 instanceof RuntimeException) {
    592                 {if (true) throw (RuntimeException)jjte001;}
    593               }
    594               if (jjte001 instanceof ParseException) {
    595                 {if (true) throw (ParseException)jjte001;}
    596               }
    597               {if (true) throw (Error)jjte001;}
    598            } finally {
    599               if (jjtc001) {
    600                 jjtree.closeNodeScope(jjtn001,  2);
    601                 jjtreeCloseNodeScope(jjtn001);
    602               }
    603            }
    604            break;
    605          case 36:
    606            jj_consume_token(36);
    607               ASTOrNode jjtn002 = new ASTOrNode(JJTORNODE);
    608               boolean jjtc002 = true;
    609               jjtree.openNodeScope(jjtn002);
    610               jjtreeOpenNodeScope(jjtn002);
    611            try {
    612              ConditionalAndExpression();
    613            } catch (Throwable jjte002) {
    614               if (jjtc002) {
    615                 jjtree.clearNodeScope(jjtn002);
    616                 jjtc002 = false;
    617               } else {
    618                 jjtree.popNode();
    619               }
    620               if (jjte002 instanceof RuntimeException) {
    621                 {if (true) throw (RuntimeException)jjte002;}
    622               }
    623               if (jjte002 instanceof ParseException) {
    624                 {if (true) throw (ParseException)jjte002;}
    625               }
    626               {if (true) throw (Error)jjte002;}
    627            } finally {
    628               if (jjtc002) {
    629                 jjtree.closeNodeScope(jjtn002,  2);
    630                 jjtreeCloseNodeScope(jjtn002);
    631               }
    632            }
    633            break;
    634          default:
    635            jj_la1[11] = jj_gen;
    636            jj_consume_token(-1);
    637            throw new ParseException();
    638          }
    639        }
    640      }
    641
    642      final public void ConditionalAndExpression() throws ParseException {
    643        InclusiveOrExpression();
    644        label_5:
    645        while (true) {
    646          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    647          case 37:
    648          case 38:
    649            ;
    650            break;
    651          default:
    652            jj_la1[12] = jj_gen;
    653            break label_5;
    654          }
    655          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    656          case 37:
    657            jj_consume_token(37);
    658               ASTAndNode jjtn001 = new ASTAndNode(JJTANDNODE);
    659               boolean jjtc001 = true;
    660               jjtree.openNodeScope(jjtn001);
    661               jjtreeOpenNodeScope(jjtn001);
    662            try {
    663              InclusiveOrExpression();
    664            } catch (Throwable jjte001) {
    665               if (jjtc001) {
    666                 jjtree.clearNodeScope(jjtn001);
    667                 jjtc001 = false;
    668               } else {
    669                 jjtree.popNode();
    670               }
    671               if (jjte001 instanceof RuntimeException) {
    672                 {if (true) throw (RuntimeException)jjte001;}
    673               }
    674               if (jjte001 instanceof ParseException) {
    675                 {if (true) throw (ParseException)jjte001;}
    676               }
    677               {if (true) throw (Error)jjte001;}
    678            } finally {
    679               if (jjtc001) {
    680                 jjtree.closeNodeScope(jjtn001,  2);
    681                 jjtreeCloseNodeScope(jjtn001);
    682               }
    683            }
    684            break;
    685          case 38:
    686            jj_consume_token(38);
    687                ASTAndNode jjtn002 = new ASTAndNode(JJTANDNODE);
    688                boolean jjtc002 = true;
    689                jjtree.openNodeScope(jjtn002);
    690                jjtreeOpenNodeScope(jjtn002);
    691            try {
    692              InclusiveOrExpression();
    693            } catch (Throwable jjte002) {
    694                if (jjtc002) {
    695                  jjtree.clearNodeScope(jjtn002);
    696                  jjtc002 = false;
    697                } else {
    698                  jjtree.popNode();
    699                }
    700                if (jjte002 instanceof RuntimeException) {
    701                  {if (true) throw (RuntimeException)jjte002;}
    702                }
    703                if (jjte002 instanceof ParseException) {
    704                  {if (true) throw (ParseException)jjte002;}
    705                }
    706                {if (true) throw (Error)jjte002;}
    707            } finally {
    708                if (jjtc002) {
    709                  jjtree.closeNodeScope(jjtn002,  2);
    710                  jjtreeCloseNodeScope(jjtn002);
    711                }
    712            }
    713            break;
    714          default:
    715            jj_la1[13] = jj_gen;
    716            jj_consume_token(-1);
    717            throw new ParseException();
    718          }
    719        }
    720      }
    721
    722      final public void InclusiveOrExpression() throws ParseException {
    723        ExclusiveOrExpression();
    724        label_6:
    725        while (true) {
    726          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    727          case 39:
    728            ;
    729            break;
    730          default:
    731            jj_la1[14] = jj_gen;
    732            break label_6;
    733          }
    734          jj_consume_token(39);
    735              ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(JJTBITWISEORNODE);
    736              boolean jjtc001 = true;
    737              jjtree.openNodeScope(jjtn001);
    738              jjtreeOpenNodeScope(jjtn001);
    739          try {
    740            ExclusiveOrExpression();
    741          } catch (Throwable jjte001) {
    742              if (jjtc001) {
    743                jjtree.clearNodeScope(jjtn001);
    744                jjtc001 = false;
    745              } else {
    746                jjtree.popNode();
    747              }
    748              if (jjte001 instanceof RuntimeException) {
    749                {if (true) throw (RuntimeException)jjte001;}
    750              }
    751              if (jjte001 instanceof ParseException) {
    752                {if (true) throw (ParseException)jjte001;}
    753              }
    754              {if (true) throw (Error)jjte001;}
    755          } finally {
    756              if (jjtc001) {
    757                jjtree.closeNodeScope(jjtn001,  2);
    758                jjtreeCloseNodeScope(jjtn001);
    759              }
    760          }
    761        }
    762      }
    763
    764      final public void ExclusiveOrExpression() throws ParseException {
    765        AndExpression();
    766        label_7:
    767        while (true) {
    768          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    769          case 40:
    770            ;
    771            break;
    772          default:
    773            jj_la1[15] = jj_gen;
    774            break label_7;
    775          }
    776          jj_consume_token(40);
    777              ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(JJTBITWISEXORNODE);
    778              boolean jjtc001 = true;
    779              jjtree.openNodeScope(jjtn001);
    780              jjtreeOpenNodeScope(jjtn001);
    781          try {
    782            AndExpression();
    783          } catch (Throwable jjte001) {
    784              if (jjtc001) {
    785                jjtree.clearNodeScope(jjtn001);
    786                jjtc001 = false;
    787              } else {
    788                jjtree.popNode();
    789              }
    790              if (jjte001 instanceof RuntimeException) {
    791                {if (true) throw (RuntimeException)jjte001;}
    792              }
    793              if (jjte001 instanceof ParseException) {
    794                {if (true) throw (ParseException)jjte001;}
    795              }
    796              {if (true) throw (Error)jjte001;}
    797          } finally {
    798              if (jjtc001) {
    799                jjtree.closeNodeScope(jjtn001,  2);
    800                jjtreeCloseNodeScope(jjtn001);
    801              }
    802          }
    803        }
    804      }
    805
    806      final public void AndExpression() throws ParseException {
    807        EqualityExpression();
    808        label_8:
    809        while (true) {
    810          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    811          case 41:
    812            ;
    813            break;
    814          default:
    815            jj_la1[16] = jj_gen;
    816            break label_8;
    817          }
    818          jj_consume_token(41);
    819              ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(JJTBITWISEANDNODE);
    820              boolean jjtc001 = true;
    821              jjtree.openNodeScope(jjtn001);
    822              jjtreeOpenNodeScope(jjtn001);
    823          try {
    824            EqualityExpression();
    825          } catch (Throwable jjte001) {
    826              if (jjtc001) {
    827                jjtree.clearNodeScope(jjtn001);
    828                jjtc001 = false;
    829              } else {
    830                jjtree.popNode();
    831              }
    832              if (jjte001 instanceof RuntimeException) {
    833                {if (true) throw (RuntimeException)jjte001;}
    834              }
    835              if (jjte001 instanceof ParseException) {
    836                {if (true) throw (ParseException)jjte001;}
    837              }
    838              {if (true) throw (Error)jjte001;}
    839          } finally {
    840              if (jjtc001) {
    841                jjtree.closeNodeScope(jjtn001,  2);
    842                jjtreeCloseNodeScope(jjtn001);
    843              }
    844          }
    845        }
    846      }
    847
    848      final public void EqualityExpression() throws ParseException {
    849        RelationalExpression();
    850        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    851        case 42:
    852        case 43:
    853        case 44:
    854        case 45:
    855          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    856          case 42:
    857            jj_consume_token(42);
    858                ASTEQNode jjtn001 = new ASTEQNode(JJTEQNODE);
    859                boolean jjtc001 = true;
    860                jjtree.openNodeScope(jjtn001);
    861                jjtreeOpenNodeScope(jjtn001);
    862            try {
    863              RelationalExpression();
    864            } catch (Throwable jjte001) {
    865                if (jjtc001) {
    866                  jjtree.clearNodeScope(jjtn001);
    867                  jjtc001 = false;
    868                } else {
    869                  jjtree.popNode();
    870                }
    871                if (jjte001 instanceof RuntimeException) {
    872                  {if (true) throw (RuntimeException)jjte001;}
    873                }
    874                if (jjte001 instanceof ParseException) {
    875                  {if (true) throw (ParseException)jjte001;}
    876                }
    877                {if (true) throw (Error)jjte001;}
    878            } finally {
    879                if (jjtc001) {
    880                  jjtree.closeNodeScope(jjtn001,  2);
    881                  jjtreeCloseNodeScope(jjtn001);
    882                }
    883            }
    884            break;
    885          case 43:
    886            jj_consume_token(43);
    887                ASTEQNode jjtn002 = new ASTEQNode(JJTEQNODE);
    888                boolean jjtc002 = true;
    889                jjtree.openNodeScope(jjtn002);
    890                jjtreeOpenNodeScope(jjtn002);
    891            try {
    892              RelationalExpression();
    893            } catch (Throwable jjte002) {
    894                if (jjtc002) {
    895                  jjtree.clearNodeScope(jjtn002);
    896                  jjtc002 = false;
    897                } else {
    898                  jjtree.popNode();
    899                }
    900                if (jjte002 instanceof RuntimeException) {
    901                  {if (true) throw (RuntimeException)jjte002;}
    902                }
    903                if (jjte002 instanceof ParseException) {
    904                  {if (true) throw (ParseException)jjte002;}
    905                }
    906                {if (true) throw (Error)jjte002;}
    907            } finally {
    908                if (jjtc002) {
    909                  jjtree.closeNodeScope(jjtn002,  2);
    910                  jjtreeCloseNodeScope(jjtn002);
    911                }
    912            }
    913            break;
    914          case 44:
    915            jj_consume_token(44);
    916                ASTNENode jjtn003 = new ASTNENode(JJTNENODE);
    917                boolean jjtc003 = true;
    918                jjtree.openNodeScope(jjtn003);
    919                jjtreeOpenNodeScope(jjtn003);
    920            try {
    921              RelationalExpression();
    922            } catch (Throwable jjte003) {
    923                if (jjtc003) {
    924                  jjtree.clearNodeScope(jjtn003);
    925                  jjtc003 = false;
    926                } else {
    927                  jjtree.popNode();
    928                }
    929                if (jjte003 instanceof RuntimeException) {
    930                  {if (true) throw (RuntimeException)jjte003;}
    931                }
    932                if (jjte003 instanceof ParseException) {
    933                  {if (true) throw (ParseException)jjte003;}
    934                }
    935                {if (true) throw (Error)jjte003;}
    936            } finally {
    937                if (jjtc003) {
    938                  jjtree.closeNodeScope(jjtn003,  2);
    939                  jjtreeCloseNodeScope(jjtn003);
    940                }
    941            }
    942            break;
    943          case 45:
    944            jj_consume_token(45);
    945                ASTNENode jjtn004 = new ASTNENode(JJTNENODE);
    946                boolean jjtc004 = true;
    947                jjtree.openNodeScope(jjtn004);
    948                jjtreeOpenNodeScope(jjtn004);
    949            try {
    950              RelationalExpression();
    951            } catch (Throwable jjte004) {
    952                if (jjtc004) {
    953                  jjtree.clearNodeScope(jjtn004);
    954                  jjtc004 = false;
    955                } else {
    956                  jjtree.popNode();
    957                }
    958                if (jjte004 instanceof RuntimeException) {
    959                  {if (true) throw (RuntimeException)jjte004;}
    960                }
    961                if (jjte004 instanceof ParseException) {
    962                  {if (true) throw (ParseException)jjte004;}
    963                }
    964                {if (true) throw (Error)jjte004;}
    965            } finally {
    966                if (jjtc004) {
    967                  jjtree.closeNodeScope(jjtn004,  2);
    968                  jjtreeCloseNodeScope(jjtn004);
    969                }
    970            }
    971            break;
    972          default:
    973            jj_la1[17] = jj_gen;
    974            jj_consume_token(-1);
    975            throw new ParseException();
    976          }
    977          break;
    978        default:
    979          jj_la1[18] = jj_gen;
    980          ;
    981        }
    982      }
    983
    984      final public void RelationalExpression() throws ParseException {
    985        AdditiveExpression();
    986        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    987        case 46:
    988        case 47:
    989        case 48:
    990        case 49:
    991        case 50:
    992        case 51:
    993        case 52:
    994        case 53:
    995        case 54:
    996        case 55:
    997          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    998          case 46:
    999            jj_consume_token(46);
    1000              ASTLTNode jjtn001 = new ASTLTNode(JJTLTNODE);
    1001              boolean jjtc001 = true;
    1002              jjtree.openNodeScope(jjtn001);
    1003              jjtreeOpenNodeScope(jjtn001);
    1004            try {
    1005              AdditiveExpression();
    1006            } catch (Throwable jjte001) {
    1007              if (jjtc001) {
    1008                jjtree.clearNodeScope(jjtn001);
    1009                jjtc001 = false;
    1010              } else {
    1011                jjtree.popNode();
    1012              }
    1013              if (jjte001 instanceof RuntimeException) {
    1014                {if (true) throw (RuntimeException)jjte001;}
    1015              }
    1016              if (jjte001 instanceof ParseException) {
    1017                {if (true) throw (ParseException)jjte001;}
    1018              }
    1019              {if (true) throw (Error)jjte001;}
    1020            } finally {
    1021              if (jjtc001) {
    1022                jjtree.closeNodeScope(jjtn001,  2);
    1023                jjtreeCloseNodeScope(jjtn001);
    1024              }
    1025            }
    1026            break;
    1027          case 47:
    1028            jj_consume_token(47);
    1029               ASTLTNode jjtn002 = new ASTLTNode(JJTLTNODE);
    1030               boolean jjtc002 = true;
    1031               jjtree.openNodeScope(jjtn002);
    1032               jjtreeOpenNodeScope(jjtn002);
    1033            try {
    1034              AdditiveExpression();
    1035            } catch (Throwable jjte002) {
    1036               if (jjtc002) {
    1037                 jjtree.clearNodeScope(jjtn002);
    1038                 jjtc002 = false;
    1039               } else {
    1040                 jjtree.popNode();
    1041               }
    1042               if (jjte002 instanceof RuntimeException) {
    1043                 {if (true) throw (RuntimeException)jjte002;}
    1044               }
    1045               if (jjte002 instanceof ParseException) {
    1046                 {if (true) throw (ParseException)jjte002;}
    1047               }
    1048               {if (true) throw (Error)jjte002;}
    1049            } finally {
    1050               if (jjtc002) {
    1051                 jjtree.closeNodeScope(jjtn002,  2);
    1052                 jjtreeCloseNodeScope(jjtn002);
    1053               }
    1054            }
    1055            break;
    1056          case 48:
    1057            jj_consume_token(48);
    1058              ASTGTNode jjtn003 = new ASTGTNode(JJTGTNODE);
    1059              boolean jjtc003 = true;
    1060              jjtree.openNodeScope(jjtn003);
    1061              jjtreeOpenNodeScope(jjtn003);
    1062            try {
    1063              AdditiveExpression();
    1064            } catch (Throwable jjte003) {
    1065              if (jjtc003) {
    1066                jjtree.clearNodeScope(jjtn003);
    1067                jjtc003 = false;
    1068              } else {
    1069                jjtree.popNode();
    1070              }
    1071              if (jjte003 instanceof RuntimeException) {
    1072                {if (true) throw (RuntimeException)jjte003;}
    1073              }
    1074              if (jjte003 instanceof ParseException) {
    1075                {if (true) throw (ParseException)jjte003;}
    1076              }
    1077              {if (true) throw (Error)jjte003;}
    1078            } finally {
    1079              if (jjtc003) {
    1080                jjtree.closeNodeScope(jjtn003,  2);
    1081                jjtreeCloseNodeScope(jjtn003);
    1082              }
    1083            }
    1084            break;
    1085          case 49:
    1086            jj_consume_token(49);
    1087               ASTGTNode jjtn004 = new ASTGTNode(JJTGTNODE);
    1088               boolean jjtc004 = true;
    1089               jjtree.openNodeScope(jjtn004);
    1090               jjtreeOpenNodeScope(jjtn004);
    1091            try {
    1092              AdditiveExpression();
    1093            } catch (Throwable jjte004) {
    1094               if (jjtc004) {
    1095                 jjtree.clearNodeScope(jjtn004);
    1096                 jjtc004 = false;
    1097               } else {
    1098                 jjtree.popNode();
    1099               }
    1100               if (jjte004 instanceof RuntimeException) {
    1101                 {if (true) throw (RuntimeException)jjte004;}
    1102               }
    1103               if (jjte004 instanceof ParseException) {
    1104                 {if (true) throw (ParseException)jjte004;}
    1105               }
    1106               {if (true) throw (Error)jjte004;}
    1107            } finally {
    1108               if (jjtc004) {
    1109                 jjtree.closeNodeScope(jjtn004,  2);
    1110                 jjtreeCloseNodeScope(jjtn004);
    1111               }
    1112            }
    1113            break;
    1114          case 50:
    1115            jj_consume_token(50);
    1116               ASTLENode jjtn005 = new ASTLENode(JJTLENODE);
    1117               boolean jjtc005 = true;
    1118               jjtree.openNodeScope(jjtn005);
    1119               jjtreeOpenNodeScope(jjtn005);
    1120            try {
    1121              AdditiveExpression();
    1122            } catch (Throwable jjte005) {
    1123               if (jjtc005) {
    1124                 jjtree.clearNodeScope(jjtn005);
    1125                 jjtc005 = false;
    1126               } else {
    1127                 jjtree.popNode();
    1128               }
    1129               if (jjte005 instanceof RuntimeException) {
    1130                 {if (true) throw (RuntimeException)jjte005;}
    1131               }
    1132               if (jjte005 instanceof ParseException) {
    1133                 {if (true) throw (ParseException)jjte005;}
    1134               }
    1135               {if (true) throw (Error)jjte005;}
    1136            } finally {
    1137               if (jjtc005) {
    1138                 jjtree.closeNodeScope(jjtn005,  2);
    1139                 jjtreeCloseNodeScope(jjtn005);
    1140               }
    1141            }
    1142            break;
    1143          case 51:
    1144            jj_consume_token(51);
    1145               ASTLENode jjtn006 = new ASTLENode(JJTLENODE);
    1146               boolean jjtc006 = true;
    1147               jjtree.openNodeScope(jjtn006);
    1148               jjtreeOpenNodeScope(jjtn006);
    1149            try {
    1150              AdditiveExpression();
    1151            } catch (Throwable jjte006) {
    1152               if (jjtc006) {
    1153                 jjtree.clearNodeScope(jjtn006);
    1154                 jjtc006 = false;
    1155               } else {
    1156                 jjtree.popNode();
    1157               }
    1158               if (jjte006 instanceof RuntimeException) {
    1159                 {if (true) throw (RuntimeException)jjte006;}
    1160               }
    1161               if (jjte006 instanceof ParseException) {
    1162                 {if (true) throw (ParseException)jjte006;}
    1163               }
    1164               {if (true) throw (Error)jjte006;}
    1165            } finally {
    1166               if (jjtc006) {
    1167                 jjtree.closeNodeScope(jjtn006,  2);
    1168                 jjtreeCloseNodeScope(jjtn006);
    1169               }
    1170            }
    1171            break;
    1172          case 52:
    1173            jj_consume_token(52);
    1174               ASTGENode jjtn007 = new ASTGENode(JJTGENODE);
    1175               boolean jjtc007 = true;
    1176               jjtree.openNodeScope(jjtn007);
    1177               jjtreeOpenNodeScope(jjtn007);
    1178            try {
    1179              AdditiveExpression();
    1180            } catch (Throwable jjte007) {
    1181               if (jjtc007) {
    1182                 jjtree.clearNodeScope(jjtn007);
    1183                 jjtc007 = false;
    1184               } else {
    1185                 jjtree.popNode();
    1186               }
    1187               if (jjte007 instanceof RuntimeException) {
    1188                 {if (true) throw (RuntimeException)jjte007;}
    1189               }
    1190               if (jjte007 instanceof ParseException) {
    1191                 {if (true) throw (ParseException)jjte007;}
    1192               }
    1193               {if (true) throw (Error)jjte007;}
    1194            } finally {
    1195               if (jjtc007) {
    1196                 jjtree.closeNodeScope(jjtn007,  2);
    1197                 jjtreeCloseNodeScope(jjtn007);
    1198               }
    1199            }
    1200            break;
    1201          case 53:
    1202            jj_consume_token(53);
    1203               ASTGENode jjtn008 = new ASTGENode(JJTGENODE);
    1204               boolean jjtc008 = true;
    1205               jjtree.openNodeScope(jjtn008);
    1206               jjtreeOpenNodeScope(jjtn008);
    1207            try {
    1208              AdditiveExpression();
    1209            } catch (Throwable jjte008) {
    1210               if (jjtc008) {
    1211                 jjtree.clearNodeScope(jjtn008);
    1212                 jjtc008 = false;
    1213               } else {
    1214                 jjtree.popNode();
    1215               }
    1216               if (jjte008 instanceof RuntimeException) {
    1217                 {if (true) throw (RuntimeException)jjte008;}
    1218               }
    1219               if (jjte008 instanceof ParseException) {
    1220                 {if (true) throw (ParseException)jjte008;}
    1221               }
    1222               {if (true) throw (Error)jjte008;}
    1223            } finally {
    1224               if (jjtc008) {
    1225                 jjtree.closeNodeScope(jjtn008,  2);
    1226                 jjtreeCloseNodeScope(jjtn008);
    1227               }
    1228            }
    1229            break;
    1230          case 54:
    1231            jj_consume_token(54);
    1232               ASTERNode jjtn009 = new ASTERNode(JJTERNODE);
    1233               boolean jjtc009 = true;
    1234               jjtree.openNodeScope(jjtn009);
    1235               jjtreeOpenNodeScope(jjtn009);
    1236            try {
    1237              AdditiveExpression();
    1238            } catch (Throwable jjte009) {
    1239               if (jjtc009) {
    1240                 jjtree.clearNodeScope(jjtn009);
    1241                 jjtc009 = false;
    1242               } else {
    1243                 jjtree.popNode();
    1244               }
    1245               if (jjte009 instanceof RuntimeException) {
    1246                 {if (true) throw (RuntimeException)jjte009;}
    1247               }
    1248               if (jjte009 instanceof ParseException) {
    1249                 {if (true) throw (ParseException)jjte009;}
    1250               }
    1251               {if (true) throw (Error)jjte009;}
    1252            } finally {
    1253               if (jjtc009) {
    1254                 jjtree.closeNodeScope(jjtn009,  2);
    1255                 jjtreeCloseNodeScope(jjtn009);
    1256               }
    1257            }
    1258            break;
    1259          case 55:
    1260            jj_consume_token(55);
    1261               ASTNRNode jjtn010 = new ASTNRNode(JJTNRNODE);
    1262               boolean jjtc010 = true;
    1263               jjtree.openNodeScope(jjtn010);
    1264               jjtreeOpenNodeScope(jjtn010);
    1265            try {
    1266              AdditiveExpression();
    1267            } catch (Throwable jjte010) {
    1268               if (jjtc010) {
    1269                 jjtree.clearNodeScope(jjtn010);
    1270                 jjtc010 = false;
    1271               } else {
    1272                 jjtree.popNode();
    1273               }
    1274               if (jjte010 instanceof RuntimeException) {
    1275                 {if (true) throw (RuntimeException)jjte010;}
    1276               }
    1277               if (jjte010 instanceof ParseException) {
    1278                 {if (true) throw (ParseException)jjte010;}
    1279               }
    1280               {if (true) throw (Error)jjte010;}
    1281            } finally {
    1282               if (jjtc010) {
    1283                 jjtree.closeNodeScope(jjtn010,  2);
    1284                 jjtreeCloseNodeScope(jjtn010);
    1285               }
    1286            }
    1287            break;
    1288          default:
    1289            jj_la1[19] = jj_gen;
    1290            jj_consume_token(-1);
    1291            throw new ParseException();
    1292          }
    1293          break;
    1294        default:
    1295          jj_la1[20] = jj_gen;
    1296          ;
    1297        }
    1298      }
    1299
    1300    /***************************************
    1301     *      Arithmetic
    1302     ***************************************/
    1303      final public void AdditiveExpression() throws ParseException {
    1304                                                   /*@bgen(jjtree) #AdditiveNode(> 1) */
    1305      ASTAdditiveNode jjtn000 = new ASTAdditiveNode(JJTADDITIVENODE);
    1306      boolean jjtc000 = true;
    1307      jjtree.openNodeScope(jjtn000);
    1308      jjtreeOpenNodeScope(jjtn000);
    1309        try {
    1310          MultiplicativeExpression();
    1311          label_9:
    1312          while (true) {
    1313            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1314            case 56:
    1315            case 57:
    1316              ;
    1317              break;
    1318            default:
    1319              jj_la1[21] = jj_gen;
    1320              break label_9;
    1321            }
    1322            AdditiveOperator();
    1323            MultiplicativeExpression();
    1324          }
    1325        } catch (Throwable jjte000) {
    1326          if (jjtc000) {
    1327            jjtree.clearNodeScope(jjtn000);
    1328            jjtc000 = false;
    1329          } else {
    1330            jjtree.popNode();
    1331          }
    1332          if (jjte000 instanceof RuntimeException) {
    1333            {if (true) throw (RuntimeException)jjte000;}
    1334          }
    1335          if (jjte000 instanceof ParseException) {
    1336            {if (true) throw (ParseException)jjte000;}
    1337          }
    1338          {if (true) throw (Error)jjte000;}
    1339        } finally {
    1340          if (jjtc000) {
    1341            jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
    1342            jjtreeCloseNodeScope(jjtn000);
    1343          }
    1344        }
    1345      }
    1346
    1347      final public void AdditiveOperator() throws ParseException {
    1348                               /*@bgen(jjtree) AdditiveOperator */
    1349      ASTAdditiveOperator jjtn000 = new ASTAdditiveOperator(JJTADDITIVEOPERATOR);
    1350      boolean jjtc000 = true;
    1351      jjtree.openNodeScope(jjtn000);
    1352      jjtreeOpenNodeScope(jjtn000);
    1353        try {
    1354          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1355          case 56:
    1356            jj_consume_token(56);
    1357              jjtree.closeNodeScope(jjtn000, true);
    1358              jjtc000 = false;
    1359              jjtreeCloseNodeScope(jjtn000);
    1360              jjtn000.image = "+";
    1361            break;
    1362          case 57:
    1363            jj_consume_token(57);
    1364              jjtree.closeNodeScope(jjtn000, true);
    1365              jjtc000 = false;
    1366              jjtreeCloseNodeScope(jjtn000);
    1367              jjtn000.image = "-";
    1368            break;
    1369          default:
    1370            jj_la1[22] = jj_gen;
    1371            jj_consume_token(-1);
    1372            throw new ParseException();
    1373          }
    1374        } finally {
    1375          if (jjtc000) {
    1376            jjtree.closeNodeScope(jjtn000, true);
    1377            jjtreeCloseNodeScope(jjtn000);
    1378          }
    1379        }
    1380      }
    1381
    1382      final public void MultiplicativeExpression() throws ParseException {
    1383        UnaryExpression();
    1384        label_10:
    1385        while (true) {
    1386          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1387          case 58:
    1388          case 59:
    1389          case 60:
    1390          case 61:
    1391          case 62:
    1392            ;
    1393            break;
    1394          default:
    1395            jj_la1[23] = jj_gen;
    1396            break label_10;
    1397          }
    1398          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1399          case 58:
    1400            jj_consume_token(58);
    1401              ASTMulNode jjtn001 = new ASTMulNode(JJTMULNODE);
    1402              boolean jjtc001 = true;
    1403              jjtree.openNodeScope(jjtn001);
    1404              jjtreeOpenNodeScope(jjtn001);
    1405            try {
    1406              UnaryExpression();
    1407            } catch (Throwable jjte001) {
    1408              if (jjtc001) {
    1409                jjtree.clearNodeScope(jjtn001);
    1410                jjtc001 = false;
    1411              } else {
    1412                jjtree.popNode();
    1413              }
    1414              if (jjte001 instanceof RuntimeException) {
    1415                {if (true) throw (RuntimeException)jjte001;}
    1416              }
    1417              if (jjte001 instanceof ParseException) {
    1418                {if (true) throw (ParseException)jjte001;}
    1419              }
    1420              {if (true) throw (Error)jjte001;}
    1421            } finally {
    1422              if (jjtc001) {
    1423                jjtree.closeNodeScope(jjtn001,  2);
    1424                jjtreeCloseNodeScope(jjtn001);
    1425              }
    1426            }
    1427            break;
    1428          case 59:
    1429            jj_consume_token(59);
    1430              ASTDivNode jjtn002 = new ASTDivNode(JJTDIVNODE);
    1431              boolean jjtc002 = true;
    1432              jjtree.openNodeScope(jjtn002);
    1433              jjtreeOpenNodeScope(jjtn002);
    1434            try {
    1435              UnaryExpression();
    1436            } catch (Throwable jjte002) {
    1437              if (jjtc002) {
    1438                jjtree.clearNodeScope(jjtn002);
    1439                jjtc002 = false;
    1440              } else {
    1441                jjtree.popNode();
    1442              }
    1443              if (jjte002 instanceof RuntimeException) {
    1444                {if (true) throw (RuntimeException)jjte002;}
    1445              }
    1446              if (jjte002 instanceof ParseException) {
    1447                {if (true) throw (ParseException)jjte002;}
    1448              }
    1449              {if (true) throw (Error)jjte002;}
    1450            } finally {
    1451              if (jjtc002) {
    1452                jjtree.closeNodeScope(jjtn002,  2);
    1453                jjtreeCloseNodeScope(jjtn002);
    1454              }
    1455            }
    1456            break;
    1457          case 60:
    1458            jj_consume_token(60);
    1459                ASTDivNode jjtn003 = new ASTDivNode(JJTDIVNODE);
    1460                boolean jjtc003 = true;
    1461                jjtree.openNodeScope(jjtn003);
    1462                jjtreeOpenNodeScope(jjtn003);
    1463            try {
    1464              UnaryExpression();
    1465            } catch (Throwable jjte003) {
    1466                if (jjtc003) {
    1467                  jjtree.clearNodeScope(jjtn003);
    1468                  jjtc003 = false;
    1469                } else {
    1470                  jjtree.popNode();
    1471                }
    1472                if (jjte003 instanceof RuntimeException) {
    1473                  {if (true) throw (RuntimeException)jjte003;}
    1474                }
    1475                if (jjte003 instanceof ParseException) {
    1476                  {if (true) throw (ParseException)jjte003;}
    1477                }
    1478                {if (true) throw (Error)jjte003;}
    1479            } finally {
    1480                if (jjtc003) {
    1481                  jjtree.closeNodeScope(jjtn003,  2);
    1482                  jjtreeCloseNodeScope(jjtn003);
    1483                }
    1484            }
    1485            break;
    1486          case 61:
    1487            jj_consume_token(61);
    1488              ASTModNode jjtn004 = new ASTModNode(JJTMODNODE);
    1489              boolean jjtc004 = true;
    1490              jjtree.openNodeScope(jjtn004);
    1491              jjtreeOpenNodeScope(jjtn004);
    1492            try {
    1493              UnaryExpression();
    1494            } catch (Throwable jjte004) {
    1495              if (jjtc004) {
    1496                jjtree.clearNodeScope(jjtn004);
    1497                jjtc004 = false;
    1498              } else {
    1499                jjtree.popNode();
    1500              }
    1501              if (jjte004 instanceof RuntimeException) {
    1502                {if (true) throw (RuntimeException)jjte004;}
    1503              }
    1504              if (jjte004 instanceof ParseException) {
    1505                {if (true) throw (ParseException)jjte004;}
    1506              }
    1507              {if (true) throw (Error)jjte004;}
    1508            } finally {
    1509              if (jjtc004) {
    1510                jjtree.closeNodeScope(jjtn004,  2);
    1511                jjtreeCloseNodeScope(jjtn004);
    1512              }
    1513            }
    1514            break;
    1515          case 62:
    1516            jj_consume_token(62);
    1517                ASTModNode jjtn005 = new ASTModNode(JJTMODNODE);
    1518                boolean jjtc005 = true;
    1519                jjtree.openNodeScope(jjtn005);
    1520                jjtreeOpenNodeScope(jjtn005);
    1521            try {
    1522              UnaryExpression();
    1523            } catch (Throwable jjte005) {
    1524                if (jjtc005) {
    1525                  jjtree.clearNodeScope(jjtn005);
    1526                  jjtc005 = false;
    1527                } else {
    1528                  jjtree.popNode();
    1529                }
    1530                if (jjte005 instanceof RuntimeException) {
    1531                  {if (true) throw (RuntimeException)jjte005;}
    1532                }
    1533                if (jjte005 instanceof ParseException) {
    1534                  {if (true) throw (ParseException)jjte005;}
    1535                }
    1536                {if (true) throw (Error)jjte005;}
    1537            } finally {
    1538                if (jjtc005) {
    1539                  jjtree.closeNodeScope(jjtn005,  2);
    1540                  jjtreeCloseNodeScope(jjtn005);
    1541                }
    1542            }
    1543            break;
    1544          default:
    1545            jj_la1[24] = jj_gen;
    1546            jj_consume_token(-1);
    1547            throw new ParseException();
    1548          }
    1549        }
    1550      }
    1551
    1552      final public void UnaryExpression() throws ParseException {
    1553        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1554        case 57:
    1555          jj_consume_token(57);
    1556            ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(JJTUNARYMINUSNODE);
    1557            boolean jjtc001 = true;
    1558            jjtree.openNodeScope(jjtn001);
    1559            jjtreeOpenNodeScope(jjtn001);
    1560          try {
    1561            UnaryExpression();
    1562          } catch (Throwable jjte001) {
    1563            if (jjtc001) {
    1564              jjtree.clearNodeScope(jjtn001);
    1565              jjtc001 = false;
    1566            } else {
    1567              jjtree.popNode();
    1568            }
    1569            if (jjte001 instanceof RuntimeException) {
    1570              {if (true) throw (RuntimeException)jjte001;}
    1571            }
    1572            if (jjte001 instanceof ParseException) {
    1573              {if (true) throw (ParseException)jjte001;}
    1574            }
    1575            {if (true) throw (Error)jjte001;}
    1576          } finally {
    1577            if (jjtc001) {
    1578              jjtree.closeNodeScope(jjtn001,  1);
    1579              jjtreeCloseNodeScope(jjtn001);
    1580            }
    1581          }
    1582          break;
    1583        case 63:
    1584          jj_consume_token(63);
    1585            ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(JJTBITWISECOMPLNODE);
    1586            boolean jjtc002 = true;
    1587            jjtree.openNodeScope(jjtn002);
    1588            jjtreeOpenNodeScope(jjtn002);
    1589          try {
    1590            UnaryExpression();
    1591          } catch (Throwable jjte002) {
    1592            if (jjtc002) {
    1593              jjtree.clearNodeScope(jjtn002);
    1594              jjtc002 = false;
    1595            } else {
    1596              jjtree.popNode();
    1597            }
    1598            if (jjte002 instanceof RuntimeException) {
    1599              {if (true) throw (RuntimeException)jjte002;}
    1600            }
    1601            if (jjte002 instanceof ParseException) {
    1602              {if (true) throw (ParseException)jjte002;}
    1603            }
    1604            {if (true) throw (Error)jjte002;}
    1605          } finally {
    1606            if (jjtc002) {
    1607              jjtree.closeNodeScope(jjtn002,  1);
    1608              jjtreeCloseNodeScope(jjtn002);
    1609            }
    1610          }
    1611          break;
    1612        case 64:
    1613          jj_consume_token(64);
    1614            ASTNotNode jjtn003 = new ASTNotNode(JJTNOTNODE);
    1615            boolean jjtc003 = true;
    1616            jjtree.openNodeScope(jjtn003);
    1617            jjtreeOpenNodeScope(jjtn003);
    1618          try {
    1619            UnaryExpression();
    1620          } catch (Throwable jjte003) {
    1621            if (jjtc003) {
    1622              jjtree.clearNodeScope(jjtn003);
    1623              jjtc003 = false;
    1624            } else {
    1625              jjtree.popNode();
    1626            }
    1627            if (jjte003 instanceof RuntimeException) {
    1628              {if (true) throw (RuntimeException)jjte003;}
    1629            }
    1630            if (jjte003 instanceof ParseException) {
    1631              {if (true) throw (ParseException)jjte003;}
    1632            }
    1633            {if (true) throw (Error)jjte003;}
    1634          } finally {
    1635            if (jjtc003) {
    1636              jjtree.closeNodeScope(jjtn003,  1);
    1637              jjtreeCloseNodeScope(jjtn003);
    1638            }
    1639          }
    1640          break;
    1641        case 65:
    1642          jj_consume_token(65);
    1643              ASTNotNode jjtn004 = new ASTNotNode(JJTNOTNODE);
    1644              boolean jjtc004 = true;
    1645              jjtree.openNodeScope(jjtn004);
    1646              jjtreeOpenNodeScope(jjtn004);
    1647          try {
    1648            UnaryExpression();
    1649          } catch (Throwable jjte004) {
    1650              if (jjtc004) {
    1651                jjtree.clearNodeScope(jjtn004);
    1652                jjtc004 = false;
    1653              } else {
    1654                jjtree.popNode();
    1655              }
    1656              if (jjte004 instanceof RuntimeException) {
    1657                {if (true) throw (RuntimeException)jjte004;}
    1658              }
    1659              if (jjte004 instanceof ParseException) {
    1660                {if (true) throw (ParseException)jjte004;}
    1661              }
    1662              {if (true) throw (Error)jjte004;}
    1663          } finally {
    1664              if (jjtc004) {
    1665                jjtree.closeNodeScope(jjtn004,  1);
    1666                jjtreeCloseNodeScope(jjtn004);
    1667              }
    1668          }
    1669          break;
    1670        case INTEGER_LITERAL:
    1671        case FLOAT_LITERAL:
    1672        case NEW:
    1673        case EMPTY:
    1674        case SIZE:
    1675        case NULL:
    1676        case TRUE:
    1677        case FALSE:
    1678        case LPAREN:
    1679        case LCURLY:
    1680        case LBRACKET:
    1681        case IDENTIFIER:
    1682        case STRING_LITERAL:
    1683          PrimaryExpression();
    1684          break;
    1685        default:
    1686          jj_la1[25] = jj_gen;
    1687          jj_consume_token(-1);
    1688          throw new ParseException();
    1689        }
    1690      }
    1691
    1692    /***************************************
    1693     *      Identifier & Literals
    1694     ***************************************/
    1695      final public void Identifier() throws ParseException {
    1696     /*@bgen(jjtree) Identifier */
    1697        ASTIdentifier jjtn000 = new ASTIdentifier(JJTIDENTIFIER);
    1698        boolean jjtc000 = true;
    1699        jjtree.openNodeScope(jjtn000);
    1700        jjtreeOpenNodeScope(jjtn000);Token t;
    1701        try {
    1702          t = jj_consume_token(IDENTIFIER);
    1703          jjtree.closeNodeScope(jjtn000, true);
    1704          jjtc000 = false;
    1705          jjtreeCloseNodeScope(jjtn000);
    1706          jjtn000.image = t.image;
    1707        } finally {
    1708          if (jjtc000) {
    1709            jjtree.closeNodeScope(jjtn000, true);
    1710            jjtreeCloseNodeScope(jjtn000);
    1711          }
    1712        }
    1713      }
    1714
    1715      final public void Literal() throws ParseException {
    1716       Token t;
    1717        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1718        case INTEGER_LITERAL:
    1719          IntegerLiteral();
    1720          break;
    1721        case FLOAT_LITERAL:
    1722          FloatLiteral();
    1723          break;
    1724        case TRUE:
    1725        case FALSE:
    1726          BooleanLiteral();
    1727          break;
    1728        case STRING_LITERAL:
    1729          StringLiteral();
    1730          break;
    1731        case NULL:
    1732          NullLiteral();
    1733          break;
    1734        default:
    1735          jj_la1[26] = jj_gen;
    1736          jj_consume_token(-1);
    1737          throw new ParseException();
    1738        }
    1739      }
    1740
    1741      final public void NullLiteral() throws ParseException {
    1742                          /*@bgen(jjtree) NullLiteral */
    1743      ASTNullLiteral jjtn000 = new ASTNullLiteral(JJTNULLLITERAL);
    1744      boolean jjtc000 = true;
    1745      jjtree.openNodeScope(jjtn000);
    1746      jjtreeOpenNodeScope(jjtn000);
    1747        try {
    1748          jj_consume_token(NULL);
    1749        } finally {
    1750          if (jjtc000) {
    1751            jjtree.closeNodeScope(jjtn000, true);
    1752            jjtreeCloseNodeScope(jjtn000);
    1753          }
    1754        }
    1755      }
    1756
    1757      final public void BooleanLiteral() throws ParseException {
    1758        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1759        case TRUE:
    1760        ASTTrueNode jjtn001 = new ASTTrueNode(JJTTRUENODE);
    1761        boolean jjtc001 = true;
    1762        jjtree.openNodeScope(jjtn001);
    1763        jjtreeOpenNodeScope(jjtn001);
    1764          try {
    1765            jj_consume_token(TRUE);
    1766          } finally {
    1767        if (jjtc001) {
    1768          jjtree.closeNodeScope(jjtn001, true);
    1769          jjtreeCloseNodeScope(jjtn001);
    1770        }
    1771          }
    1772          break;
    1773        case FALSE:
    1774        ASTFalseNode jjtn002 = new ASTFalseNode(JJTFALSENODE);
    1775        boolean jjtc002 = true;
    1776        jjtree.openNodeScope(jjtn002);
    1777        jjtreeOpenNodeScope(jjtn002);
    1778          try {
    1779            jj_consume_token(FALSE);
    1780          } finally {
    1781        if (jjtc002) {
    1782          jjtree.closeNodeScope(jjtn002, true);
    1783          jjtreeCloseNodeScope(jjtn002);
    1784        }
    1785          }
    1786          break;
    1787        default:
    1788          jj_la1[27] = jj_gen;
    1789          jj_consume_token(-1);
    1790          throw new ParseException();
    1791        }
    1792      }
    1793
    1794      final public void IntegerLiteral() throws ParseException {
    1795     /*@bgen(jjtree) IntegerLiteral */
    1796      ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(JJTINTEGERLITERAL);
    1797      boolean jjtc000 = true;
    1798      jjtree.openNodeScope(jjtn000);
    1799      jjtreeOpenNodeScope(jjtn000);Token t;
    1800        try {
    1801          t = jj_consume_token(INTEGER_LITERAL);
    1802        jjtree.closeNodeScope(jjtn000, true);
    1803        jjtc000 = false;
    1804        jjtreeCloseNodeScope(jjtn000);
    1805        jjtn000.image = t.image;
    1806        } finally {
    1807        if (jjtc000) {
    1808          jjtree.closeNodeScope(jjtn000, true);
    1809          jjtreeCloseNodeScope(jjtn000);
    1810        }
    1811        }
    1812      }
    1813
    1814      final public void FloatLiteral() throws ParseException {
    1815     /*@bgen(jjtree) FloatLiteral */
    1816      ASTFloatLiteral jjtn000 = new ASTFloatLiteral(JJTFLOATLITERAL);
    1817      boolean jjtc000 = true;
    1818      jjtree.openNodeScope(jjtn000);
    1819      jjtreeOpenNodeScope(jjtn000);Token t;
    1820        try {
    1821          t = jj_consume_token(FLOAT_LITERAL);
    1822        jjtree.closeNodeScope(jjtn000, true);
    1823        jjtc000 = false;
    1824        jjtreeCloseNodeScope(jjtn000);
    1825        jjtn000.image = t.image;
    1826        } finally {
    1827        if (jjtc000) {
    1828          jjtree.closeNodeScope(jjtn000, true);
    1829          jjtreeCloseNodeScope(jjtn000);
    1830        }
    1831        }
    1832      }
    1833
    1834      final public void StringLiteral() throws ParseException {
    1835     /*@bgen(jjtree) StringLiteral */
    1836       ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL);
    1837       boolean jjtc000 = true;
    1838       jjtree.openNodeScope(jjtn000);
    1839       jjtreeOpenNodeScope(jjtn000);Token t;
    1840        try {
    1841          t = jj_consume_token(STRING_LITERAL);
    1842        jjtree.closeNodeScope(jjtn000, true);
    1843        jjtc000 = false;
    1844        jjtreeCloseNodeScope(jjtn000);
    1845        jjtn000.image = Parser.buildString(t.image, true);
    1846        } finally {
    1847        if (jjtc000) {
    1848          jjtree.closeNodeScope(jjtn000, true);
    1849          jjtreeCloseNodeScope(jjtn000);
    1850        }
    1851        }
    1852      }
    1853
    1854      final public void ArrayLiteral() throws ParseException {
    1855                           /*@bgen(jjtree) ArrayLiteral */
    1856      ASTArrayLiteral jjtn000 = new ASTArrayLiteral(JJTARRAYLITERAL);
    1857      boolean jjtc000 = true;
    1858      jjtree.openNodeScope(jjtn000);
    1859      jjtreeOpenNodeScope(jjtn000);
    1860        try {
    1861          jj_consume_token(LBRACKET);
    1862          Expression();
    1863          label_11:
    1864          while (true) {
    1865            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1866            case COMMA:
    1867              ;
    1868              break;
    1869            default:
    1870              jj_la1[28] = jj_gen;
    1871              break label_11;
    1872            }
    1873            jj_consume_token(COMMA);
    1874            Expression();
    1875          }
    1876          jj_consume_token(RBRACKET);
    1877        } catch (Throwable jjte000) {
    1878        if (jjtc000) {
    1879          jjtree.clearNodeScope(jjtn000);
    1880          jjtc000 = false;
    1881        } else {
    1882          jjtree.popNode();
    1883        }
    1884        if (jjte000 instanceof RuntimeException) {
    1885          {if (true) throw (RuntimeException)jjte000;}
    1886        }
    1887        if (jjte000 instanceof ParseException) {
    1888          {if (true) throw (ParseException)jjte000;}
    1889        }
    1890        {if (true) throw (Error)jjte000;}
    1891        } finally {
    1892        if (jjtc000) {
    1893          jjtree.closeNodeScope(jjtn000, true);
    1894          jjtreeCloseNodeScope(jjtn000);
    1895        }
    1896        }
    1897      }
    1898
    1899      final public void MapLiteral() throws ParseException {
    1900                         /*@bgen(jjtree) MapLiteral */
    1901      ASTMapLiteral jjtn000 = new ASTMapLiteral(JJTMAPLITERAL);
    1902      boolean jjtc000 = true;
    1903      jjtree.openNodeScope(jjtn000);
    1904      jjtreeOpenNodeScope(jjtn000);
    1905        try {
    1906          jj_consume_token(LCURLY);
    1907          MapEntry();
    1908          label_12:
    1909          while (true) {
    1910            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1911            case COMMA:
    1912              ;
    1913              break;
    1914            default:
    1915              jj_la1[29] = jj_gen;
    1916              break label_12;
    1917            }
    1918            jj_consume_token(COMMA);
    1919            MapEntry();
    1920          }
    1921          jj_consume_token(RCURLY);
    1922        } catch (Throwable jjte000) {
    1923          if (jjtc000) {
    1924            jjtree.clearNodeScope(jjtn000);
    1925            jjtc000 = false;
    1926          } else {
    1927            jjtree.popNode();
    1928          }
    1929          if (jjte000 instanceof RuntimeException) {
    1930            {if (true) throw (RuntimeException)jjte000;}
    1931          }
    1932          if (jjte000 instanceof ParseException) {
    1933            {if (true) throw (ParseException)jjte000;}
    1934          }
    1935          {if (true) throw (Error)jjte000;}
    1936        } finally {
    1937          if (jjtc000) {
    1938            jjtree.closeNodeScope(jjtn000, true);
    1939            jjtreeCloseNodeScope(jjtn000);
    1940          }
    1941        }
    1942      }
    1943
    1944      final public void MapEntry() throws ParseException {
    1945                       /*@bgen(jjtree) MapEntry */
    1946      ASTMapEntry jjtn000 = new ASTMapEntry(JJTMAPENTRY);
    1947      boolean jjtc000 = true;
    1948      jjtree.openNodeScope(jjtn000);
    1949      jjtreeOpenNodeScope(jjtn000);
    1950        try {
    1951          Expression();
    1952          jj_consume_token(COLON);
    1953          Expression();
    1954        } catch (Throwable jjte000) {
    1955          if (jjtc000) {
    1956            jjtree.clearNodeScope(jjtn000);
    1957            jjtc000 = false;
    1958          } else {
    1959            jjtree.popNode();
    1960          }
    1961          if (jjte000 instanceof RuntimeException) {
    1962            {if (true) throw (RuntimeException)jjte000;}
    1963          }
    1964          if (jjte000 instanceof ParseException) {
    1965            {if (true) throw (ParseException)jjte000;}
    1966          }
    1967          {if (true) throw (Error)jjte000;}
    1968        } finally {
    1969          if (jjtc000) {
    1970            jjtree.closeNodeScope(jjtn000, true);
    1971            jjtreeCloseNodeScope(jjtn000);
    1972          }
    1973        }
    1974      }
    1975
    1976    /***************************************
    1977     *      Functions & Methods
    1978     ***************************************/
    1979      final public void EmptyFunction() throws ParseException {
    1980                            /*@bgen(jjtree) EmptyFunction */
    1981      ASTEmptyFunction jjtn000 = new ASTEmptyFunction(JJTEMPTYFUNCTION);
    1982      boolean jjtc000 = true;
    1983      jjtree.openNodeScope(jjtn000);
    1984      jjtreeOpenNodeScope(jjtn000);
    1985        try {
    1986          if (jj_2_4(3)) {
    1987            jj_consume_token(EMPTY);
    1988            jj_consume_token(LPAREN);
    1989            Expression();
    1990            jj_consume_token(RPAREN);
    1991          } else {
    1992            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1993            case EMPTY:
    1994              jj_consume_token(EMPTY);
    1995              Reference();
    1996              break;
    1997            default:
    1998              jj_la1[30] = jj_gen;
    1999              jj_consume_token(-1);
    2000              throw new ParseException();
    2001            }
    2002          }
    2003        } catch (Throwable jjte000) {
    2004          if (jjtc000) {
    2005            jjtree.clearNodeScope(jjtn000);
    2006            jjtc000 = false;
    2007          } else {
    2008            jjtree.popNode();
    2009          }
    2010          if (jjte000 instanceof RuntimeException) {
    2011            {if (true) throw (RuntimeException)jjte000;}
    2012          }
    2013          if (jjte000 instanceof ParseException) {
    2014            {if (true) throw (ParseException)jjte000;}
    2015          }
    2016          {if (true) throw (Error)jjte000;}
    2017        } finally {
    2018          if (jjtc000) {
    2019            jjtree.closeNodeScope(jjtn000, true);
    2020            jjtreeCloseNodeScope(jjtn000);
    2021          }
    2022        }
    2023      }
    2024
    2025      final public void SizeFunction() throws ParseException {
    2026                           /*@bgen(jjtree) SizeFunction */
    2027      ASTSizeFunction jjtn000 = new ASTSizeFunction(JJTSIZEFUNCTION);
    2028      boolean jjtc000 = true;
    2029      jjtree.openNodeScope(jjtn000);
    2030      jjtreeOpenNodeScope(jjtn000);
    2031        try {
    2032          jj_consume_token(SIZE);
    2033          jj_consume_token(LPAREN);
    2034          Expression();
    2035          jj_consume_token(RPAREN);
    2036        } catch (Throwable jjte000) {
    2037          if (jjtc000) {
    2038            jjtree.clearNodeScope(jjtn000);
    2039            jjtc000 = false;
    2040          } else {
    2041            jjtree.popNode();
    2042          }
    2043          if (jjte000 instanceof RuntimeException) {
    2044            {if (true) throw (RuntimeException)jjte000;}
    2045          }
    2046          if (jjte000 instanceof ParseException) {
    2047            {if (true) throw (ParseException)jjte000;}
    2048          }
    2049          {if (true) throw (Error)jjte000;}
    2050        } finally {
    2051          if (jjtc000) {
    2052            jjtree.closeNodeScope(jjtn000, true);
    2053            jjtreeCloseNodeScope(jjtn000);
    2054          }
    2055        }
    2056      }
    2057
    2058      final public void Function() throws ParseException {
    2059                                    /*@bgen(jjtree) FunctionNode */
    2060      ASTFunctionNode jjtn000 = new ASTFunctionNode(JJTFUNCTIONNODE);
    2061      boolean jjtc000 = true;
    2062      jjtree.openNodeScope(jjtn000);
    2063      jjtreeOpenNodeScope(jjtn000);
    2064        try {
    2065          Identifier();
    2066          jj_consume_token(COLON);
    2067          Identifier();
    2068          jj_consume_token(LPAREN);
    2069          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2070          case INTEGER_LITERAL:
    2071          case FLOAT_LITERAL:
    2072          case NEW:
    2073          case EMPTY:
    2074          case SIZE:
    2075          case NULL:
    2076          case TRUE:
    2077          case FALSE:
    2078          case LPAREN:
    2079          case LCURLY:
    2080          case LBRACKET:
    2081          case 57:
    2082          case 63:
    2083          case 64:
    2084          case 65:
    2085          case IDENTIFIER:
    2086          case STRING_LITERAL:
    2087            Expression();
    2088            label_13:
    2089            while (true) {
    2090              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2091              case COMMA:
    2092                ;
    2093                break;
    2094              default:
    2095                jj_la1[31] = jj_gen;
    2096                break label_13;
    2097              }
    2098              jj_consume_token(COMMA);
    2099              Expression();
    2100            }
    2101            break;
    2102          default:
    2103            jj_la1[32] = jj_gen;
    2104            ;
    2105          }
    2106          jj_consume_token(RPAREN);
    2107        } catch (Throwable jjte000) {
    2108         if (jjtc000) {
    2109           jjtree.clearNodeScope(jjtn000);
    2110           jjtc000 = false;
    2111         } else {
    2112           jjtree.popNode();
    2113         }
    2114         if (jjte000 instanceof RuntimeException) {
    2115           {if (true) throw (RuntimeException)jjte000;}
    2116         }
    2117         if (jjte000 instanceof ParseException) {
    2118           {if (true) throw (ParseException)jjte000;}
    2119         }
    2120         {if (true) throw (Error)jjte000;}
    2121        } finally {
    2122         if (jjtc000) {
    2123           jjtree.closeNodeScope(jjtn000, true);
    2124           jjtreeCloseNodeScope(jjtn000);
    2125         }
    2126        }
    2127      }
    2128
    2129      final public void Method() throws ParseException {
    2130                                /*@bgen(jjtree) MethodNode */
    2131      ASTMethodNode jjtn000 = new ASTMethodNode(JJTMETHODNODE);
    2132      boolean jjtc000 = true;
    2133      jjtree.openNodeScope(jjtn000);
    2134      jjtreeOpenNodeScope(jjtn000);
    2135        try {
    2136          Identifier();
    2137          jj_consume_token(LPAREN);
    2138          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2139          case INTEGER_LITERAL:
    2140          case FLOAT_LITERAL:
    2141          case NEW:
    2142          case EMPTY:
    2143          case SIZE:
    2144          case NULL:
    2145          case TRUE:
    2146          case FALSE:
    2147          case LPAREN:
    2148          case LCURLY:
    2149          case LBRACKET:
    2150          case 57:
    2151          case 63:
    2152          case 64:
    2153          case 65:
    2154          case IDENTIFIER:
    2155          case STRING_LITERAL:
    2156            Expression();
    2157            label_14:
    2158            while (true) {
    2159              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2160              case COMMA:
    2161                ;
    2162                break;
    2163              default:
    2164                jj_la1[33] = jj_gen;
    2165                break label_14;
    2166              }
    2167              jj_consume_token(COMMA);
    2168              Expression();
    2169            }
    2170            break;
    2171          default:
    2172            jj_la1[34] = jj_gen;
    2173            ;
    2174          }
    2175          jj_consume_token(RPAREN);
    2176        } catch (Throwable jjte000) {
    2177         if (jjtc000) {
    2178           jjtree.clearNodeScope(jjtn000);
    2179           jjtc000 = false;
    2180         } else {
    2181           jjtree.popNode();
    2182         }
    2183         if (jjte000 instanceof RuntimeException) {
    2184           {if (true) throw (RuntimeException)jjte000;}
    2185         }
    2186         if (jjte000 instanceof ParseException) {
    2187           {if (true) throw (ParseException)jjte000;}
    2188         }
    2189         {if (true) throw (Error)jjte000;}
    2190        } finally {
    2191         if (jjtc000) {
    2192           jjtree.closeNodeScope(jjtn000, true);
    2193           jjtreeCloseNodeScope(jjtn000);
    2194         }
    2195        }
    2196      }
    2197
    2198      final public void AnyMethod() throws ParseException {
    2199        if (jj_2_5(2147483647)) {
    2200          SizeMethod();
    2201        } else if (jj_2_6(2147483647)) {
    2202          Method();
    2203        } else {
    2204          jj_consume_token(-1);
    2205          throw new ParseException();
    2206        }
    2207      }
    2208
    2209      final public void SizeMethod() throws ParseException {
    2210                         /*@bgen(jjtree) SizeMethod */
    2211      ASTSizeMethod jjtn000 = new ASTSizeMethod(JJTSIZEMETHOD);
    2212      boolean jjtc000 = true;
    2213      jjtree.openNodeScope(jjtn000);
    2214      jjtreeOpenNodeScope(jjtn000);
    2215        try {
    2216          jj_consume_token(SIZE);
    2217          jj_consume_token(LPAREN);
    2218          jj_consume_token(RPAREN);
    2219        } finally {
    2220          if (jjtc000) {
    2221            jjtree.closeNodeScope(jjtn000, true);
    2222            jjtreeCloseNodeScope(jjtn000);
    2223          }
    2224        }
    2225      }
    2226
    2227      final public void Constructor() throws ParseException {
    2228                                             /*@bgen(jjtree) #ConstructorNode(true) */
    2229      ASTConstructorNode jjtn000 = new ASTConstructorNode(JJTCONSTRUCTORNODE);
    2230      boolean jjtc000 = true;
    2231      jjtree.openNodeScope(jjtn000);
    2232      jjtreeOpenNodeScope(jjtn000);
    2233        try {
    2234          jj_consume_token(NEW);
    2235          jj_consume_token(LPAREN);
    2236          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2237          case INTEGER_LITERAL:
    2238          case FLOAT_LITERAL:
    2239          case NEW:
    2240          case EMPTY:
    2241          case SIZE:
    2242          case NULL:
    2243          case TRUE:
    2244          case FALSE:
    2245          case LPAREN:
    2246          case LCURLY:
    2247          case LBRACKET:
    2248          case 57:
    2249          case 63:
    2250          case 64:
    2251          case 65:
    2252          case IDENTIFIER:
    2253          case STRING_LITERAL:
    2254            Expression();
    2255            label_15:
    2256            while (true) {
    2257              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2258              case COMMA:
    2259                ;
    2260                break;
    2261              default:
    2262                jj_la1[35] = jj_gen;
    2263                break label_15;
    2264              }
    2265              jj_consume_token(COMMA);
    2266              Expression();
    2267            }
    2268            break;
    2269          default:
    2270            jj_la1[36] = jj_gen;
    2271            ;
    2272          }
    2273          jj_consume_token(RPAREN);
    2274        } catch (Throwable jjte000) {
    2275        if (jjtc000) {
    2276          jjtree.clearNodeScope(jjtn000);
    2277          jjtc000 = false;
    2278        } else {
    2279          jjtree.popNode();
    2280        }
    2281        if (jjte000 instanceof RuntimeException) {
    2282          {if (true) throw (RuntimeException)jjte000;}
    2283        }
    2284        if (jjte000 instanceof ParseException) {
    2285          {if (true) throw (ParseException)jjte000;}
    2286        }
    2287        {if (true) throw (Error)jjte000;}
    2288        } finally {
    2289        if (jjtc000) {
    2290          jjtree.closeNodeScope(jjtn000, true);
    2291          jjtreeCloseNodeScope(jjtn000);
    2292        }
    2293        }
    2294      }
    2295
    2296    /***************************************
    2297     *     References
    2298     ***************************************/
    2299      final public void PrimaryExpression() throws ParseException {
    2300        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2301        case INTEGER_LITERAL:
    2302        case FLOAT_LITERAL:
    2303        case NULL:
    2304        case TRUE:
    2305        case FALSE:
    2306        case STRING_LITERAL:
    2307          Literal();
    2308          break;
    2309        default:
    2310          jj_la1[37] = jj_gen;
    2311          if (jj_2_7(3)) {
    2312            Reference();
    2313          } else if (jj_2_8(2147483647)) {
    2314            jj_consume_token(LPAREN);
    2315            Expression();
    2316            jj_consume_token(RPAREN);
    2317          } else if (jj_2_9(2147483647)) {
    2318            EmptyFunction();
    2319          } else if (jj_2_10(2147483647)) {
    2320            SizeFunction();
    2321          } else if (jj_2_11(2147483647)) {
    2322            Constructor();
    2323          } else if (jj_2_12(2147483647)) {
    2324            MapLiteral();
    2325          } else if (jj_2_13(2147483647)) {
    2326            ArrayLiteral();
    2327          } else {
    2328            jj_consume_token(-1);
    2329            throw new ParseException();
    2330          }
    2331        }
    2332      }
    2333
    2334      final public void ArrayAccess() throws ParseException {
    2335                          /*@bgen(jjtree) ArrayAccess */
    2336      ASTArrayAccess jjtn000 = new ASTArrayAccess(JJTARRAYACCESS);
    2337      boolean jjtc000 = true;
    2338      jjtree.openNodeScope(jjtn000);
    2339      jjtreeOpenNodeScope(jjtn000);
    2340        try {
    2341          Identifier();
    2342          label_16:
    2343          while (true) {
    2344            jj_consume_token(LBRACKET);
    2345            Expression();
    2346            jj_consume_token(RBRACKET);
    2347            if (jj_2_14(2)) {
    2348              ;
    2349            } else {
    2350              break label_16;
    2351            }
    2352          }
    2353        } catch (Throwable jjte000) {
    2354          if (jjtc000) {
    2355            jjtree.clearNodeScope(jjtn000);
    2356            jjtc000 = false;
    2357          } else {
    2358            jjtree.popNode();
    2359          }
    2360          if (jjte000 instanceof RuntimeException) {
    2361            {if (true) throw (RuntimeException)jjte000;}
    2362          }
    2363          if (jjte000 instanceof ParseException) {
    2364            {if (true) throw (ParseException)jjte000;}
    2365          }
    2366          {if (true) throw (Error)jjte000;}
    2367        } finally {
    2368          if (jjtc000) {
    2369            jjtree.closeNodeScope(jjtn000, true);
    2370            jjtreeCloseNodeScope(jjtn000);
    2371          }
    2372        }
    2373      }
    2374
    2375      final public void DotReference() throws ParseException {
    2376        label_17:
    2377        while (true) {
    2378          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2379          case 66:
    2380            ;
    2381            break;
    2382          default:
    2383            jj_la1[38] = jj_gen;
    2384            break label_17;
    2385          }
    2386          jj_consume_token(66);
    2387          if (jj_2_16(2147483647)) {
    2388            ArrayAccess();
    2389          } else {
    2390            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2391            case INTEGER_LITERAL:
    2392            case SIZE:
    2393            case IDENTIFIER:
    2394              if (jj_2_15(3)) {
    2395                AnyMethod();
    2396              } else {
    2397                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2398                case IDENTIFIER:
    2399                  Identifier();
    2400                  break;
    2401                case INTEGER_LITERAL:
    2402                  IntegerLiteral();
    2403                  break;
    2404                default:
    2405                  jj_la1[39] = jj_gen;
    2406                  jj_consume_token(-1);
    2407                  throw new ParseException();
    2408                }
    2409              }
    2410              break;
    2411            default:
    2412              jj_la1[40] = jj_gen;
    2413              jj_consume_token(-1);
    2414              throw new ParseException();
    2415            }
    2416          }
    2417        }
    2418      }
    2419
    2420      final public void Reference() throws ParseException {
    2421                        /*@bgen(jjtree) Reference */
    2422      ASTReference jjtn000 = new ASTReference(JJTREFERENCE);
    2423      boolean jjtc000 = true;
    2424      jjtree.openNodeScope(jjtn000);
    2425      jjtreeOpenNodeScope(jjtn000);
    2426        try {
    2427          if (jj_2_17(2147483647)) {
    2428            Constructor();
    2429          } else if (jj_2_18(2147483647)) {
    2430            ArrayAccess();
    2431          } else if (jj_2_19(2147483647)) {
    2432            Function();
    2433          } else if (jj_2_20(2147483647)) {
    2434            Method();
    2435          } else {
    2436            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    2437            case IDENTIFIER:
    2438              Identifier();
    2439              break;
    2440            default:
    2441              jj_la1[41] = jj_gen;
    2442              if (jj_2_21(2147483647)) {
    2443                MapLiteral();
    2444              } else if (jj_2_22(2147483647)) {
    2445                ArrayLiteral();
    2446              } else {
    2447                jj_consume_token(-1);
    2448                throw new ParseException();
    2449              }
    2450            }
    2451          }
    2452          DotReference();
    2453        } catch (Throwable jjte000) {
    2454        if (jjtc000) {
    2455          jjtree.clearNodeScope(jjtn000);
    2456          jjtc000 = false;
    2457        } else {
    2458          jjtree.popNode();
    2459        }
    2460        if (jjte000 instanceof RuntimeException) {
    2461          {if (true) throw (RuntimeException)jjte000;}
    2462        }
    2463        if (jjte000 instanceof ParseException) {
    2464          {if (true) throw (ParseException)jjte000;}
    2465        }
    2466        {if (true) throw (Error)jjte000;}
    2467        } finally {
    2468        if (jjtc000) {
    2469          jjtree.closeNodeScope(jjtn000, true);
    2470          jjtreeCloseNodeScope(jjtn000);
    2471        }
    2472        }
    2473      }
    2474
    2475      private boolean jj_2_1(int xla) {
    2476        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2477        try { return !jj_3_1(); }
    2478        catch(LookaheadSuccess ls) { return true; }
    2479        finally { jj_save(0, xla); }
    2480      }
    2481
    2482      private boolean jj_2_2(int xla) {
    2483        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2484        try { return !jj_3_2(); }
    2485        catch(LookaheadSuccess ls) { return true; }
    2486        finally { jj_save(1, xla); }
    2487      }
    2488
    2489      private boolean jj_2_3(int xla) {
    2490        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2491        try { return !jj_3_3(); }
    2492        catch(LookaheadSuccess ls) { return true; }
    2493        finally { jj_save(2, xla); }
    2494      }
    2495
    2496      private boolean jj_2_4(int xla) {
    2497        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2498        try { return !jj_3_4(); }
    2499        catch(LookaheadSuccess ls) { return true; }
    2500        finally { jj_save(3, xla); }
    2501      }
    2502
    2503      private boolean jj_2_5(int xla) {
    2504        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2505        try { return !jj_3_5(); }
    2506        catch(LookaheadSuccess ls) { return true; }
    2507        finally { jj_save(4, xla); }
    2508      }
    2509
    2510      private boolean jj_2_6(int xla) {
    2511        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2512        try { return !jj_3_6(); }
    2513        catch(LookaheadSuccess ls) { return true; }
    2514        finally { jj_save(5, xla); }
    2515      }
    2516
    2517      private boolean jj_2_7(int xla) {
    2518        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2519        try { return !jj_3_7(); }
    2520        catch(LookaheadSuccess ls) { return true; }
    2521        finally { jj_save(6, xla); }
    2522      }
    2523
    2524      private boolean jj_2_8(int xla) {
    2525        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2526        try { return !jj_3_8(); }
    2527        catch(LookaheadSuccess ls) { return true; }
    2528        finally { jj_save(7, xla); }
    2529      }
    2530
    2531      private boolean jj_2_9(int xla) {
    2532        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2533        try { return !jj_3_9(); }
    2534        catch(LookaheadSuccess ls) { return true; }
    2535        finally { jj_save(8, xla); }
    2536      }
    2537
    2538      private boolean jj_2_10(int xla) {
    2539        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2540        try { return !jj_3_10(); }
    2541        catch(LookaheadSuccess ls) { return true; }
    2542        finally { jj_save(9, xla); }
    2543      }
    2544
    2545      private boolean jj_2_11(int xla) {
    2546        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2547        try { return !jj_3_11(); }
    2548        catch(LookaheadSuccess ls) { return true; }
    2549        finally { jj_save(10, xla); }
    2550      }
    2551
    2552      private boolean jj_2_12(int xla) {
    2553        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2554        try { return !jj_3_12(); }
    2555        catch(LookaheadSuccess ls) { return true; }
    2556        finally { jj_save(11, xla); }
    2557      }
    2558
    2559      private boolean jj_2_13(int xla) {
    2560        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2561        try { return !jj_3_13(); }
    2562        catch(LookaheadSuccess ls) { return true; }
    2563        finally { jj_save(12, xla); }
    2564      }
    2565
    2566      private boolean jj_2_14(int xla) {
    2567        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2568        try { return !jj_3_14(); }
    2569        catch(LookaheadSuccess ls) { return true; }
    2570        finally { jj_save(13, xla); }
    2571      }
    2572
    2573      private boolean jj_2_15(int xla) {
    2574        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2575        try { return !jj_3_15(); }
    2576        catch(LookaheadSuccess ls) { return true; }
    2577        finally { jj_save(14, xla); }
    2578      }
    2579
    2580      private boolean jj_2_16(int xla) {
    2581        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2582        try { return !jj_3_16(); }
    2583        catch(LookaheadSuccess ls) { return true; }
    2584        finally { jj_save(15, xla); }
    2585      }
    2586
    2587      private boolean jj_2_17(int xla) {
    2588        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2589        try { return !jj_3_17(); }
    2590        catch(LookaheadSuccess ls) { return true; }
    2591        finally { jj_save(16, xla); }
    2592      }
    2593
    2594      private boolean jj_2_18(int xla) {
    2595        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2596        try { return !jj_3_18(); }
    2597        catch(LookaheadSuccess ls) { return true; }
    2598        finally { jj_save(17, xla); }
    2599      }
    2600
    2601      private boolean jj_2_19(int xla) {
    2602        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2603        try { return !jj_3_19(); }
    2604        catch(LookaheadSuccess ls) { return true; }
    2605        finally { jj_save(18, xla); }
    2606      }
    2607
    2608      private boolean jj_2_20(int xla) {
    2609        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2610        try { return !jj_3_20(); }
    2611        catch(LookaheadSuccess ls) { return true; }
    2612        finally { jj_save(19, xla); }
    2613      }
    2614
    2615      private boolean jj_2_21(int xla) {
    2616        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2617        try { return !jj_3_21(); }
    2618        catch(LookaheadSuccess ls) { return true; }
    2619        finally { jj_save(20, xla); }
    2620      }
    2621
    2622      private boolean jj_2_22(int xla) {
    2623        jj_la = xla; jj_lastpos = jj_scanpos = token;
    2624        try { return !jj_3_22(); }
    2625        catch(LookaheadSuccess ls) { return true; }
    2626        finally { jj_save(21, xla); }
    2627      }
    2628
    2629      private boolean jj_3R_140() {
    2630        if (jj_3R_145()) return true;
    2631        return false;
    2632      }
    2633
    2634      private boolean jj_3R_139() {
    2635        if (jj_3R_144()) return true;
    2636        return false;
    2637      }
    2638
    2639      private boolean jj_3R_138() {
    2640        if (jj_3R_143()) return true;
    2641        return false;
    2642      }
    2643
    2644      private boolean jj_3R_137() {
    2645        if (jj_3R_142()) return true;
    2646        return false;
    2647      }
    2648
    2649      private boolean jj_3R_133() {
    2650        Token xsp;
    2651        xsp = jj_scanpos;
    2652        if (jj_3R_136()) {
    2653        jj_scanpos = xsp;
    2654        if (jj_3R_137()) {
    2655        jj_scanpos = xsp;
    2656        if (jj_3R_138()) {
    2657        jj_scanpos = xsp;
    2658        if (jj_3R_139()) {
    2659        jj_scanpos = xsp;
    2660        if (jj_3R_140()) return true;
    2661        }
    2662        }
    2663        }
    2664        }
    2665        return false;
    2666      }
    2667
    2668      private boolean jj_3R_136() {
    2669        if (jj_3R_77()) return true;
    2670        return false;
    2671      }
    2672
    2673      private boolean jj_3R_21() {
    2674        if (jj_scan_token(IDENTIFIER)) return true;
    2675        return false;
    2676      }
    2677
    2678      private boolean jj_3R_117() {
    2679        if (jj_3R_125()) return true;
    2680        return false;
    2681      }
    2682
    2683      private boolean jj_3R_116() {
    2684        if (jj_scan_token(65)) return true;
    2685        if (jj_3R_110()) return true;
    2686        return false;
    2687      }
    2688
    2689      private boolean jj_3R_115() {
    2690        if (jj_scan_token(64)) return true;
    2691        if (jj_3R_110()) return true;
    2692        return false;
    2693      }
    2694
    2695      private boolean jj_3R_99() {
    2696        if (jj_3R_112()) return true;
    2697        if (jj_3R_98()) return true;
    2698        return false;
    2699      }
    2700
    2701      private boolean jj_3R_114() {
    2702        if (jj_scan_token(63)) return true;
    2703        if (jj_3R_110()) return true;
    2704        return false;
    2705      }
    2706
    2707      private boolean jj_3R_110() {
    2708        Token xsp;
    2709        xsp = jj_scanpos;
    2710        if (jj_3R_113()) {
    2711        jj_scanpos = xsp;
    2712        if (jj_3R_114()) {
    2713        jj_scanpos = xsp;
    2714        if (jj_3R_115()) {
    2715        jj_scanpos = xsp;
    2716        if (jj_3R_116()) {
    2717        jj_scanpos = xsp;
    2718        if (jj_3R_117()) return true;
    2719        }
    2720        }
    2721        }
    2722        }
    2723        return false;
    2724      }
    2725
    2726      private boolean jj_3R_113() {
    2727        if (jj_scan_token(57)) return true;
    2728        if (jj_3R_110()) return true;
    2729        return false;
    2730      }
    2731
    2732      private boolean jj_3R_122() {
    2733        if (jj_scan_token(62)) return true;
    2734        if (jj_3R_110()) return true;
    2735        return false;
    2736      }
    2737
    2738      private boolean jj_3R_121() {
    2739        if (jj_scan_token(61)) return true;
    2740        if (jj_3R_110()) return true;
    2741        return false;
    2742      }
    2743
    2744      private boolean jj_3R_120() {
    2745        if (jj_scan_token(60)) return true;
    2746        if (jj_3R_110()) return true;
    2747        return false;
    2748      }
    2749
    2750      private boolean jj_3R_119() {
    2751        if (jj_scan_token(59)) return true;
    2752        if (jj_3R_110()) return true;
    2753        return false;
    2754      }
    2755
    2756      private boolean jj_3R_111() {
    2757        Token xsp;
    2758        xsp = jj_scanpos;
    2759        if (jj_3R_118()) {
    2760        jj_scanpos = xsp;
    2761        if (jj_3R_119()) {
    2762        jj_scanpos = xsp;
    2763        if (jj_3R_120()) {
    2764        jj_scanpos = xsp;
    2765        if (jj_3R_121()) {
    2766        jj_scanpos = xsp;
    2767        if (jj_3R_122()) return true;
    2768        }
    2769        }
    2770        }
    2771        }
    2772        return false;
    2773      }
    2774
    2775      private boolean jj_3R_118() {
    2776        if (jj_scan_token(58)) return true;
    2777        if (jj_3R_110()) return true;
    2778        return false;
    2779      }
    2780
    2781      private boolean jj_3R_98() {
    2782        if (jj_3R_110()) return true;
    2783        Token xsp;
    2784        while (true) {
    2785          xsp = jj_scanpos;
    2786          if (jj_3R_111()) { jj_scanpos = xsp; break; }
    2787        }
    2788        return false;
    2789      }
    2790
    2791      private boolean jj_3R_124() {
    2792        if (jj_scan_token(57)) return true;
    2793        return false;
    2794      }
    2795
    2796      private boolean jj_3R_112() {
    2797        Token xsp;
    2798        xsp = jj_scanpos;
    2799        if (jj_3R_123()) {
    2800        jj_scanpos = xsp;
    2801        if (jj_3R_124()) return true;
    2802        }
    2803        return false;
    2804      }
    2805
    2806      private boolean jj_3R_123() {
    2807        if (jj_scan_token(56)) return true;
    2808        return false;
    2809      }
    2810
    2811      private boolean jj_3R_92() {
    2812        if (jj_3R_98()) return true;
    2813        Token xsp;
    2814        while (true) {
    2815          xsp = jj_scanpos;
    2816          if (jj_3R_99()) { jj_scanpos = xsp; break; }
    2817        }
    2818        return false;
    2819      }
    2820
    2821      private boolean jj_3R_109() {
    2822        if (jj_scan_token(55)) return true;
    2823        if (jj_3R_92()) return true;
    2824        return false;
    2825      }
    2826
    2827      private boolean jj_3R_108() {
    2828        if (jj_scan_token(54)) return true;
    2829        if (jj_3R_92()) return true;
    2830        return false;
    2831      }
    2832
    2833      private boolean jj_3R_107() {
    2834        if (jj_scan_token(53)) return true;
    2835        if (jj_3R_92()) return true;
    2836        return false;
    2837      }
    2838
    2839      private boolean jj_3R_106() {
    2840        if (jj_scan_token(52)) return true;
    2841        if (jj_3R_92()) return true;
    2842        return false;
    2843      }
    2844
    2845      private boolean jj_3R_105() {
    2846        if (jj_scan_token(51)) return true;
    2847        if (jj_3R_92()) return true;
    2848        return false;
    2849      }
    2850
    2851      private boolean jj_3R_104() {
    2852        if (jj_scan_token(50)) return true;
    2853        if (jj_3R_92()) return true;
    2854        return false;
    2855      }
    2856
    2857      private boolean jj_3R_103() {
    2858        if (jj_scan_token(49)) return true;
    2859        if (jj_3R_92()) return true;
    2860        return false;
    2861      }
    2862
    2863      private boolean jj_3R_102() {
    2864        if (jj_scan_token(48)) return true;
    2865        if (jj_3R_92()) return true;
    2866        return false;
    2867      }
    2868
    2869      private boolean jj_3R_101() {
    2870        if (jj_scan_token(47)) return true;
    2871        if (jj_3R_92()) return true;
    2872        return false;
    2873      }
    2874
    2875      private boolean jj_3R_93() {
    2876        Token xsp;
    2877        xsp = jj_scanpos;
    2878        if (jj_3R_100()) {
    2879        jj_scanpos = xsp;
    2880        if (jj_3R_101()) {
    2881        jj_scanpos = xsp;
    2882        if (jj_3R_102()) {
    2883        jj_scanpos = xsp;
    2884        if (jj_3R_103()) {
    2885        jj_scanpos = xsp;
    2886        if (jj_3R_104()) {
    2887        jj_scanpos = xsp;
    2888        if (jj_3R_105()) {
    2889        jj_scanpos = xsp;
    2890        if (jj_3R_106()) {
    2891        jj_scanpos = xsp;
    2892        if (jj_3R_107()) {
    2893        jj_scanpos = xsp;
    2894        if (jj_3R_108()) {
    2895        jj_scanpos = xsp;
    2896        if (jj_3R_109()) return true;
    2897        }
    2898        }
    2899        }
    2900        }
    2901        }
    2902        }
    2903        }
    2904        }
    2905        }
    2906        return false;
    2907      }
    2908
    2909      private boolean jj_3R_100() {
    2910        if (jj_scan_token(46)) return true;
    2911        if (jj_3R_92()) return true;
    2912        return false;
    2913      }
    2914
    2915      private boolean jj_3R_90() {
    2916        if (jj_3R_92()) return true;
    2917        Token xsp;
    2918        xsp = jj_scanpos;
    2919        if (jj_3R_93()) jj_scanpos = xsp;
    2920        return false;
    2921      }
    2922
    2923      private boolean jj_3R_97() {
    2924        if (jj_scan_token(45)) return true;
    2925        if (jj_3R_90()) return true;
    2926        return false;
    2927      }
    2928
    2929      private boolean jj_3R_96() {
    2930        if (jj_scan_token(44)) return true;
    2931        if (jj_3R_90()) return true;
    2932        return false;
    2933      }
    2934
    2935      private boolean jj_3R_95() {
    2936        if (jj_scan_token(43)) return true;
    2937        if (jj_3R_90()) return true;
    2938        return false;
    2939      }
    2940
    2941      private boolean jj_3R_91() {
    2942        Token xsp;
    2943        xsp = jj_scanpos;
    2944        if (jj_3R_94()) {
    2945        jj_scanpos = xsp;
    2946        if (jj_3R_95()) {
    2947        jj_scanpos = xsp;
    2948        if (jj_3R_96()) {
    2949        jj_scanpos = xsp;
    2950        if (jj_3R_97()) return true;
    2951        }
    2952        }
    2953        }
    2954        return false;
    2955      }
    2956
    2957      private boolean jj_3R_94() {
    2958        if (jj_scan_token(42)) return true;
    2959        if (jj_3R_90()) return true;
    2960        return false;
    2961      }
    2962
    2963      private boolean jj_3R_88() {
    2964        if (jj_3R_90()) return true;
    2965        Token xsp;
    2966        xsp = jj_scanpos;
    2967        if (jj_3R_91()) jj_scanpos = xsp;
    2968        return false;
    2969      }
    2970
    2971      private boolean jj_3R_89() {
    2972        if (jj_scan_token(41)) return true;
    2973        if (jj_3R_88()) return true;
    2974        return false;
    2975      }
    2976
    2977      private boolean jj_3R_86() {
    2978        if (jj_3R_88()) return true;
    2979        Token xsp;
    2980        while (true) {
    2981          xsp = jj_scanpos;
    2982          if (jj_3R_89()) { jj_scanpos = xsp; break; }
    2983        }
    2984        return false;
    2985      }
    2986
    2987      private boolean jj_3R_87() {
    2988        if (jj_scan_token(40)) return true;
    2989        if (jj_3R_86()) return true;
    2990        return false;
    2991      }
    2992
    2993      private boolean jj_3R_82() {
    2994        if (jj_3R_86()) return true;
    2995        Token xsp;
    2996        while (true) {
    2997          xsp = jj_scanpos;
    2998          if (jj_3R_87()) { jj_scanpos = xsp; break; }
    2999        }
    3000        return false;
    3001      }
    3002
    3003      private boolean jj_3R_83() {
    3004        if (jj_scan_token(39)) return true;
    3005        if (jj_3R_82()) return true;
    3006        return false;
    3007      }
    3008
    3009      private boolean jj_3R_78() {
    3010        if (jj_3R_82()) return true;
    3011        Token xsp;
    3012        while (true) {
    3013          xsp = jj_scanpos;
    3014          if (jj_3R_83()) { jj_scanpos = xsp; break; }
    3015        }
    3016        return false;
    3017      }
    3018
    3019      private boolean jj_3R_85() {
    3020        if (jj_scan_token(38)) return true;
    3021        if (jj_3R_78()) return true;
    3022        return false;
    3023      }
    3024
    3025      private boolean jj_3R_79() {
    3026        Token xsp;
    3027        xsp = jj_scanpos;
    3028        if (jj_3R_84()) {
    3029        jj_scanpos = xsp;
    3030        if (jj_3R_85()) return true;
    3031        }
    3032        return false;
    3033      }
    3034
    3035      private boolean jj_3R_84() {
    3036        if (jj_scan_token(37)) return true;
    3037        if (jj_3R_78()) return true;
    3038        return false;
    3039      }
    3040
    3041      private boolean jj_3R_70() {
    3042        if (jj_3R_78()) return true;
    3043        Token xsp;
    3044        while (true) {
    3045          xsp = jj_scanpos;
    3046          if (jj_3R_79()) { jj_scanpos = xsp; break; }
    3047        }
    3048        return false;
    3049      }
    3050
    3051      private boolean jj_3R_81() {
    3052        if (jj_scan_token(36)) return true;
    3053        if (jj_3R_70()) return true;
    3054        return false;
    3055      }
    3056
    3057      private boolean jj_3R_71() {
    3058        Token xsp;
    3059        xsp = jj_scanpos;
    3060        if (jj_3R_80()) {
    3061        jj_scanpos = xsp;
    3062        if (jj_3R_81()) return true;
    3063        }
    3064        return false;
    3065      }
    3066
    3067      private boolean jj_3R_80() {
    3068        if (jj_scan_token(35)) return true;
    3069        if (jj_3R_70()) return true;
    3070        return false;
    3071      }
    3072
    3073      private boolean jj_3R_59() {
    3074        if (jj_3R_70()) return true;
    3075        Token xsp;
    3076        while (true) {
    3077          xsp = jj_scanpos;
    3078          if (jj_3R_71()) { jj_scanpos = xsp; break; }
    3079        }
    3080        return false;
    3081      }
    3082
    3083      private boolean jj_3_2() {
    3084        if (jj_scan_token(SEMICOL)) return true;
    3085        return false;
    3086      }
    3087
    3088      private boolean jj_3R_73() {
    3089        if (jj_scan_token(34)) return true;
    3090        if (jj_3R_20()) return true;
    3091        return false;
    3092      }
    3093
    3094      private boolean jj_3R_60() {
    3095        Token xsp;
    3096        xsp = jj_scanpos;
    3097        if (jj_3R_72()) {
    3098        jj_scanpos = xsp;
    3099        if (jj_3R_73()) return true;
    3100        }
    3101        return false;
    3102      }
    3103
    3104      private boolean jj_3R_72() {
    3105        if (jj_scan_token(33)) return true;
    3106        if (jj_3R_20()) return true;
    3107        if (jj_scan_token(COLON)) return true;
    3108        if (jj_3R_20()) return true;
    3109        return false;
    3110      }
    3111
    3112      private boolean jj_3R_46() {
    3113        if (jj_3R_59()) return true;
    3114        Token xsp;
    3115        xsp = jj_scanpos;
    3116        if (jj_3R_60()) jj_scanpos = xsp;
    3117        return false;
    3118      }
    3119
    3120      private boolean jj_3_3() {
    3121        if (jj_3R_19()) return true;
    3122        if (jj_scan_token(32)) return true;
    3123        return false;
    3124      }
    3125
    3126      private boolean jj_3R_45() {
    3127        if (jj_3R_19()) return true;
    3128        if (jj_scan_token(32)) return true;
    3129        if (jj_3R_20()) return true;
    3130        return false;
    3131      }
    3132
    3133      private boolean jj_3R_34() {
    3134        if (jj_3R_46()) return true;
    3135        return false;
    3136      }
    3137
    3138      private boolean jj_3R_33() {
    3139        if (jj_3R_45()) return true;
    3140        return false;
    3141      }
    3142
    3143      private boolean jj_3R_20() {
    3144        Token xsp;
    3145        xsp = jj_scanpos;
    3146        if (jj_3R_33()) {
    3147        jj_scanpos = xsp;
    3148        if (jj_3R_34()) return true;
    3149        }
    3150        return false;
    3151      }
    3152
    3153      private boolean jj_3R_75() {
    3154        if (jj_scan_token(FOREACH)) return true;
    3155        if (jj_scan_token(LPAREN)) return true;
    3156        return false;
    3157      }
    3158
    3159      private boolean jj_3R_62() {
    3160        Token xsp;
    3161        xsp = jj_scanpos;
    3162        if (jj_3R_74()) {
    3163        jj_scanpos = xsp;
    3164        if (jj_3R_75()) return true;
    3165        }
    3166        return false;
    3167      }
    3168
    3169      private boolean jj_3R_74() {
    3170        if (jj_scan_token(FOR)) return true;
    3171        if (jj_scan_token(LPAREN)) return true;
    3172        return false;
    3173      }
    3174
    3175      private boolean jj_3R_76() {
    3176        if (jj_3R_20()) return true;
    3177        return false;
    3178      }
    3179
    3180      private boolean jj_3R_63() {
    3181        if (jj_scan_token(WHILE)) return true;
    3182        if (jj_scan_token(LPAREN)) return true;
    3183        return false;
    3184      }
    3185
    3186      private boolean jj_3R_61() {
    3187        if (jj_scan_token(IF)) return true;
    3188        if (jj_scan_token(LPAREN)) return true;
    3189        return false;
    3190      }
    3191
    3192      private boolean jj_3R_24() {
    3193        if (jj_3R_37()) return true;
    3194        return false;
    3195      }
    3196
    3197      private boolean jj_3_22() {
    3198        if (jj_scan_token(LBRACKET)) return true;
    3199        return false;
    3200      }
    3201
    3202      private boolean jj_3R_64() {
    3203        if (jj_3R_20()) return true;
    3204        Token xsp;
    3205        while (true) {
    3206          xsp = jj_scanpos;
    3207          if (jj_3R_76()) { jj_scanpos = xsp; break; }
    3208        }
    3209        xsp = jj_scanpos;
    3210        if (jj_3_2()) jj_scanpos = xsp;
    3211        return false;
    3212      }
    3213
    3214      private boolean jj_3_21() {
    3215        if (jj_scan_token(LCURLY)) return true;
    3216        return false;
    3217      }
    3218
    3219      private boolean jj_3_20() {
    3220        if (jj_3R_21()) return true;
    3221        if (jj_scan_token(LPAREN)) return true;
    3222        return false;
    3223      }
    3224
    3225      private boolean jj_3R_18() {
    3226        if (jj_scan_token(LCURLY)) return true;
    3227        Token xsp;
    3228        while (true) {
    3229          xsp = jj_scanpos;
    3230          if (jj_3R_24()) { jj_scanpos = xsp; break; }
    3231        }
    3232        if (jj_scan_token(RCURLY)) return true;
    3233        return false;
    3234      }
    3235
    3236      private boolean jj_3_19() {
    3237        if (jj_3R_21()) return true;
    3238        if (jj_scan_token(COLON)) return true;
    3239        if (jj_3R_21()) return true;
    3240        if (jj_scan_token(LPAREN)) return true;
    3241        return false;
    3242      }
    3243
    3244      private boolean jj_3R_31() {
    3245        if (jj_3R_43()) return true;
    3246        return false;
    3247      }
    3248
    3249      private boolean jj_3_18() {
    3250        if (jj_3R_21()) return true;
    3251        if (jj_scan_token(LBRACKET)) return true;
    3252        return false;
    3253      }
    3254
    3255      private boolean jj_3R_51() {
    3256        if (jj_3R_64()) return true;
    3257        return false;
    3258      }
    3259
    3260      private boolean jj_3_17() {
    3261        if (jj_scan_token(NEW)) return true;
    3262        return false;
    3263      }
    3264
    3265      private boolean jj_3R_50() {
    3266        if (jj_3R_63()) return true;
    3267        return false;
    3268      }
    3269
    3270      private boolean jj_3R_30() {
    3271        if (jj_3R_42()) return true;
    3272        return false;
    3273      }
    3274
    3275      private boolean jj_3R_49() {
    3276        if (jj_3R_62()) return true;
    3277        return false;
    3278      }
    3279
    3280      private boolean jj_3R_48() {
    3281        if (jj_3R_61()) return true;
    3282        return false;
    3283      }
    3284
    3285      private boolean jj_3R_29() {
    3286        if (jj_3R_21()) return true;
    3287        return false;
    3288      }
    3289
    3290      private boolean jj_3_1() {
    3291        if (jj_3R_18()) return true;
    3292        return false;
    3293      }
    3294
    3295      private boolean jj_3R_28() {
    3296        if (jj_3R_41()) return true;
    3297        return false;
    3298      }
    3299
    3300      private boolean jj_3R_37() {
    3301        Token xsp;
    3302        xsp = jj_scanpos;
    3303        if (jj_scan_token(28)) {
    3304        jj_scanpos = xsp;
    3305        if (jj_3_1()) {
    3306        jj_scanpos = xsp;
    3307        if (jj_3R_48()) {
    3308        jj_scanpos = xsp;
    3309        if (jj_3R_49()) {
    3310        jj_scanpos = xsp;
    3311        if (jj_3R_50()) {
    3312        jj_scanpos = xsp;
    3313        if (jj_3R_51()) return true;
    3314        }
    3315        }
    3316        }
    3317        }
    3318        }
    3319        return false;
    3320      }
    3321
    3322      private boolean jj_3R_27() {
    3323        if (jj_3R_40()) return true;
    3324        return false;
    3325      }
    3326
    3327      private boolean jj_3R_26() {
    3328        if (jj_3R_39()) return true;
    3329        return false;
    3330      }
    3331
    3332      private boolean jj_3R_25() {
    3333        if (jj_3R_38()) return true;
    3334        return false;
    3335      }
    3336
    3337      private boolean jj_3R_69() {
    3338        if (jj_3R_77()) return true;
    3339        return false;
    3340      }
    3341
    3342      private boolean jj_3R_19() {
    3343        Token xsp;
    3344        xsp = jj_scanpos;
    3345        if (jj_3R_25()) {
    3346        jj_scanpos = xsp;
    3347        if (jj_3R_26()) {
    3348        jj_scanpos = xsp;
    3349        if (jj_3R_27()) {
    3350        jj_scanpos = xsp;
    3351        if (jj_3R_28()) {
    3352        jj_scanpos = xsp;
    3353        if (jj_3R_29()) {
    3354        jj_scanpos = xsp;
    3355        if (jj_3R_30()) {
    3356        jj_scanpos = xsp;
    3357        if (jj_3R_31()) return true;
    3358        }
    3359        }
    3360        }
    3361        }
    3362        }
    3363        }
    3364        if (jj_3R_32()) return true;
    3365        return false;
    3366      }
    3367
    3368      private boolean jj_3R_68() {
    3369        if (jj_3R_21()) return true;
    3370        return false;
    3371      }
    3372
    3373      private boolean jj_3_16() {
    3374        if (jj_3R_21()) return true;
    3375        if (jj_scan_token(LBRACKET)) return true;
    3376        return false;
    3377      }
    3378
    3379      private boolean jj_3_15() {
    3380        if (jj_3R_23()) return true;
    3381        return false;
    3382      }
    3383
    3384      private boolean jj_3_14() {
    3385        if (jj_scan_token(LBRACKET)) return true;
    3386        if (jj_3R_20()) return true;
    3387        if (jj_scan_token(RBRACKET)) return true;
    3388        return false;
    3389      }
    3390
    3391      private boolean jj_3R_58() {
    3392        Token xsp;
    3393        xsp = jj_scanpos;
    3394        if (jj_3_15()) {
    3395        jj_scanpos = xsp;
    3396        if (jj_3R_68()) {
    3397        jj_scanpos = xsp;
    3398        if (jj_3R_69()) return true;
    3399        }
    3400        }
    3401        return false;
    3402      }
    3403
    3404      private boolean jj_3R_57() {
    3405        if (jj_3R_39()) return true;
    3406        return false;
    3407      }
    3408
    3409      private boolean jj_3R_66() {
    3410        if (jj_scan_token(COMMA)) return true;
    3411        if (jj_3R_20()) return true;
    3412        return false;
    3413      }
    3414
    3415      private boolean jj_3R_44() {
    3416        if (jj_scan_token(66)) return true;
    3417        Token xsp;
    3418        xsp = jj_scanpos;
    3419        if (jj_3R_57()) {
    3420        jj_scanpos = xsp;
    3421        if (jj_3R_58()) return true;
    3422        }
    3423        return false;
    3424      }
    3425
    3426      private boolean jj_3R_32() {
    3427        Token xsp;
    3428        while (true) {
    3429          xsp = jj_scanpos;
    3430          if (jj_3R_44()) { jj_scanpos = xsp; break; }
    3431        }
    3432        return false;
    3433      }
    3434
    3435      private boolean jj_3_13() {
    3436        if (jj_scan_token(LBRACKET)) return true;
    3437        if (jj_3R_20()) return true;
    3438        return false;
    3439      }
    3440
    3441      private boolean jj_3_12() {
    3442        if (jj_scan_token(LCURLY)) return true;
    3443        if (jj_3R_22()) return true;
    3444        return false;
    3445      }
    3446
    3447      private boolean jj_3R_39() {
    3448        if (jj_3R_21()) return true;
    3449        Token xsp;
    3450        if (jj_3_14()) return true;
    3451        while (true) {
    3452          xsp = jj_scanpos;
    3453          if (jj_3_14()) { jj_scanpos = xsp; break; }
    3454        }
    3455        return false;
    3456      }
    3457
    3458      private boolean jj_3R_65() {
    3459        if (jj_scan_token(COMMA)) return true;
    3460        if (jj_3R_20()) return true;
    3461        return false;
    3462      }
    3463
    3464      private boolean jj_3_11() {
    3465        if (jj_scan_token(NEW)) return true;
    3466        if (jj_scan_token(LPAREN)) return true;
    3467        return false;
    3468      }
    3469
    3470      private boolean jj_3_10() {
    3471        if (jj_scan_token(SIZE)) return true;
    3472        return false;
    3473      }
    3474
    3475      private boolean jj_3_9() {
    3476        if (jj_scan_token(EMPTY)) return true;
    3477        return false;
    3478      }
    3479
    3480      private boolean jj_3_8() {
    3481        if (jj_scan_token(LPAREN)) return true;
    3482        return false;
    3483      }
    3484
    3485      private boolean jj_3R_132() {
    3486        if (jj_3R_43()) return true;
    3487        return false;
    3488      }
    3489
    3490      private boolean jj_3R_53() {
    3491        if (jj_3R_20()) return true;
    3492        Token xsp;
    3493        while (true) {
    3494          xsp = jj_scanpos;
    3495          if (jj_3R_66()) { jj_scanpos = xsp; break; }
    3496        }
    3497        return false;
    3498      }
    3499
    3500      private boolean jj_3R_67() {
    3501        if (jj_scan_token(COMMA)) return true;
    3502        if (jj_3R_20()) return true;
    3503        return false;
    3504      }
    3505
    3506      private boolean jj_3R_131() {
    3507        if (jj_3R_42()) return true;
    3508        return false;
    3509      }
    3510
    3511      private boolean jj_3R_130() {
    3512        if (jj_3R_38()) return true;
    3513        return false;
    3514      }
    3515
    3516      private boolean jj_3R_129() {
    3517        if (jj_3R_135()) return true;
    3518        return false;
    3519      }
    3520
    3521      private boolean jj_3R_52() {
    3522        if (jj_3R_20()) return true;
    3523        Token xsp;
    3524        while (true) {
    3525          xsp = jj_scanpos;
    3526          if (jj_3R_65()) { jj_scanpos = xsp; break; }
    3527        }
    3528        return false;
    3529      }
    3530
    3531      private boolean jj_3R_128() {
    3532        if (jj_3R_134()) return true;
    3533        return false;
    3534      }
    3535
    3536      private boolean jj_3R_127() {
    3537        if (jj_scan_token(LPAREN)) return true;
    3538        if (jj_3R_20()) return true;
    3539        if (jj_scan_token(RPAREN)) return true;
    3540        return false;
    3541      }
    3542
    3543      private boolean jj_3_7() {
    3544        if (jj_3R_19()) return true;
    3545        return false;
    3546      }
    3547
    3548      private boolean jj_3R_125() {
    3549        Token xsp;
    3550        xsp = jj_scanpos;
    3551        if (jj_3R_126()) {
    3552        jj_scanpos = xsp;
    3553        if (jj_3_7()) {
    3554        jj_scanpos = xsp;
    3555        if (jj_3R_127()) {
    3556        jj_scanpos = xsp;
    3557        if (jj_3R_128()) {
    3558        jj_scanpos = xsp;
    3559        if (jj_3R_129()) {
    3560        jj_scanpos = xsp;
    3561        if (jj_3R_130()) {
    3562        jj_scanpos = xsp;
    3563        if (jj_3R_131()) {
    3564        jj_scanpos = xsp;
    3565        if (jj_3R_132()) return true;
    3566        }
    3567        }
    3568        }
    3569        }
    3570        }
    3571        }
    3572        }
    3573        return false;
    3574      }
    3575
    3576      private boolean jj_3R_126() {
    3577        if (jj_3R_133()) return true;
    3578        return false;
    3579      }
    3580
    3581      private boolean jj_3R_54() {
    3582        if (jj_3R_20()) return true;
    3583        Token xsp;
    3584        while (true) {
    3585          xsp = jj_scanpos;
    3586          if (jj_3R_67()) { jj_scanpos = xsp; break; }
    3587        }
    3588        return false;
    3589      }
    3590
    3591      private boolean jj_3_6() {
    3592        if (jj_3R_21()) return true;
    3593        if (jj_scan_token(LPAREN)) return true;
    3594        return false;
    3595      }
    3596
    3597      private boolean jj_3R_38() {
    3598        if (jj_scan_token(NEW)) return true;
    3599        if (jj_scan_token(LPAREN)) return true;
    3600        Token xsp;
    3601        xsp = jj_scanpos;
    3602        if (jj_3R_52()) jj_scanpos = xsp;
    3603        if (jj_scan_token(RPAREN)) return true;
    3604        return false;
    3605      }
    3606
    3607      private boolean jj_3_5() {
    3608        if (jj_scan_token(SIZE)) return true;
    3609        return false;
    3610      }
    3611
    3612      private boolean jj_3R_47() {
    3613        if (jj_scan_token(SIZE)) return true;
    3614        if (jj_scan_token(LPAREN)) return true;
    3615        if (jj_scan_token(RPAREN)) return true;
    3616        return false;
    3617      }
    3618
    3619      private boolean jj_3R_36() {
    3620        if (jj_3R_41()) return true;
    3621        return false;
    3622      }
    3623
    3624      private boolean jj_3R_35() {
    3625        if (jj_3R_47()) return true;
    3626        return false;
    3627      }
    3628
    3629      private boolean jj_3R_23() {
    3630        Token xsp;
    3631        xsp = jj_scanpos;
    3632        if (jj_3R_35()) {
    3633        jj_scanpos = xsp;
    3634        if (jj_3R_36()) return true;
    3635        }
    3636        return false;
    3637      }
    3638
    3639      private boolean jj_3R_41() {
    3640        if (jj_3R_21()) return true;
    3641        if (jj_scan_token(LPAREN)) return true;
    3642        Token xsp;
    3643        xsp = jj_scanpos;
    3644        if (jj_3R_54()) jj_scanpos = xsp;
    3645        if (jj_scan_token(RPAREN)) return true;
    3646        return false;
    3647      }
    3648
    3649      private boolean jj_3R_40() {
    3650        if (jj_3R_21()) return true;
    3651        if (jj_scan_token(COLON)) return true;
    3652        if (jj_3R_21()) return true;
    3653        if (jj_scan_token(LPAREN)) return true;
    3654        Token xsp;
    3655        xsp = jj_scanpos;
    3656        if (jj_3R_53()) jj_scanpos = xsp;
    3657        if (jj_scan_token(RPAREN)) return true;
    3658        return false;
    3659      }
    3660
    3661      private boolean jj_3R_55() {
    3662        if (jj_scan_token(COMMA)) return true;
    3663        if (jj_3R_22()) return true;
    3664        return false;
    3665      }
    3666
    3667      private boolean jj_3R_135() {
    3668        if (jj_scan_token(SIZE)) return true;
    3669        if (jj_scan_token(LPAREN)) return true;
    3670        if (jj_3R_20()) return true;
    3671        if (jj_scan_token(RPAREN)) return true;
    3672        return false;
    3673      }
    3674
    3675      private boolean jj_3R_56() {
    3676        if (jj_scan_token(COMMA)) return true;
    3677        if (jj_3R_20()) return true;
    3678        return false;
    3679      }
    3680
    3681      private boolean jj_3R_141() {
    3682        if (jj_scan_token(EMPTY)) return true;
    3683        if (jj_3R_19()) return true;
    3684        return false;
    3685      }
    3686
    3687      private boolean jj_3_4() {
    3688        if (jj_scan_token(EMPTY)) return true;
    3689        if (jj_scan_token(LPAREN)) return true;
    3690        if (jj_3R_20()) return true;
    3691        if (jj_scan_token(RPAREN)) return true;
    3692        return false;
    3693      }
    3694
    3695      private boolean jj_3R_134() {
    3696        Token xsp;
    3697        xsp = jj_scanpos;
    3698        if (jj_3_4()) {
    3699        jj_scanpos = xsp;
    3700        if (jj_3R_141()) return true;
    3701        }
    3702        return false;
    3703      }
    3704
    3705      private boolean jj_3R_22() {
    3706        if (jj_3R_20()) return true;
    3707        if (jj_scan_token(COLON)) return true;
    3708        if (jj_3R_20()) return true;
    3709        return false;
    3710      }
    3711
    3712      private boolean jj_3R_42() {
    3713        if (jj_scan_token(LCURLY)) return true;
    3714        if (jj_3R_22()) return true;
    3715        Token xsp;
    3716        while (true) {
    3717          xsp = jj_scanpos;
    3718          if (jj_3R_55()) { jj_scanpos = xsp; break; }
    3719        }
    3720        if (jj_scan_token(RCURLY)) return true;
    3721        return false;
    3722      }
    3723
    3724      private boolean jj_3R_43() {
    3725        if (jj_scan_token(LBRACKET)) return true;
    3726        if (jj_3R_20()) return true;
    3727        Token xsp;
    3728        while (true) {
    3729          xsp = jj_scanpos;
    3730          if (jj_3R_56()) { jj_scanpos = xsp; break; }
    3731        }
    3732        if (jj_scan_token(RBRACKET)) return true;
    3733        return false;
    3734      }
    3735
    3736      private boolean jj_3R_144() {
    3737        if (jj_scan_token(STRING_LITERAL)) return true;
    3738        return false;
    3739      }
    3740
    3741      private boolean jj_3R_142() {
    3742        if (jj_scan_token(FLOAT_LITERAL)) return true;
    3743        return false;
    3744      }
    3745
    3746      private boolean jj_3R_77() {
    3747        if (jj_scan_token(INTEGER_LITERAL)) return true;
    3748        return false;
    3749      }
    3750
    3751      private boolean jj_3R_147() {
    3752        if (jj_scan_token(FALSE)) return true;
    3753        return false;
    3754      }
    3755
    3756      private boolean jj_3R_146() {
    3757        if (jj_scan_token(TRUE)) return true;
    3758        return false;
    3759      }
    3760
    3761      private boolean jj_3R_143() {
    3762        Token xsp;
    3763        xsp = jj_scanpos;
    3764        if (jj_3R_146()) {
    3765        jj_scanpos = xsp;
    3766        if (jj_3R_147()) return true;
    3767        }
    3768        return false;
    3769      }
    3770
    3771      private boolean jj_3R_145() {
    3772        if (jj_scan_token(NULL)) return true;
    3773        return false;
    3774      }
    3775
    3776      /** Generated Token Manager. */
    3777      public ParserTokenManager token_source;
    3778      SimpleCharStream jj_input_stream;
    3779      /** Current token. */
    3780      public Token token;
    3781      /** Next token. */
    3782      public Token jj_nt;
    3783      private int jj_ntk;
    3784      private Token jj_scanpos, jj_lastpos;
    3785      private int jj_la;
    3786      private int jj_gen;
    3787      final private int[] jj_la1 = new int[42];
    3788      static private int[] jj_la1_0;
    3789      static private int[] jj_la1_1;
    3790      static private int[] jj_la1_2;
    3791      static {
    3792          jj_la1_init_0();
    3793          jj_la1_init_1();
    3794          jj_la1_init_2();
    3795       }
    3796       private static void jj_la1_init_0() {
    3797          jj_la1_0 = new int[] {0x157fee00,0x10000000,0x57fee00,0x157fee00,0x57f0600,0x1000,0x6000,0x57f0600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x57f0600,0x380600,0x300000,0x40000000,0x40000000,0x20000,0x40000000,0x57f0600,0x40000000,0x57f0600,0x40000000,0x57f0600,0x380600,0x0,0x200,0x40200,0x0,};
    3798       }
    3799       private static void jj_la1_init_1() {
    3800          jj_la1_1 = new int[] {0x82000000,0x0,0x82000000,0x82000000,0x82000000,0x0,0x0,0x82000000,0x6,0x6,0x18,0x18,0x60,0x60,0x80,0x100,0x200,0x3c00,0x3c00,0xffc000,0xffc000,0x3000000,0x3000000,0x7c000000,0x7c000000,0x82000000,0x0,0x0,0x0,0x0,0x0,0x0,0x82000000,0x0,0x82000000,0x0,0x82000000,0x0,0x0,0x0,0x0,0x0,};
    3801       }
    3802       private static void jj_la1_init_2() {
    3803          jj_la1_2 = new int[] {0x4b,0x0,0x4b,0x4b,0x4b,0x0,0x0,0x4b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4b,0x40,0x0,0x0,0x0,0x0,0x0,0x4b,0x0,0x4b,0x0,0x4b,0x40,0x4,0x8,0x8,0x8,};
    3804       }
    3805      final private JJCalls[] jj_2_rtns = new JJCalls[22];
    3806      private boolean jj_rescan = false;
    3807      private int jj_gc = 0;
    3808
    3809      /** Constructor with InputStream. */
    3810      public Parser(java.io.InputStream stream) {
    3811         this(stream, null);
    3812      }
    3813      /** Constructor with InputStream and supplied encoding */
    3814      public Parser(java.io.InputStream stream, String encoding) {
    3815        try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    3816        token_source = new ParserTokenManager(jj_input_stream);
    3817        token = new Token();
    3818        jj_ntk = -1;
    3819        jj_gen = 0;
    3820        for (int i = 0; i < 42; i++) jj_la1[i] = -1;
    3821        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3822      }
    3823
    3824      /** Reinitialise. */
    3825      public void ReInit(java.io.InputStream stream) {
    3826         ReInit(stream, null);
    3827      }
    3828      /** Reinitialise. */
    3829      public void ReInit(java.io.InputStream stream, String encoding) {
    3830        try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    3831        token_source.ReInit(jj_input_stream);
    3832        token = new Token();
    3833        jj_ntk = -1;
    3834        jjtree.reset();
    3835        jj_gen = 0;
    3836        for (int i = 0; i < 42; i++) jj_la1[i] = -1;
    3837        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3838      }
    3839
    3840      /** Constructor. */
    3841      public Parser(java.io.Reader stream) {
    3842        jj_input_stream = new SimpleCharStream(stream, 1, 1);
    3843        token_source = new ParserTokenManager(jj_input_stream);
    3844        token = new Token();
    3845        jj_ntk = -1;
    3846        jj_gen = 0;
    3847        for (int i = 0; i < 42; i++) jj_la1[i] = -1;
    3848        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3849      }
    3850
    3851      /** Reinitialise. */
    3852      public void ReInit(java.io.Reader stream) {
    3853        jj_input_stream.ReInit(stream, 1, 1);
    3854        token_source.ReInit(jj_input_stream);
    3855        token = new Token();
    3856        jj_ntk = -1;
    3857        jjtree.reset();
    3858        jj_gen = 0;
    3859        for (int i = 0; i < 42; i++) jj_la1[i] = -1;
    3860        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3861      }
    3862
    3863      /** Constructor with generated Token Manager. */
    3864      public Parser(ParserTokenManager tm) {
    3865        token_source = tm;
    3866        token = new Token();
    3867        jj_ntk = -1;
    3868        jj_gen = 0;
    3869        for (int i = 0; i < 42; i++) jj_la1[i] = -1;
    3870        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3871      }
    3872
    3873      /** Reinitialise. */
    3874      public void ReInit(ParserTokenManager tm) {
    3875        token_source = tm;
    3876        token = new Token();
    3877        jj_ntk = -1;
    3878        jjtree.reset();
    3879        jj_gen = 0;
    3880        for (int i = 0; i < 42; i++) jj_la1[i] = -1;
    3881        for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3882      }
    3883
    3884      private Token jj_consume_token(int kind) throws ParseException {
    3885        Token oldToken;
    3886        if ((oldToken = token).next != null) token = token.next;
    3887        else token = token.next = token_source.getNextToken();
    3888        jj_ntk = -1;
    3889        if (token.kind == kind) {
    3890          jj_gen++;
    3891          if (++jj_gc > 100) {
    3892            jj_gc = 0;
    3893            for (int i = 0; i < jj_2_rtns.length; i++) {
    3894              JJCalls c = jj_2_rtns[i];
    3895              while (c != null) {
    3896                if (c.gen < jj_gen) c.first = null;
    3897                c = c.next;
    3898              }
    3899            }
    3900          }
    3901          return token;
    3902        }
    3903        token = oldToken;
    3904        jj_kind = kind;
    3905        throw generateParseException();
    3906      }
    3907
    3908      static private final class LookaheadSuccess extends java.lang.Error { }
    3909      final private LookaheadSuccess jj_ls = new LookaheadSuccess();
    3910      private boolean jj_scan_token(int kind) {
    3911        if (jj_scanpos == jj_lastpos) {
    3912          jj_la--;
    3913          if (jj_scanpos.next == null) {
    3914            jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    3915          } else {
    3916            jj_lastpos = jj_scanpos = jj_scanpos.next;
    3917          }
    3918        } else {
    3919          jj_scanpos = jj_scanpos.next;
    3920        }
    3921        if (jj_rescan) {
    3922          int i = 0; Token tok = token;
    3923          while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    3924          if (tok != null) jj_add_error_token(kind, i);
    3925        }
    3926        if (jj_scanpos.kind != kind) return true;
    3927        if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    3928        return false;
    3929      }
    3930
    3931
    3932    /** Get the next Token. */
    3933      final public Token getNextToken() {
    3934        if (token.next != null) token = token.next;
    3935        else token = token.next = token_source.getNextToken();
    3936        jj_ntk = -1;
    3937        jj_gen++;
    3938        return token;
    3939      }
    3940
    3941    /** Get the specific Token. */
    3942      final public Token getToken(int index) {
    3943        Token t = token;
    3944        for (int i = 0; i < index; i++) {
    3945          if (t.next != null) t = t.next;
    3946          else t = t.next = token_source.getNextToken();
    3947        }
    3948        return t;
    3949      }
    3950
    3951      private int jj_ntk() {
    3952        if ((jj_nt=token.next) == null)
    3953          return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    3954        else
    3955          return (jj_ntk = jj_nt.kind);
    3956      }
    3957
    3958      private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
    3959      private int[] jj_expentry;
    3960      private int jj_kind = -1;
    3961      private int[] jj_lasttokens = new int[100];
    3962      private int jj_endpos;
    3963
    3964      private void jj_add_error_token(int kind, int pos) {
    3965        if (pos >= 100) return;
    3966        if (pos == jj_endpos + 1) {
    3967          jj_lasttokens[jj_endpos++] = kind;
    3968        } else if (jj_endpos != 0) {
    3969          jj_expentry = new int[jj_endpos];
    3970          for (int i = 0; i < jj_endpos; i++) {
    3971            jj_expentry[i] = jj_lasttokens[i];
    3972          }
    3973          jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
    3974            int[] oldentry = (int[])(it.next());
    3975            if (oldentry.length == jj_expentry.length) {
    3976              for (int i = 0; i < jj_expentry.length; i++) {
    3977                if (oldentry[i] != jj_expentry[i]) {
    3978                  continue jj_entries_loop;
    3979                }
    3980              }
    3981              jj_expentries.add(jj_expentry);
    3982              break jj_entries_loop;
    3983            }
    3984          }
    3985          if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    3986        }
    3987      }
    3988
    3989      /** Generate ParseException. */
    3990      public ParseException generateParseException() {
    3991        jj_expentries.clear();
    3992        boolean[] la1tokens = new boolean[71];
    3993        if (jj_kind >= 0) {
    3994          la1tokens[jj_kind] = true;
    3995          jj_kind = -1;
    3996        }
    3997        for (int i = 0; i < 42; i++) {
    3998          if (jj_la1[i] == jj_gen) {
    3999            for (int j = 0; j < 32; j++) {
    4000              if ((jj_la1_0[i] & (1<<j)) != 0) {
    4001                la1tokens[j] = true;
    4002              }
    4003              if ((jj_la1_1[i] & (1<<j)) != 0) {
    4004                la1tokens[32+j] = true;
    4005              }
    4006              if ((jj_la1_2[i] & (1<<j)) != 0) {
    4007                la1tokens[64+j] = true;
    4008              }
    4009            }
    4010          }
    4011        }
    4012        for (int i = 0; i < 71; i++) {
    4013          if (la1tokens[i]) {
    4014            jj_expentry = new int[1];
    4015            jj_expentry[0] = i;
    4016            jj_expentries.add(jj_expentry);
    4017          }
    4018        }
    4019        jj_endpos = 0;
    4020        jj_rescan_token();
    4021        jj_add_error_token(0, 0);
    4022        int[][] exptokseq = new int[jj_expentries.size()][];
    4023        for (int i = 0; i < jj_expentries.size(); i++) {
    4024          exptokseq[i] = jj_expentries.get(i);
    4025        }
    4026        return new ParseException(token, exptokseq, tokenImage);
    4027      }
    4028
    4029      /** Enable tracing. */
    4030      final public void enable_tracing() {
    4031      }
    4032
    4033      /** Disable tracing. */
    4034      final public void disable_tracing() {
    4035      }
    4036
    4037      private void jj_rescan_token() {
    4038        jj_rescan = true;
    4039        for (int i = 0; i < 22; i++) {
    4040        try {
    4041          JJCalls p = jj_2_rtns[i];
    4042          do {
    4043            if (p.gen > jj_gen) {
    4044              jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    4045              switch (i) {
    4046                case 0: jj_3_1(); break;
    4047                case 1: jj_3_2(); break;
    4048                case 2: jj_3_3(); break;
    4049                case 3: jj_3_4(); break;
    4050                case 4: jj_3_5(); break;
    4051                case 5: jj_3_6(); break;
    4052                case 6: jj_3_7(); break;
    4053                case 7: jj_3_8(); break;
    4054                case 8: jj_3_9(); break;
    4055                case 9: jj_3_10(); break;
    4056                case 10: jj_3_11(); break;
    4057                case 11: jj_3_12(); break;
    4058                case 12: jj_3_13(); break;
    4059                case 13: jj_3_14(); break;
    4060                case 14: jj_3_15(); break;
    4061                case 15: jj_3_16(); break;
    4062                case 16: jj_3_17(); break;
    4063                case 17: jj_3_18(); break;
    4064                case 18: jj_3_19(); break;
    4065                case 19: jj_3_20(); break;
    4066                case 20: jj_3_21(); break;
    4067                case 21: jj_3_22(); break;
    4068              }
    4069            }
    4070            p = p.next;
    4071          } while (p != null);
    4072          } catch(LookaheadSuccess ls) { }
    4073        }
    4074        jj_rescan = false;
    4075      }
    4076
    4077      private void jj_save(int index, int xla) {
    4078        JJCalls p = jj_2_rtns[index];
    4079        while (p.gen > jj_gen) {
    4080          if (p.next == null) { p = p.next = new JJCalls(); break; }
    4081          p = p.next;
    4082        }
    4083        p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    4084      }
    4085
    4086      static final class JJCalls {
    4087        int gen;
    4088        Token first;
    4089        int arg;
    4090        JJCalls next;
    4091      }
    4092
    4093    }