View Javadoc

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