View Javadoc

    1   /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
    2   package org.apache.commons.jexl.parser;
    3
    4   import java.io.Reader;
    5
    6   public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants, ParserConstants {/*@bgen(jjtree)*/
    7     protected JJTParserState jjtree = new JJTParserState();public SimpleNode parse(Reader reader)
    8           throws Exception
    9       {
    10          ReInit(reader);
    11
    12          /*
    13           *  lets do the 'Unique Init' in here to be
    14           *  safe - it's a pain to remember
    15           */
    16
    17          SimpleNode tree = JexlScript();
    18          return tree;
    19      }
    20
    21  /*
    22   * Program structuring syntax follows.
    23   */
    24    final public SimpleNode JexlScript() throws ParseException {
    25   /*@bgen(jjtree) JexlScript */
    26     ASTJexlScript jjtn000 = new ASTJexlScript(this, JJTJEXLSCRIPT);
    27     boolean jjtc000 = true;
    28     jjtree.openNodeScope(jjtn000);String name;
    29      try {
    30        label_1:
    31        while (true) {
    32          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    33          case INTEGER_LITERAL:
    34          case FLOAT_LITERAL:
    35          case 9:
    36          case 11:
    37          case 12:
    38          case 14:
    39          case 36:
    40          case 42:
    41          case 43:
    42          case 44:
    43          case 45:
    44          case 46:
    45          case 47:
    46          case 48:
    47          case 49:
    48          case 51:
    49          case 52:
    50          case IDENTIFIER:
    51          case STRING_LITERAL:
    52            ;
    53            break;
    54          default:
    55            jj_la1[0] = jj_gen;
    56            break label_1;
    57          }
    58          Statement();
    59        }
    60        jj_consume_token(0);
    61       jjtree.closeNodeScope(jjtn000, true);
    62       jjtc000 = false;
    63       {if (true) return jjtn000;}
    64      } catch (Throwable jjte000) {
    65        if (jjtc000) {
    66          jjtree.clearNodeScope(jjtn000);
    67          jjtc000 = false;
    68        } else {
    69          jjtree.popNode();
    70        }
    71        if (jjte000 instanceof RuntimeException) {
    72          {if (true) throw (RuntimeException)jjte000;}
    73        }
    74        if (jjte000 instanceof ParseException) {
    75          {if (true) throw (ParseException)jjte000;}
    76        }
    77        {if (true) throw (Error)jjte000;}
    78      } finally {
    79        if (jjtc000) {
    80          jjtree.closeNodeScope(jjtn000, true);
    81        }
    82      }
    83      throw new Error("Missing return statement in function");
    84    }
    85
    86    final public void Block() throws ParseException {
    87   /*@bgen(jjtree) Block */
    88    ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
    89    boolean jjtc000 = true;
    90    jjtree.openNodeScope(jjtn000);
    91      try {
    92        jj_consume_token(9);
    93        label_2:
    94        while (true) {
    95          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    96          case INTEGER_LITERAL:
    97          case FLOAT_LITERAL:
    98          case 9:
    99          case 11:
    100         case 12:
    101         case 14:
    102         case 36:
    103         case 42:
    104         case 43:
    105         case 44:
    106         case 45:
    107         case 46:
    108         case 47:
    109         case 48:
    110         case 49:
    111         case 51:
    112         case 52:
    113         case IDENTIFIER:
    114         case STRING_LITERAL:
    115           ;
    116           break;
    117         default:
    118           jj_la1[1] = jj_gen;
    119           break label_2;
    120         }
    121         Statement();
    122       }
    123       jj_consume_token(10);
    124     } catch (Throwable jjte000) {
    125     if (jjtc000) {
    126       jjtree.clearNodeScope(jjtn000);
    127       jjtc000 = false;
    128     } else {
    129       jjtree.popNode();
    130     }
    131     if (jjte000 instanceof RuntimeException) {
    132       {if (true) throw (RuntimeException)jjte000;}
    133     }
    134     if (jjte000 instanceof ParseException) {
    135       {if (true) throw (ParseException)jjte000;}
    136     }
    137     {if (true) throw (Error)jjte000;}
    138     } finally {
    139     if (jjtc000) {
    140       jjtree.closeNodeScope(jjtn000, true);
    141     }
    142     }
    143   }
    144
    145   final public void EmptyFunction() throws ParseException {
    146                         /*@bgen(jjtree) EmptyFunction */
    147   ASTEmptyFunction jjtn000 = new ASTEmptyFunction(this, JJTEMPTYFUNCTION);
    148   boolean jjtc000 = true;
    149   jjtree.openNodeScope(jjtn000);
    150     try {
    151       jj_consume_token(11);
    152       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    153       case IDENTIFIER:
    154         Reference();
    155         break;
    156       case 12:
    157         jj_consume_token(12);
    158         Reference();
    159         jj_consume_token(13);
    160         break;
    161       default:
    162         jj_la1[2] = jj_gen;
    163         jj_consume_token(-1);
    164         throw new ParseException();
    165       }
    166     } catch (Throwable jjte000) {
    167       if (jjtc000) {
    168         jjtree.clearNodeScope(jjtn000);
    169         jjtc000 = false;
    170       } else {
    171         jjtree.popNode();
    172       }
    173       if (jjte000 instanceof RuntimeException) {
    174         {if (true) throw (RuntimeException)jjte000;}
    175       }
    176       if (jjte000 instanceof ParseException) {
    177         {if (true) throw (ParseException)jjte000;}
    178       }
    179       {if (true) throw (Error)jjte000;}
    180     } finally {
    181       if (jjtc000) {
    182         jjtree.closeNodeScope(jjtn000, true);
    183       }
    184     }
    185   }
    186
    187   final public void SizeFunction() throws ParseException {
    188                        /*@bgen(jjtree) SizeFunction */
    189   ASTSizeFunction jjtn000 = new ASTSizeFunction(this, JJTSIZEFUNCTION);
    190   boolean jjtc000 = true;
    191   jjtree.openNodeScope(jjtn000);
    192     try {
    193       jj_consume_token(14);
    194       jj_consume_token(12);
    195       Reference();
    196       jj_consume_token(13);
    197     } catch (Throwable jjte000) {
    198       if (jjtc000) {
    199         jjtree.clearNodeScope(jjtn000);
    200         jjtc000 = false;
    201       } else {
    202         jjtree.popNode();
    203       }
    204       if (jjte000 instanceof RuntimeException) {
    205         {if (true) throw (RuntimeException)jjte000;}
    206       }
    207       if (jjte000 instanceof ParseException) {
    208         {if (true) throw (ParseException)jjte000;}
    209       }
    210       {if (true) throw (Error)jjte000;}
    211     } finally {
    212       if (jjtc000) {
    213         jjtree.closeNodeScope(jjtn000, true);
    214       }
    215     }
    216   }
    217
    218   final public void Identifier() throws ParseException {
    219  /*@bgen(jjtree) Identifier */
    220    ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
    221    boolean jjtc000 = true;
    222    jjtree.openNodeScope(jjtn000);Token t;
    223     try {
    224       t = jj_consume_token(IDENTIFIER);
    225       jjtree.closeNodeScope(jjtn000, true);
    226       jjtc000 = false;
    227        jjtn000.val = t.image;
    228     } finally {
    229       if (jjtc000) {
    230         jjtree.closeNodeScope(jjtn000, true);
    231       }
    232     }
    233   }
    234
    235 /*
    236  * Expression syntax follows.
    237  */
    238   final public void Expression() throws ParseException {
    239                      /*@bgen(jjtree) Expression */
    240   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
    241   boolean jjtc000 = true;
    242   jjtree.openNodeScope(jjtn000);
    243     try {
    244       if (jj_2_1(2147483647)) {
    245         Assignment();
    246       } else {
    247         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    248         case INTEGER_LITERAL:
    249         case FLOAT_LITERAL:
    250         case 11:
    251         case 12:
    252         case 14:
    253         case 36:
    254         case 42:
    255         case 43:
    256         case 44:
    257         case 45:
    258         case 46:
    259         case 47:
    260         case IDENTIFIER:
    261         case STRING_LITERAL:
    262           ConditionalOrExpression();
    263           break;
    264         default:
    265           jj_la1[3] = jj_gen;
    266           jj_consume_token(-1);
    267           throw new ParseException();
    268         }
    269       }
    270     } catch (Throwable jjte000) {
    271     if (jjtc000) {
    272       jjtree.clearNodeScope(jjtn000);
    273       jjtc000 = false;
    274     } else {
    275       jjtree.popNode();
    276     }
    277     if (jjte000 instanceof RuntimeException) {
    278       {if (true) throw (RuntimeException)jjte000;}
    279     }
    280     if (jjte000 instanceof ParseException) {
    281       {if (true) throw (ParseException)jjte000;}
    282     }
    283     {if (true) throw (Error)jjte000;}
    284     } finally {
    285     if (jjtc000) {
    286       jjtree.closeNodeScope(jjtn000, true);
    287     }
    288     }
    289   }
    290
    291   final public void Assignment() throws ParseException {
    292  /*@bgen(jjtree) #Assignment( 2) */
    293   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
    294   boolean jjtc000 = true;
    295   jjtree.openNodeScope(jjtn000);
    296     try {
    297       PrimaryExpression();
    298       jj_consume_token(15);
    299       Expression();
    300     } catch (Throwable jjte000) {
    301     if (jjtc000) {
    302       jjtree.clearNodeScope(jjtn000);
    303       jjtc000 = false;
    304     } else {
    305       jjtree.popNode();
    306     }
    307     if (jjte000 instanceof RuntimeException) {
    308       {if (true) throw (RuntimeException)jjte000;}
    309     }
    310     if (jjte000 instanceof ParseException) {
    311       {if (true) throw (ParseException)jjte000;}
    312     }
    313     {if (true) throw (Error)jjte000;}
    314     } finally {
    315     if (jjtc000) {
    316       jjtree.closeNodeScope(jjtn000,  2);
    317     }
    318     }
    319   }
    320
    321   final public void ConditionalOrExpression() throws ParseException {
    322     ConditionalAndExpression();
    323     label_3:
    324     while (true) {
    325       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    326       case 16:
    327       case 17:
    328         ;
    329         break;
    330       default:
    331         jj_la1[4] = jj_gen;
    332         break label_3;
    333       }
    334       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    335       case 16:
    336         jj_consume_token(16);
    337            ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
    338            boolean jjtc001 = true;
    339            jjtree.openNodeScope(jjtn001);
    340         try {
    341           ConditionalAndExpression();
    342         } catch (Throwable jjte001) {
    343            if (jjtc001) {
    344              jjtree.clearNodeScope(jjtn001);
    345              jjtc001 = false;
    346            } else {
    347              jjtree.popNode();
    348            }
    349            if (jjte001 instanceof RuntimeException) {
    350              {if (true) throw (RuntimeException)jjte001;}
    351            }
    352            if (jjte001 instanceof ParseException) {
    353              {if (true) throw (ParseException)jjte001;}
    354            }
    355            {if (true) throw (Error)jjte001;}
    356         } finally {
    357            if (jjtc001) {
    358              jjtree.closeNodeScope(jjtn001,  2);
    359            }
    360         }
    361         break;
    362       case 17:
    363         jj_consume_token(17);
    364            ASTOrNode jjtn002 = new ASTOrNode(this, JJTORNODE);
    365            boolean jjtc002 = true;
    366            jjtree.openNodeScope(jjtn002);
    367         try {
    368           ConditionalAndExpression();
    369         } catch (Throwable jjte002) {
    370            if (jjtc002) {
    371              jjtree.clearNodeScope(jjtn002);
    372              jjtc002 = false;
    373            } else {
    374              jjtree.popNode();
    375            }
    376            if (jjte002 instanceof RuntimeException) {
    377              {if (true) throw (RuntimeException)jjte002;}
    378            }
    379            if (jjte002 instanceof ParseException) {
    380              {if (true) throw (ParseException)jjte002;}
    381            }
    382            {if (true) throw (Error)jjte002;}
    383         } finally {
    384            if (jjtc002) {
    385              jjtree.closeNodeScope(jjtn002,  2);
    386            }
    387         }
    388         break;
    389       default:
    390         jj_la1[5] = jj_gen;
    391         jj_consume_token(-1);
    392         throw new ParseException();
    393       }
    394     }
    395   }
    396
    397   final public void ConditionalAndExpression() throws ParseException {
    398     InclusiveOrExpression();
    399     label_4:
    400     while (true) {
    401       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    402       case 18:
    403       case 19:
    404         ;
    405         break;
    406       default:
    407         jj_la1[6] = jj_gen;
    408         break label_4;
    409       }
    410       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    411       case 18:
    412         jj_consume_token(18);
    413            ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
    414            boolean jjtc001 = true;
    415            jjtree.openNodeScope(jjtn001);
    416         try {
    417           InclusiveOrExpression();
    418         } catch (Throwable jjte001) {
    419            if (jjtc001) {
    420              jjtree.clearNodeScope(jjtn001);
    421              jjtc001 = false;
    422            } else {
    423              jjtree.popNode();
    424            }
    425            if (jjte001 instanceof RuntimeException) {
    426              {if (true) throw (RuntimeException)jjte001;}
    427            }
    428            if (jjte001 instanceof ParseException) {
    429              {if (true) throw (ParseException)jjte001;}
    430            }
    431            {if (true) throw (Error)jjte001;}
    432         } finally {
    433            if (jjtc001) {
    434              jjtree.closeNodeScope(jjtn001,  2);
    435            }
    436         }
    437         break;
    438       case 19:
    439         jj_consume_token(19);
    440             ASTAndNode jjtn002 = new ASTAndNode(this, JJTANDNODE);
    441             boolean jjtc002 = true;
    442             jjtree.openNodeScope(jjtn002);
    443         try {
    444           InclusiveOrExpression();
    445         } catch (Throwable jjte002) {
    446             if (jjtc002) {
    447               jjtree.clearNodeScope(jjtn002);
    448               jjtc002 = false;
    449             } else {
    450               jjtree.popNode();
    451             }
    452             if (jjte002 instanceof RuntimeException) {
    453               {if (true) throw (RuntimeException)jjte002;}
    454             }
    455             if (jjte002 instanceof ParseException) {
    456               {if (true) throw (ParseException)jjte002;}
    457             }
    458             {if (true) throw (Error)jjte002;}
    459         } finally {
    460             if (jjtc002) {
    461               jjtree.closeNodeScope(jjtn002,  2);
    462             }
    463         }
    464         break;
    465       default:
    466         jj_la1[7] = jj_gen;
    467         jj_consume_token(-1);
    468         throw new ParseException();
    469       }
    470     }
    471   }
    472
    473   final public void InclusiveOrExpression() throws ParseException {
    474     ExclusiveOrExpression();
    475     label_5:
    476     while (true) {
    477       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    478       case 20:
    479         ;
    480         break;
    481       default:
    482         jj_la1[8] = jj_gen;
    483         break label_5;
    484       }
    485       jj_consume_token(20);
    486           ASTBitwiseOrNode jjtn001 = new ASTBitwiseOrNode(this, JJTBITWISEORNODE);
    487           boolean jjtc001 = true;
    488           jjtree.openNodeScope(jjtn001);
    489       try {
    490         ExclusiveOrExpression();
    491       } catch (Throwable jjte001) {
    492           if (jjtc001) {
    493             jjtree.clearNodeScope(jjtn001);
    494             jjtc001 = false;
    495           } else {
    496             jjtree.popNode();
    497           }
    498           if (jjte001 instanceof RuntimeException) {
    499             {if (true) throw (RuntimeException)jjte001;}
    500           }
    501           if (jjte001 instanceof ParseException) {
    502             {if (true) throw (ParseException)jjte001;}
    503           }
    504           {if (true) throw (Error)jjte001;}
    505       } finally {
    506           if (jjtc001) {
    507             jjtree.closeNodeScope(jjtn001,  2);
    508           }
    509       }
    510     }
    511   }
    512
    513   final public void ExclusiveOrExpression() throws ParseException {
    514     AndExpression();
    515     label_6:
    516     while (true) {
    517       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    518       case 21:
    519         ;
    520         break;
    521       default:
    522         jj_la1[9] = jj_gen;
    523         break label_6;
    524       }
    525       jj_consume_token(21);
    526           ASTBitwiseXorNode jjtn001 = new ASTBitwiseXorNode(this, JJTBITWISEXORNODE);
    527           boolean jjtc001 = true;
    528           jjtree.openNodeScope(jjtn001);
    529       try {
    530         AndExpression();
    531       } catch (Throwable jjte001) {
    532           if (jjtc001) {
    533             jjtree.clearNodeScope(jjtn001);
    534             jjtc001 = false;
    535           } else {
    536             jjtree.popNode();
    537           }
    538           if (jjte001 instanceof RuntimeException) {
    539             {if (true) throw (RuntimeException)jjte001;}
    540           }
    541           if (jjte001 instanceof ParseException) {
    542             {if (true) throw (ParseException)jjte001;}
    543           }
    544           {if (true) throw (Error)jjte001;}
    545       } finally {
    546           if (jjtc001) {
    547             jjtree.closeNodeScope(jjtn001,  2);
    548           }
    549       }
    550     }
    551   }
    552
    553   final public void AndExpression() throws ParseException {
    554     EqualityExpression();
    555     label_7:
    556     while (true) {
    557       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    558       case 22:
    559         ;
    560         break;
    561       default:
    562         jj_la1[10] = jj_gen;
    563         break label_7;
    564       }
    565       jj_consume_token(22);
    566           ASTBitwiseAndNode jjtn001 = new ASTBitwiseAndNode(this, JJTBITWISEANDNODE);
    567           boolean jjtc001 = true;
    568           jjtree.openNodeScope(jjtn001);
    569       try {
    570         EqualityExpression();
    571       } catch (Throwable jjte001) {
    572           if (jjtc001) {
    573             jjtree.clearNodeScope(jjtn001);
    574             jjtc001 = false;
    575           } else {
    576             jjtree.popNode();
    577           }
    578           if (jjte001 instanceof RuntimeException) {
    579             {if (true) throw (RuntimeException)jjte001;}
    580           }
    581           if (jjte001 instanceof ParseException) {
    582             {if (true) throw (ParseException)jjte001;}
    583           }
    584           {if (true) throw (Error)jjte001;}
    585       } finally {
    586           if (jjtc001) {
    587             jjtree.closeNodeScope(jjtn001,  2);
    588           }
    589       }
    590     }
    591   }
    592
    593   final public void EqualityExpression() throws ParseException {
    594     RelationalExpression();
    595     label_8:
    596     while (true) {
    597       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    598       case 23:
    599       case 24:
    600       case 25:
    601       case 26:
    602         ;
    603         break;
    604       default:
    605         jj_la1[11] = jj_gen;
    606         break label_8;
    607       }
    608       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    609       case 23:
    610         jj_consume_token(23);
    611             ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
    612             boolean jjtc001 = true;
    613             jjtree.openNodeScope(jjtn001);
    614         try {
    615           RelationalExpression();
    616         } catch (Throwable jjte001) {
    617             if (jjtc001) {
    618               jjtree.clearNodeScope(jjtn001);
    619               jjtc001 = false;
    620             } else {
    621               jjtree.popNode();
    622             }
    623             if (jjte001 instanceof RuntimeException) {
    624               {if (true) throw (RuntimeException)jjte001;}
    625             }
    626             if (jjte001 instanceof ParseException) {
    627               {if (true) throw (ParseException)jjte001;}
    628             }
    629             {if (true) throw (Error)jjte001;}
    630         } finally {
    631             if (jjtc001) {
    632               jjtree.closeNodeScope(jjtn001,  2);
    633             }
    634         }
    635         break;
    636       case 24:
    637         jj_consume_token(24);
    638             ASTEQNode jjtn002 = new ASTEQNode(this, JJTEQNODE);
    639             boolean jjtc002 = true;
    640             jjtree.openNodeScope(jjtn002);
    641         try {
    642           RelationalExpression();
    643         } catch (Throwable jjte002) {
    644             if (jjtc002) {
    645               jjtree.clearNodeScope(jjtn002);
    646               jjtc002 = false;
    647             } else {
    648               jjtree.popNode();
    649             }
    650             if (jjte002 instanceof RuntimeException) {
    651               {if (true) throw (RuntimeException)jjte002;}
    652             }
    653             if (jjte002 instanceof ParseException) {
    654               {if (true) throw (ParseException)jjte002;}
    655             }
    656             {if (true) throw (Error)jjte002;}
    657         } finally {
    658             if (jjtc002) {
    659               jjtree.closeNodeScope(jjtn002,  2);
    660             }
    661         }
    662         break;
    663       case 25:
    664         jj_consume_token(25);
    665             ASTNENode jjtn003 = new ASTNENode(this, JJTNENODE);
    666             boolean jjtc003 = true;
    667             jjtree.openNodeScope(jjtn003);
    668         try {
    669           RelationalExpression();
    670         } catch (Throwable jjte003) {
    671             if (jjtc003) {
    672               jjtree.clearNodeScope(jjtn003);
    673               jjtc003 = false;
    674             } else {
    675               jjtree.popNode();
    676             }
    677             if (jjte003 instanceof RuntimeException) {
    678               {if (true) throw (RuntimeException)jjte003;}
    679             }
    680             if (jjte003 instanceof ParseException) {
    681               {if (true) throw (ParseException)jjte003;}
    682             }
    683             {if (true) throw (Error)jjte003;}
    684         } finally {
    685             if (jjtc003) {
    686               jjtree.closeNodeScope(jjtn003,  2);
    687             }
    688         }
    689         break;
    690       case 26:
    691         jj_consume_token(26);
    692             ASTNENode jjtn004 = new ASTNENode(this, JJTNENODE);
    693             boolean jjtc004 = true;
    694             jjtree.openNodeScope(jjtn004);
    695         try {
    696           RelationalExpression();
    697         } catch (Throwable jjte004) {
    698             if (jjtc004) {
    699               jjtree.clearNodeScope(jjtn004);
    700               jjtc004 = false;
    701             } else {
    702               jjtree.popNode();
    703             }
    704             if (jjte004 instanceof RuntimeException) {
    705               {if (true) throw (RuntimeException)jjte004;}
    706             }
    707             if (jjte004 instanceof ParseException) {
    708               {if (true) throw (ParseException)jjte004;}
    709             }
    710             {if (true) throw (Error)jjte004;}
    711         } finally {
    712             if (jjtc004) {
    713               jjtree.closeNodeScope(jjtn004,  2);
    714             }
    715         }
    716         break;
    717       default:
    718         jj_la1[12] = jj_gen;
    719         jj_consume_token(-1);
    720         throw new ParseException();
    721       }
    722     }
    723   }
    724
    725   final public void RelationalExpression() throws ParseException {
    726     AdditiveExpression();
    727     label_9:
    728     while (true) {
    729       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    730       case 27:
    731       case 28:
    732       case 29:
    733       case 30:
    734       case 31:
    735       case 32:
    736       case 33:
    737       case 34:
    738         ;
    739         break;
    740       default:
    741         jj_la1[13] = jj_gen;
    742         break label_9;
    743       }
    744       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    745       case 27:
    746         jj_consume_token(27);
    747           ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
    748           boolean jjtc001 = true;
    749           jjtree.openNodeScope(jjtn001);
    750         try {
    751           AdditiveExpression();
    752         } catch (Throwable jjte001) {
    753           if (jjtc001) {
    754             jjtree.clearNodeScope(jjtn001);
    755             jjtc001 = false;
    756           } else {
    757             jjtree.popNode();
    758           }
    759           if (jjte001 instanceof RuntimeException) {
    760             {if (true) throw (RuntimeException)jjte001;}
    761           }
    762           if (jjte001 instanceof ParseException) {
    763             {if (true) throw (ParseException)jjte001;}
    764           }
    765           {if (true) throw (Error)jjte001;}
    766         } finally {
    767           if (jjtc001) {
    768             jjtree.closeNodeScope(jjtn001,  2);
    769           }
    770         }
    771         break;
    772       case 28:
    773         jj_consume_token(28);
    774            ASTLTNode jjtn002 = new ASTLTNode(this, JJTLTNODE);
    775            boolean jjtc002 = true;
    776            jjtree.openNodeScope(jjtn002);
    777         try {
    778           AdditiveExpression();
    779         } catch (Throwable jjte002) {
    780            if (jjtc002) {
    781              jjtree.clearNodeScope(jjtn002);
    782              jjtc002 = false;
    783            } else {
    784              jjtree.popNode();
    785            }
    786            if (jjte002 instanceof RuntimeException) {
    787              {if (true) throw (RuntimeException)jjte002;}
    788            }
    789            if (jjte002 instanceof ParseException) {
    790              {if (true) throw (ParseException)jjte002;}
    791            }
    792            {if (true) throw (Error)jjte002;}
    793         } finally {
    794            if (jjtc002) {
    795              jjtree.closeNodeScope(jjtn002,  2);
    796            }
    797         }
    798         break;
    799       case 29:
    800         jj_consume_token(29);
    801           ASTGTNode jjtn003 = new ASTGTNode(this, JJTGTNODE);
    802           boolean jjtc003 = true;
    803           jjtree.openNodeScope(jjtn003);
    804         try {
    805           AdditiveExpression();
    806         } catch (Throwable jjte003) {
    807           if (jjtc003) {
    808             jjtree.clearNodeScope(jjtn003);
    809             jjtc003 = false;
    810           } else {
    811             jjtree.popNode();
    812           }
    813           if (jjte003 instanceof RuntimeException) {
    814             {if (true) throw (RuntimeException)jjte003;}
    815           }
    816           if (jjte003 instanceof ParseException) {
    817             {if (true) throw (ParseException)jjte003;}
    818           }
    819           {if (true) throw (Error)jjte003;}
    820         } finally {
    821           if (jjtc003) {
    822             jjtree.closeNodeScope(jjtn003,  2);
    823           }
    824         }
    825         break;
    826       case 30:
    827         jj_consume_token(30);
    828            ASTGTNode jjtn004 = new ASTGTNode(this, JJTGTNODE);
    829            boolean jjtc004 = true;
    830            jjtree.openNodeScope(jjtn004);
    831         try {
    832           AdditiveExpression();
    833         } catch (Throwable jjte004) {
    834            if (jjtc004) {
    835              jjtree.clearNodeScope(jjtn004);
    836              jjtc004 = false;
    837            } else {
    838              jjtree.popNode();
    839            }
    840            if (jjte004 instanceof RuntimeException) {
    841              {if (true) throw (RuntimeException)jjte004;}
    842            }
    843            if (jjte004 instanceof ParseException) {
    844              {if (true) throw (ParseException)jjte004;}
    845            }
    846            {if (true) throw (Error)jjte004;}
    847         } finally {
    848            if (jjtc004) {
    849              jjtree.closeNodeScope(jjtn004,  2);
    850            }
    851         }
    852         break;
    853       case 31:
    854         jj_consume_token(31);
    855            ASTLENode jjtn005 = new ASTLENode(this, JJTLENODE);
    856            boolean jjtc005 = true;
    857            jjtree.openNodeScope(jjtn005);
    858         try {
    859           AdditiveExpression();
    860         } catch (Throwable jjte005) {
    861            if (jjtc005) {
    862              jjtree.clearNodeScope(jjtn005);
    863              jjtc005 = false;
    864            } else {
    865              jjtree.popNode();
    866            }
    867            if (jjte005 instanceof RuntimeException) {
    868              {if (true) throw (RuntimeException)jjte005;}
    869            }
    870            if (jjte005 instanceof ParseException) {
    871              {if (true) throw (ParseException)jjte005;}
    872            }
    873            {if (true) throw (Error)jjte005;}
    874         } finally {
    875            if (jjtc005) {
    876              jjtree.closeNodeScope(jjtn005,  2);
    877            }
    878         }
    879         break;
    880       case 32:
    881         jj_consume_token(32);
    882            ASTLENode jjtn006 = new ASTLENode(this, JJTLENODE);
    883            boolean jjtc006 = true;
    884            jjtree.openNodeScope(jjtn006);
    885         try {
    886           AdditiveExpression();
    887         } catch (Throwable jjte006) {
    888            if (jjtc006) {
    889              jjtree.clearNodeScope(jjtn006);
    890              jjtc006 = false;
    891            } else {
    892              jjtree.popNode();
    893            }
    894            if (jjte006 instanceof RuntimeException) {
    895              {if (true) throw (RuntimeException)jjte006;}
    896            }
    897            if (jjte006 instanceof ParseException) {
    898              {if (true) throw (ParseException)jjte006;}
    899            }
    900            {if (true) throw (Error)jjte006;}
    901         } finally {
    902            if (jjtc006) {
    903              jjtree.closeNodeScope(jjtn006,  2);
    904            }
    905         }
    906         break;
    907       case 33:
    908         jj_consume_token(33);
    909            ASTGENode jjtn007 = new ASTGENode(this, JJTGENODE);
    910            boolean jjtc007 = true;
    911            jjtree.openNodeScope(jjtn007);
    912         try {
    913           AdditiveExpression();
    914         } catch (Throwable jjte007) {
    915            if (jjtc007) {
    916              jjtree.clearNodeScope(jjtn007);
    917              jjtc007 = false;
    918            } else {
    919              jjtree.popNode();
    920            }
    921            if (jjte007 instanceof RuntimeException) {
    922              {if (true) throw (RuntimeException)jjte007;}
    923            }
    924            if (jjte007 instanceof ParseException) {
    925              {if (true) throw (ParseException)jjte007;}
    926            }
    927            {if (true) throw (Error)jjte007;}
    928         } finally {
    929            if (jjtc007) {
    930              jjtree.closeNodeScope(jjtn007,  2);
    931            }
    932         }
    933         break;
    934       case 34:
    935         jj_consume_token(34);
    936            ASTGENode jjtn008 = new ASTGENode(this, JJTGENODE);
    937            boolean jjtc008 = true;
    938            jjtree.openNodeScope(jjtn008);
    939         try {
    940           AdditiveExpression();
    941         } catch (Throwable jjte008) {
    942            if (jjtc008) {
    943              jjtree.clearNodeScope(jjtn008);
    944              jjtc008 = false;
    945            } else {
    946              jjtree.popNode();
    947            }
    948            if (jjte008 instanceof RuntimeException) {
    949              {if (true) throw (RuntimeException)jjte008;}
    950            }
    951            if (jjte008 instanceof ParseException) {
    952              {if (true) throw (ParseException)jjte008;}
    953            }
    954            {if (true) throw (Error)jjte008;}
    955         } finally {
    956            if (jjtc008) {
    957              jjtree.closeNodeScope(jjtn008,  2);
    958            }
    959         }
    960         break;
    961       default:
    962         jj_la1[14] = jj_gen;
    963         jj_consume_token(-1);
    964         throw new ParseException();
    965       }
    966     }
    967   }
    968
    969   final public void AdditiveExpression() throws ParseException {
    970     MultiplicativeExpression();
    971     label_10:
    972     while (true) {
    973       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    974       case 35:
    975       case 36:
    976         ;
    977         break;
    978       default:
    979         jj_la1[15] = jj_gen;
    980         break label_10;
    981       }
    982       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    983       case 35:
    984         jj_consume_token(35);
    985           ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
    986           boolean jjtc001 = true;
    987           jjtree.openNodeScope(jjtn001);
    988         try {
    989           MultiplicativeExpression();
    990         } catch (Throwable jjte001) {
    991           if (jjtc001) {
    992             jjtree.clearNodeScope(jjtn001);
    993             jjtc001 = false;
    994           } else {
    995             jjtree.popNode();
    996           }
    997           if (jjte001 instanceof RuntimeException) {
    998             {if (true) throw (RuntimeException)jjte001;}
    999           }
    1000           if (jjte001 instanceof ParseException) {
    1001             {if (true) throw (ParseException)jjte001;}
    1002           }
    1003           {if (true) throw (Error)jjte001;}
    1004         } finally {
    1005           if (jjtc001) {
    1006             jjtree.closeNodeScope(jjtn001,  2);
    1007           }
    1008         }
    1009         break;
    1010       case 36:
    1011         jj_consume_token(36);
    1012           ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
    1013           boolean jjtc002 = true;
    1014           jjtree.openNodeScope(jjtn002);
    1015         try {
    1016           MultiplicativeExpression();
    1017         } catch (Throwable jjte002) {
    1018           if (jjtc002) {
    1019             jjtree.clearNodeScope(jjtn002);
    1020             jjtc002 = false;
    1021           } else {
    1022             jjtree.popNode();
    1023           }
    1024           if (jjte002 instanceof RuntimeException) {
    1025             {if (true) throw (RuntimeException)jjte002;}
    1026           }
    1027           if (jjte002 instanceof ParseException) {
    1028             {if (true) throw (ParseException)jjte002;}
    1029           }
    1030           {if (true) throw (Error)jjte002;}
    1031         } finally {
    1032           if (jjtc002) {
    1033             jjtree.closeNodeScope(jjtn002,  2);
    1034           }
    1035         }
    1036         break;
    1037       default:
    1038         jj_la1[16] = jj_gen;
    1039         jj_consume_token(-1);
    1040         throw new ParseException();
    1041       }
    1042     }
    1043   }
    1044
    1045   final public void MultiplicativeExpression() throws ParseException {
    1046     UnaryExpression();
    1047     label_11:
    1048     while (true) {
    1049       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1050       case 37:
    1051       case 38:
    1052       case 39:
    1053       case 40:
    1054       case 41:
    1055         ;
    1056         break;
    1057       default:
    1058         jj_la1[17] = jj_gen;
    1059         break label_11;
    1060       }
    1061       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1062       case 37:
    1063         jj_consume_token(37);
    1064           ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
    1065           boolean jjtc001 = true;
    1066           jjtree.openNodeScope(jjtn001);
    1067         try {
    1068           UnaryExpression();
    1069         } catch (Throwable jjte001) {
    1070           if (jjtc001) {
    1071             jjtree.clearNodeScope(jjtn001);
    1072             jjtc001 = false;
    1073           } else {
    1074             jjtree.popNode();
    1075           }
    1076           if (jjte001 instanceof RuntimeException) {
    1077             {if (true) throw (RuntimeException)jjte001;}
    1078           }
    1079           if (jjte001 instanceof ParseException) {
    1080             {if (true) throw (ParseException)jjte001;}
    1081           }
    1082           {if (true) throw (Error)jjte001;}
    1083         } finally {
    1084           if (jjtc001) {
    1085             jjtree.closeNodeScope(jjtn001,  2);
    1086           }
    1087         }
    1088         break;
    1089       case 38:
    1090         jj_consume_token(38);
    1091           ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
    1092           boolean jjtc002 = true;
    1093           jjtree.openNodeScope(jjtn002);
    1094         try {
    1095           UnaryExpression();
    1096         } catch (Throwable jjte002) {
    1097           if (jjtc002) {
    1098             jjtree.clearNodeScope(jjtn002);
    1099             jjtc002 = false;
    1100           } else {
    1101             jjtree.popNode();
    1102           }
    1103           if (jjte002 instanceof RuntimeException) {
    1104             {if (true) throw (RuntimeException)jjte002;}
    1105           }
    1106           if (jjte002 instanceof ParseException) {
    1107             {if (true) throw (ParseException)jjte002;}
    1108           }
    1109           {if (true) throw (Error)jjte002;}
    1110         } finally {
    1111           if (jjtc002) {
    1112             jjtree.closeNodeScope(jjtn002,  2);
    1113           }
    1114         }
    1115         break;
    1116       case 39:
    1117         jj_consume_token(39);
    1118             ASTDivNode jjtn003 = new ASTDivNode(this, JJTDIVNODE);
    1119             boolean jjtc003 = true;
    1120             jjtree.openNodeScope(jjtn003);
    1121         try {
    1122           UnaryExpression();
    1123         } catch (Throwable jjte003) {
    1124             if (jjtc003) {
    1125               jjtree.clearNodeScope(jjtn003);
    1126               jjtc003 = false;
    1127             } else {
    1128               jjtree.popNode();
    1129             }
    1130             if (jjte003 instanceof RuntimeException) {
    1131               {if (true) throw (RuntimeException)jjte003;}
    1132             }
    1133             if (jjte003 instanceof ParseException) {
    1134               {if (true) throw (ParseException)jjte003;}
    1135             }
    1136             {if (true) throw (Error)jjte003;}
    1137         } finally {
    1138             if (jjtc003) {
    1139               jjtree.closeNodeScope(jjtn003,  2);
    1140             }
    1141         }
    1142         break;
    1143       case 40:
    1144         jj_consume_token(40);
    1145           ASTModNode jjtn004 = new ASTModNode(this, JJTMODNODE);
    1146           boolean jjtc004 = true;
    1147           jjtree.openNodeScope(jjtn004);
    1148         try {
    1149           UnaryExpression();
    1150         } catch (Throwable jjte004) {
    1151           if (jjtc004) {
    1152             jjtree.clearNodeScope(jjtn004);
    1153             jjtc004 = false;
    1154           } else {
    1155             jjtree.popNode();
    1156           }
    1157           if (jjte004 instanceof RuntimeException) {
    1158             {if (true) throw (RuntimeException)jjte004;}
    1159           }
    1160           if (jjte004 instanceof ParseException) {
    1161             {if (true) throw (ParseException)jjte004;}
    1162           }
    1163           {if (true) throw (Error)jjte004;}
    1164         } finally {
    1165           if (jjtc004) {
    1166             jjtree.closeNodeScope(jjtn004,  2);
    1167           }
    1168         }
    1169         break;
    1170       case 41:
    1171         jj_consume_token(41);
    1172             ASTModNode jjtn005 = new ASTModNode(this, JJTMODNODE);
    1173             boolean jjtc005 = true;
    1174             jjtree.openNodeScope(jjtn005);
    1175         try {
    1176           UnaryExpression();
    1177         } catch (Throwable jjte005) {
    1178             if (jjtc005) {
    1179               jjtree.clearNodeScope(jjtn005);
    1180               jjtc005 = false;
    1181             } else {
    1182               jjtree.popNode();
    1183             }
    1184             if (jjte005 instanceof RuntimeException) {
    1185               {if (true) throw (RuntimeException)jjte005;}
    1186             }
    1187             if (jjte005 instanceof ParseException) {
    1188               {if (true) throw (ParseException)jjte005;}
    1189             }
    1190             {if (true) throw (Error)jjte005;}
    1191         } finally {
    1192             if (jjtc005) {
    1193               jjtree.closeNodeScope(jjtn005,  2);
    1194             }
    1195         }
    1196         break;
    1197       default:
    1198         jj_la1[18] = jj_gen;
    1199         jj_consume_token(-1);
    1200         throw new ParseException();
    1201       }
    1202     }
    1203   }
    1204
    1205   final public void UnaryExpression() throws ParseException {
    1206     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1207     case 36:
    1208       jj_consume_token(36);
    1209         ASTUnaryMinusNode jjtn001 = new ASTUnaryMinusNode(this, JJTUNARYMINUSNODE);
    1210         boolean jjtc001 = true;
    1211         jjtree.openNodeScope(jjtn001);
    1212       try {
    1213         UnaryExpression();
    1214       } catch (Throwable jjte001) {
    1215         if (jjtc001) {
    1216           jjtree.clearNodeScope(jjtn001);
    1217           jjtc001 = false;
    1218         } else {
    1219           jjtree.popNode();
    1220         }
    1221         if (jjte001 instanceof RuntimeException) {
    1222           {if (true) throw (RuntimeException)jjte001;}
    1223         }
    1224         if (jjte001 instanceof ParseException) {
    1225           {if (true) throw (ParseException)jjte001;}
    1226         }
    1227         {if (true) throw (Error)jjte001;}
    1228       } finally {
    1229         if (jjtc001) {
    1230           jjtree.closeNodeScope(jjtn001,  1);
    1231         }
    1232       }
    1233       break;
    1234     case 42:
    1235       jj_consume_token(42);
    1236         ASTBitwiseComplNode jjtn002 = new ASTBitwiseComplNode(this, JJTBITWISECOMPLNODE);
    1237         boolean jjtc002 = true;
    1238         jjtree.openNodeScope(jjtn002);
    1239       try {
    1240         UnaryExpression();
    1241       } catch (Throwable jjte002) {
    1242         if (jjtc002) {
    1243           jjtree.clearNodeScope(jjtn002);
    1244           jjtc002 = false;
    1245         } else {
    1246           jjtree.popNode();
    1247         }
    1248         if (jjte002 instanceof RuntimeException) {
    1249           {if (true) throw (RuntimeException)jjte002;}
    1250         }
    1251         if (jjte002 instanceof ParseException) {
    1252           {if (true) throw (ParseException)jjte002;}
    1253         }
    1254         {if (true) throw (Error)jjte002;}
    1255       } finally {
    1256         if (jjtc002) {
    1257           jjtree.closeNodeScope(jjtn002,  1);
    1258         }
    1259       }
    1260       break;
    1261     case 43:
    1262       jj_consume_token(43);
    1263         ASTNotNode jjtn003 = new ASTNotNode(this, JJTNOTNODE);
    1264         boolean jjtc003 = true;
    1265         jjtree.openNodeScope(jjtn003);
    1266       try {
    1267         UnaryExpression();
    1268       } catch (Throwable jjte003) {
    1269         if (jjtc003) {
    1270           jjtree.clearNodeScope(jjtn003);
    1271           jjtc003 = false;
    1272         } else {
    1273           jjtree.popNode();
    1274         }
    1275         if (jjte003 instanceof RuntimeException) {
    1276           {if (true) throw (RuntimeException)jjte003;}
    1277         }
    1278         if (jjte003 instanceof ParseException) {
    1279           {if (true) throw (ParseException)jjte003;}
    1280         }
    1281         {if (true) throw (Error)jjte003;}
    1282       } finally {
    1283         if (jjtc003) {
    1284           jjtree.closeNodeScope(jjtn003,  1);
    1285         }
    1286       }
    1287       break;
    1288     case 44:
    1289       jj_consume_token(44);
    1290           ASTNotNode jjtn004 = new ASTNotNode(this, JJTNOTNODE);
    1291           boolean jjtc004 = true;
    1292           jjtree.openNodeScope(jjtn004);
    1293       try {
    1294         UnaryExpression();
    1295       } catch (Throwable jjte004) {
    1296           if (jjtc004) {
    1297             jjtree.clearNodeScope(jjtn004);
    1298             jjtc004 = false;
    1299           } else {
    1300             jjtree.popNode();
    1301           }
    1302           if (jjte004 instanceof RuntimeException) {
    1303             {if (true) throw (RuntimeException)jjte004;}
    1304           }
    1305           if (jjte004 instanceof ParseException) {
    1306             {if (true) throw (ParseException)jjte004;}
    1307           }
    1308           {if (true) throw (Error)jjte004;}
    1309       } finally {
    1310           if (jjtc004) {
    1311             jjtree.closeNodeScope(jjtn004,  1);
    1312           }
    1313       }
    1314       break;
    1315     case INTEGER_LITERAL:
    1316     case FLOAT_LITERAL:
    1317     case 11:
    1318     case 12:
    1319     case 14:
    1320     case 45:
    1321     case 46:
    1322     case 47:
    1323     case IDENTIFIER:
    1324     case STRING_LITERAL:
    1325       PrimaryExpression();
    1326       break;
    1327     default:
    1328       jj_la1[19] = jj_gen;
    1329       jj_consume_token(-1);
    1330       throw new ParseException();
    1331     }
    1332   }
    1333
    1334   final public void PrimaryExpression() throws ParseException {
    1335     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1336     case INTEGER_LITERAL:
    1337     case FLOAT_LITERAL:
    1338     case 45:
    1339     case 46:
    1340     case 47:
    1341     case STRING_LITERAL:
    1342       Literal();
    1343       break;
    1344     case IDENTIFIER:
    1345       Reference();
    1346       break;
    1347     case 12:
    1348       jj_consume_token(12);
    1349       Expression();
    1350       jj_consume_token(13);
    1351       break;
    1352     case 11:
    1353       EmptyFunction();
    1354       break;
    1355     case 14:
    1356       SizeFunction();
    1357       break;
    1358     default:
    1359       jj_la1[20] = jj_gen;
    1360       jj_consume_token(-1);
    1361       throw new ParseException();
    1362     }
    1363   }
    1364
    1365   final public void Literal() throws ParseException {
    1366    Token t;
    1367     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1368     case INTEGER_LITERAL:
    1369       IntegerLiteral();
    1370       break;
    1371     case FLOAT_LITERAL:
    1372       FloatLiteral();
    1373       break;
    1374     case 46:
    1375     case 47:
    1376       BooleanLiteral();
    1377       break;
    1378     case STRING_LITERAL:
    1379       StringLiteral();
    1380       break;
    1381     case 45:
    1382       NullLiteral();
    1383       break;
    1384     default:
    1385       jj_la1[21] = jj_gen;
    1386       jj_consume_token(-1);
    1387       throw new ParseException();
    1388     }
    1389   }
    1390
    1391   final public void NullLiteral() throws ParseException {
    1392                       /*@bgen(jjtree) NullLiteral */
    1393   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
    1394   boolean jjtc000 = true;
    1395   jjtree.openNodeScope(jjtn000);
    1396     try {
    1397       jj_consume_token(45);
    1398     } finally {
    1399       if (jjtc000) {
    1400         jjtree.closeNodeScope(jjtn000, true);
    1401       }
    1402     }
    1403   }
    1404
    1405   final public void BooleanLiteral() throws ParseException {
    1406     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1407     case 46:
    1408     ASTTrueNode jjtn001 = new ASTTrueNode(this, JJTTRUENODE);
    1409     boolean jjtc001 = true;
    1410     jjtree.openNodeScope(jjtn001);
    1411       try {
    1412         jj_consume_token(46);
    1413       } finally {
    1414     if (jjtc001) {
    1415       jjtree.closeNodeScope(jjtn001, true);
    1416     }
    1417       }
    1418       break;
    1419     case 47:
    1420     ASTFalseNode jjtn002 = new ASTFalseNode(this, JJTFALSENODE);
    1421     boolean jjtc002 = true;
    1422     jjtree.openNodeScope(jjtn002);
    1423       try {
    1424         jj_consume_token(47);
    1425       } finally {
    1426     if (jjtc002) {
    1427       jjtree.closeNodeScope(jjtn002, true);
    1428     }
    1429       }
    1430       break;
    1431     default:
    1432       jj_la1[22] = jj_gen;
    1433       jj_consume_token(-1);
    1434       throw new ParseException();
    1435     }
    1436   }
    1437
    1438   final public void IntegerLiteral() throws ParseException {
    1439  /*@bgen(jjtree) IntegerLiteral */
    1440   ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
    1441   boolean jjtc000 = true;
    1442   jjtree.openNodeScope(jjtn000);Token t;
    1443     try {
    1444       t = jj_consume_token(INTEGER_LITERAL);
    1445       jjtree.closeNodeScope(jjtn000, true);
    1446       jjtc000 = false;
    1447        jjtn000.val = Integer.valueOf(t.image);
    1448     } finally {
    1449    if (jjtc000) {
    1450      jjtree.closeNodeScope(jjtn000, true);
    1451    }
    1452     }
    1453   }
    1454
    1455   final public void FloatLiteral() throws ParseException {
    1456  /*@bgen(jjtree) FloatLiteral */
    1457   ASTFloatLiteral jjtn000 = new ASTFloatLiteral(this, JJTFLOATLITERAL);
    1458   boolean jjtc000 = true;
    1459   jjtree.openNodeScope(jjtn000);Token t;
    1460     try {
    1461       t = jj_consume_token(FLOAT_LITERAL);
    1462       jjtree.closeNodeScope(jjtn000, true);
    1463       jjtc000 = false;
    1464        jjtn000.val = Float.valueOf(t.image);
    1465     } finally {
    1466    if (jjtc000) {
    1467      jjtree.closeNodeScope(jjtn000, true);
    1468    }
    1469     }
    1470   }
    1471
    1472   final public void StringLiteral() throws ParseException {
    1473  /*@bgen(jjtree) StringLiteral */
    1474    ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
    1475    boolean jjtc000 = true;
    1476    jjtree.openNodeScope(jjtn000);Token t;
    1477     try {
    1478       t = jj_consume_token(STRING_LITERAL);
    1479       jjtree.closeNodeScope(jjtn000, true);
    1480       jjtc000 = false;
    1481        jjtn000.literal = t.image.substring(1,t.image.length()-1);
    1482     } finally {
    1483    if (jjtc000) {
    1484      jjtree.closeNodeScope(jjtn000, true);
    1485    }
    1486     }
    1487   }
    1488
    1489 /*
    1490  * Statement syntax follows.
    1491  */
    1492   final public void Statement() throws ParseException {
    1493     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1494     case 48:
    1495       jj_consume_token(48);
    1496       break;
    1497     case 9:
    1498       Block();
    1499       break;
    1500     default:
    1501       jj_la1[23] = jj_gen;
    1502       if (jj_2_2(2147483647)) {
    1503         ReferenceExpression();
    1504       } else if (jj_2_3(2147483647)) {
    1505         StatementExpression();
    1506       } else {
    1507         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1508         case INTEGER_LITERAL:
    1509         case FLOAT_LITERAL:
    1510         case 11:
    1511         case 12:
    1512         case 14:
    1513         case 36:
    1514         case 42:
    1515         case 43:
    1516         case 44:
    1517         case 45:
    1518         case 46:
    1519         case 47:
    1520         case IDENTIFIER:
    1521         case STRING_LITERAL:
    1522           ExpressionExpression();
    1523           break;
    1524         case 49:
    1525           IfStatement();
    1526           break;
    1527         case 52:
    1528           ForeachStatement();
    1529           break;
    1530         case 51:
    1531           WhileStatement();
    1532           break;
    1533         default:
    1534           jj_la1[24] = jj_gen;
    1535           jj_consume_token(-1);
    1536           throw new ParseException();
    1537         }
    1538       }
    1539     }
    1540   }
    1541
    1542   final public void ExpressionExpression() throws ParseException {
    1543                                /*@bgen(jjtree) ExpressionExpression */
    1544   ASTExpressionExpression jjtn000 = new ASTExpressionExpression(this, JJTEXPRESSIONEXPRESSION);
    1545   boolean jjtc000 = true;
    1546   jjtree.openNodeScope(jjtn000);
    1547     try {
    1548       Expression();
    1549       jj_consume_token(48);
    1550     } catch (Throwable jjte000) {
    1551       if (jjtc000) {
    1552         jjtree.clearNodeScope(jjtn000);
    1553         jjtc000 = false;
    1554       } else {
    1555         jjtree.popNode();
    1556       }
    1557       if (jjte000 instanceof RuntimeException) {
    1558         {if (true) throw (RuntimeException)jjte000;}
    1559       }
    1560       if (jjte000 instanceof ParseException) {
    1561         {if (true) throw (ParseException)jjte000;}
    1562       }
    1563       {if (true) throw (Error)jjte000;}
    1564     } finally {
    1565       if (jjtc000) {
    1566         jjtree.closeNodeScope(jjtn000, true);
    1567       }
    1568     }
    1569   }
    1570
    1571   final public void StatementExpression() throws ParseException {
    1572                               /*@bgen(jjtree) StatementExpression */
    1573   ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
    1574   boolean jjtc000 = true;
    1575   jjtree.openNodeScope(jjtn000);
    1576     try {
    1577       Assignment();
    1578       jj_consume_token(48);
    1579     } catch (Throwable jjte000) {
    1580     if (jjtc000) {
    1581       jjtree.clearNodeScope(jjtn000);
    1582       jjtc000 = false;
    1583     } else {
    1584       jjtree.popNode();
    1585     }
    1586     if (jjte000 instanceof RuntimeException) {
    1587       {if (true) throw (RuntimeException)jjte000;}
    1588     }
    1589     if (jjte000 instanceof ParseException) {
    1590       {if (true) throw (ParseException)jjte000;}
    1591     }
    1592     {if (true) throw (Error)jjte000;}
    1593     } finally {
    1594     if (jjtc000) {
    1595       jjtree.closeNodeScope(jjtn000, true);
    1596     }
    1597     }
    1598   }
    1599
    1600   final public void ReferenceExpression() throws ParseException {
    1601                               /*@bgen(jjtree) ReferenceExpression */
    1602   ASTReferenceExpression jjtn000 = new ASTReferenceExpression(this, JJTREFERENCEEXPRESSION);
    1603   boolean jjtc000 = true;
    1604   jjtree.openNodeScope(jjtn000);
    1605     try {
    1606       Reference();
    1607       jj_consume_token(48);
    1608     } catch (Throwable jjte000) {
    1609     if (jjtc000) {
    1610       jjtree.clearNodeScope(jjtn000);
    1611       jjtc000 = false;
    1612     } else {
    1613       jjtree.popNode();
    1614     }
    1615     if (jjte000 instanceof RuntimeException) {
    1616       {if (true) throw (RuntimeException)jjte000;}
    1617     }
    1618     if (jjte000 instanceof ParseException) {
    1619       {if (true) throw (ParseException)jjte000;}
    1620     }
    1621     {if (true) throw (Error)jjte000;}
    1622     } finally {
    1623     if (jjtc000) {
    1624       jjtree.closeNodeScope(jjtn000, true);
    1625     }
    1626     }
    1627   }
    1628
    1629   final public void IfStatement() throws ParseException {
    1630                      /*@bgen(jjtree) IfStatement */
    1631   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
    1632   boolean jjtc000 = true;
    1633   jjtree.openNodeScope(jjtn000);
    1634     try {
    1635       jj_consume_token(49);
    1636       jj_consume_token(12);
    1637       Expression();
    1638       jj_consume_token(13);
    1639       Statement();
    1640       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1641       case 50:
    1642         jj_consume_token(50);
    1643         Statement();
    1644         break;
    1645       default:
    1646         jj_la1[25] = jj_gen;
    1647         ;
    1648       }
    1649     } catch (Throwable jjte000) {
    1650     if (jjtc000) {
    1651       jjtree.clearNodeScope(jjtn000);
    1652       jjtc000 = false;
    1653     } else {
    1654       jjtree.popNode();
    1655     }
    1656     if (jjte000 instanceof RuntimeException) {
    1657       {if (true) throw (RuntimeException)jjte000;}
    1658     }
    1659     if (jjte000 instanceof ParseException) {
    1660       {if (true) throw (ParseException)jjte000;}
    1661     }
    1662     {if (true) throw (Error)jjte000;}
    1663     } finally {
    1664     if (jjtc000) {
    1665       jjtree.closeNodeScope(jjtn000, true);
    1666     }
    1667     }
    1668   }
    1669
    1670   final public void WhileStatement() throws ParseException {
    1671  /*@bgen(jjtree) WhileStatement */
    1672   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
    1673   boolean jjtc000 = true;
    1674   jjtree.openNodeScope(jjtn000);
    1675     try {
    1676       jj_consume_token(51);
    1677       jj_consume_token(12);
    1678       Expression();
    1679       jj_consume_token(13);
    1680       Statement();
    1681     } catch (Throwable jjte000) {
    1682     if (jjtc000) {
    1683       jjtree.clearNodeScope(jjtn000);
    1684       jjtc000 = false;
    1685     } else {
    1686       jjtree.popNode();
    1687     }
    1688     if (jjte000 instanceof RuntimeException) {
    1689       {if (true) throw (RuntimeException)jjte000;}
    1690     }
    1691     if (jjte000 instanceof ParseException) {
    1692       {if (true) throw (ParseException)jjte000;}
    1693     }
    1694     {if (true) throw (Error)jjte000;}
    1695     } finally {
    1696     if (jjtc000) {
    1697       jjtree.closeNodeScope(jjtn000, true);
    1698     }
    1699     }
    1700   }
    1701
    1702   final public void ForeachStatement() throws ParseException {
    1703  /*@bgen(jjtree) ForeachStatement */
    1704   ASTForeachStatement jjtn000 = new ASTForeachStatement(this, JJTFOREACHSTATEMENT);
    1705   boolean jjtc000 = true;
    1706   jjtree.openNodeScope(jjtn000);
    1707     try {
    1708       jj_consume_token(52);
    1709       jj_consume_token(12);
    1710       Reference();
    1711       jj_consume_token(53);
    1712       Reference();
    1713       jj_consume_token(13);
    1714       Statement();
    1715     } catch (Throwable jjte000) {
    1716     if (jjtc000) {
    1717       jjtree.clearNodeScope(jjtn000);
    1718       jjtc000 = false;
    1719     } else {
    1720       jjtree.popNode();
    1721     }
    1722     if (jjte000 instanceof RuntimeException) {
    1723       {if (true) throw (RuntimeException)jjte000;}
    1724     }
    1725     if (jjte000 instanceof ParseException) {
    1726       {if (true) throw (ParseException)jjte000;}
    1727     }
    1728     {if (true) throw (Error)jjte000;}
    1729     } finally {
    1730     if (jjtc000) {
    1731       jjtree.closeNodeScope(jjtn000, true);
    1732     }
    1733     }
    1734   }
    1735
    1736   final public void Method() throws ParseException {
    1737                  /*@bgen(jjtree) Method */
    1738   ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
    1739   boolean jjtc000 = true;
    1740   jjtree.openNodeScope(jjtn000);
    1741     try {
    1742       Identifier();
    1743       jj_consume_token(12);
    1744       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1745       case INTEGER_LITERAL:
    1746       case FLOAT_LITERAL:
    1747       case 11:
    1748       case 12:
    1749       case 14:
    1750       case 36:
    1751       case 42:
    1752       case 43:
    1753       case 44:
    1754       case 45:
    1755       case 46:
    1756       case 47:
    1757       case IDENTIFIER:
    1758       case STRING_LITERAL:
    1759         Parameter();
    1760         label_12:
    1761         while (true) {
    1762           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1763           case 54:
    1764             ;
    1765             break;
    1766           default:
    1767             jj_la1[26] = jj_gen;
    1768             break label_12;
    1769           }
    1770           jj_consume_token(54);
    1771           Parameter();
    1772         }
    1773         break;
    1774       default:
    1775         jj_la1[27] = jj_gen;
    1776         ;
    1777       }
    1778       jj_consume_token(13);
    1779     } catch (Throwable jjte000) {
    1780      if (jjtc000) {
    1781        jjtree.clearNodeScope(jjtn000);
    1782        jjtc000 = false;
    1783      } else {
    1784        jjtree.popNode();
    1785      }
    1786      if (jjte000 instanceof RuntimeException) {
    1787        {if (true) throw (RuntimeException)jjte000;}
    1788      }
    1789      if (jjte000 instanceof ParseException) {
    1790        {if (true) throw (ParseException)jjte000;}
    1791      }
    1792      {if (true) throw (Error)jjte000;}
    1793     } finally {
    1794      if (jjtc000) {
    1795        jjtree.closeNodeScope(jjtn000, true);
    1796      }
    1797     }
    1798   }
    1799
    1800   final public void ArrayAccess() throws ParseException {
    1801                       /*@bgen(jjtree) ArrayAccess */
    1802   ASTArrayAccess jjtn000 = new ASTArrayAccess(this, JJTARRAYACCESS);
    1803   boolean jjtc000 = true;
    1804   jjtree.openNodeScope(jjtn000);
    1805     try {
    1806       Identifier();
    1807       label_13:
    1808       while (true) {
    1809         jj_consume_token(55);
    1810         if (jj_2_4(3)) {
    1811           Expression();
    1812         } else {
    1813           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1814           case INTEGER_LITERAL:
    1815             IntegerLiteral();
    1816             break;
    1817           case IDENTIFIER:
    1818             Reference();
    1819             break;
    1820           default:
    1821             jj_la1[28] = jj_gen;
    1822             jj_consume_token(-1);
    1823             throw new ParseException();
    1824           }
    1825         }
    1826         jj_consume_token(56);
    1827         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1828         case 55:
    1829           ;
    1830           break;
    1831         default:
    1832           jj_la1[29] = jj_gen;
    1833           break label_13;
    1834         }
    1835       }
    1836     } catch (Throwable jjte000) {
    1837       if (jjtc000) {
    1838         jjtree.clearNodeScope(jjtn000);
    1839         jjtc000 = false;
    1840       } else {
    1841         jjtree.popNode();
    1842       }
    1843       if (jjte000 instanceof RuntimeException) {
    1844         {if (true) throw (RuntimeException)jjte000;}
    1845       }
    1846       if (jjte000 instanceof ParseException) {
    1847         {if (true) throw (ParseException)jjte000;}
    1848       }
    1849       {if (true) throw (Error)jjte000;}
    1850     } finally {
    1851       if (jjtc000) {
    1852         jjtree.closeNodeScope(jjtn000, true);
    1853       }
    1854     }
    1855   }
    1856
    1857   final public void SizeMethod() throws ParseException {
    1858                      /*@bgen(jjtree) SizeMethod */
    1859   ASTSizeMethod jjtn000 = new ASTSizeMethod(this, JJTSIZEMETHOD);
    1860   boolean jjtc000 = true;
    1861   jjtree.openNodeScope(jjtn000);
    1862     try {
    1863       jj_consume_token(14);
    1864       jj_consume_token(12);
    1865       jj_consume_token(13);
    1866     } finally {
    1867           if (jjtc000) {
    1868             jjtree.closeNodeScope(jjtn000, true);
    1869           }
    1870     }
    1871   }
    1872
    1873   final public void Reference() throws ParseException {
    1874                     /*@bgen(jjtree) Reference */
    1875   ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
    1876   boolean jjtc000 = true;
    1877   jjtree.openNodeScope(jjtn000);
    1878     try {
    1879       if (jj_2_5(2147483647)) {
    1880         ArrayAccess();
    1881       } else {
    1882         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1883         case IDENTIFIER:
    1884           Identifier();
    1885           break;
    1886         default:
    1887           jj_la1[30] = jj_gen;
    1888           jj_consume_token(-1);
    1889           throw new ParseException();
    1890         }
    1891       }
    1892       label_14:
    1893       while (true) {
    1894         if (jj_2_6(2)) {
    1895           ;
    1896         } else {
    1897           break label_14;
    1898         }
    1899         jj_consume_token(57);
    1900         if (jj_2_8(2147483647)) {
    1901           ArrayAccess();
    1902         } else {
    1903           switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1904           case INTEGER_LITERAL:
    1905           case 14:
    1906           case IDENTIFIER:
    1907             if (jj_2_7(3)) {
    1908               Method();
    1909             } else {
    1910               switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1911               case 14:
    1912                 SizeMethod();
    1913                 break;
    1914               case IDENTIFIER:
    1915                 Identifier();
    1916                 break;
    1917               case INTEGER_LITERAL:
    1918                 IntegerLiteral();
    1919                 break;
    1920               default:
    1921                 jj_la1[31] = jj_gen;
    1922                 jj_consume_token(-1);
    1923                 throw new ParseException();
    1924               }
    1925             }
    1926             break;
    1927           default:
    1928             jj_la1[32] = jj_gen;
    1929             jj_consume_token(-1);
    1930             throw new ParseException();
    1931           }
    1932         }
    1933       }
    1934     } catch (Throwable jjte000) {
    1935     if (jjtc000) {
    1936       jjtree.clearNodeScope(jjtn000);
    1937       jjtc000 = false;
    1938     } else {
    1939       jjtree.popNode();
    1940     }
    1941     if (jjte000 instanceof RuntimeException) {
    1942       {if (true) throw (RuntimeException)jjte000;}
    1943     }
    1944     if (jjte000 instanceof ParseException) {
    1945       {if (true) throw (ParseException)jjte000;}
    1946     }
    1947     {if (true) throw (Error)jjte000;}
    1948     } finally {
    1949     if (jjtc000) {
    1950       jjtree.closeNodeScope(jjtn000, true);
    1951     }
    1952     }
    1953   }
    1954
    1955   final public void Parameter() throws ParseException {
    1956     if (jj_2_9(3)) {
    1957       Expression();
    1958     } else {
    1959       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    1960       case INTEGER_LITERAL:
    1961       case FLOAT_LITERAL:
    1962       case 45:
    1963       case 46:
    1964       case 47:
    1965       case STRING_LITERAL:
    1966         Literal();
    1967         break;
    1968       case IDENTIFIER:
    1969         Reference();
    1970         break;
    1971       default:
    1972         jj_la1[33] = jj_gen;
    1973         jj_consume_token(-1);
    1974         throw new ParseException();
    1975       }
    1976     }
    1977   }
    1978
    1979   final private boolean jj_2_1(int xla) {
    1980     jj_la = xla; jj_lastpos = jj_scanpos = token;
    1981     boolean retval = !jj_3_1();
    1982     jj_save(0, xla);
    1983     return retval;
    1984   }
    1985
    1986   final private boolean jj_2_2(int xla) {
    1987     jj_la = xla; jj_lastpos = jj_scanpos = token;
    1988     boolean retval = !jj_3_2();
    1989     jj_save(1, xla);
    1990     return retval;
    1991   }
    1992
    1993   final private boolean jj_2_3(int xla) {
    1994     jj_la = xla; jj_lastpos = jj_scanpos = token;
    1995     boolean retval = !jj_3_3();
    1996     jj_save(2, xla);
    1997     return retval;
    1998   }
    1999
    2000   final private boolean jj_2_4(int xla) {
    2001     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2002     boolean retval = !jj_3_4();
    2003     jj_save(3, xla);
    2004     return retval;
    2005   }
    2006
    2007   final private boolean jj_2_5(int xla) {
    2008     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2009     boolean retval = !jj_3_5();
    2010     jj_save(4, xla);
    2011     return retval;
    2012   }
    2013
    2014   final private boolean jj_2_6(int xla) {
    2015     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2016     boolean retval = !jj_3_6();
    2017     jj_save(5, xla);
    2018     return retval;
    2019   }
    2020
    2021   final private boolean jj_2_7(int xla) {
    2022     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2023     boolean retval = !jj_3_7();
    2024     jj_save(6, xla);
    2025     return retval;
    2026   }
    2027
    2028   final private boolean jj_2_8(int xla) {
    2029     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2030     boolean retval = !jj_3_8();
    2031     jj_save(7, xla);
    2032     return retval;
    2033   }
    2034
    2035   final private boolean jj_2_9(int xla) {
    2036     jj_la = xla; jj_lastpos = jj_scanpos = token;
    2037     boolean retval = !jj_3_9();
    2038     jj_save(8, xla);
    2039     return retval;
    2040   }
    2041
    2042   final private boolean jj_3R_71() {
    2043     if (jj_scan_token(17)) return true;
    2044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2045     if (jj_3R_58()) return true;
    2046     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2047     return false;
    2048   }
    2049
    2050   final private boolean jj_3R_59() {
    2051     Token xsp;
    2052     xsp = jj_scanpos;
    2053     if (jj_3R_70()) {
    2054     jj_scanpos = xsp;
    2055     if (jj_3R_71()) return true;
    2056     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2057     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2058     return false;
    2059   }
    2060
    2061   final private boolean jj_3R_70() {
    2062     if (jj_scan_token(16)) return true;
    2063     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2064     if (jj_3R_58()) return true;
    2065     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2066     return false;
    2067   }
    2068
    2069   final private boolean jj_3R_64() {
    2070     if (jj_scan_token(STRING_LITERAL)) return true;
    2071     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2072     return false;
    2073   }
    2074
    2075   final private boolean jj_3R_47() {
    2076     if (jj_3R_58()) return true;
    2077     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2078     Token xsp;
    2079     while (true) {
    2080       xsp = jj_scanpos;
    2081       if (jj_3R_59()) { jj_scanpos = xsp; break; }
    2082       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2083     }
    2084     return false;
    2085   }
    2086
    2087   final private boolean jj_3_1() {
    2088     if (jj_3R_15()) return true;
    2089     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2090     if (jj_scan_token(15)) return true;
    2091     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2092     return false;
    2093   }
    2094
    2095   final private boolean jj_3R_46() {
    2096     if (jj_3R_15()) return true;
    2097     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2098     if (jj_scan_token(15)) return true;
    2099     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2100     if (jj_3R_17()) return true;
    2101     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2102     return false;
    2103   }
    2104
    2105   final private boolean jj_3R_34() {
    2106     if (jj_3R_18()) return true;
    2107     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2108     return false;
    2109   }
    2110
    2111   final private boolean jj_3R_62() {
    2112     if (jj_scan_token(FLOAT_LITERAL)) return true;
    2113     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2114     return false;
    2115   }
    2116
    2117   final private boolean jj_3R_36() {
    2118     if (jj_3R_47()) return true;
    2119     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2120     return false;
    2121   }
    2122
    2123   final private boolean jj_3R_35() {
    2124     if (jj_3R_46()) return true;
    2125     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2126     return false;
    2127   }
    2128
    2129   final private boolean jj_3R_17() {
    2130     Token xsp;
    2131     xsp = jj_scanpos;
    2132     if (jj_3R_35()) {
    2133     jj_scanpos = xsp;
    2134     if (jj_3R_36()) return true;
    2135     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2136     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2137     return false;
    2138   }
    2139
    2140   final private boolean jj_3R_56() {
    2141     if (jj_scan_token(12)) return true;
    2142     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2143     if (jj_3R_16()) return true;
    2144     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2145     if (jj_scan_token(13)) return true;
    2146     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2147     return false;
    2148   }
    2149
    2150   final private boolean jj_3R_37() {
    2151     if (jj_scan_token(INTEGER_LITERAL)) return true;
    2152     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2153     return false;
    2154   }
    2155
    2156   final private boolean jj_3R_18() {
    2157     if (jj_scan_token(IDENTIFIER)) return true;
    2158     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2159     return false;
    2160   }
    2161
    2162   final private boolean jj_3R_73() {
    2163     if (jj_scan_token(47)) return true;
    2164     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2165     return false;
    2166   }
    2167
    2168   final private boolean jj_3R_63() {
    2169     Token xsp;
    2170     xsp = jj_scanpos;
    2171     if (jj_3R_72()) {
    2172     jj_scanpos = xsp;
    2173     if (jj_3R_73()) return true;
    2174     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2175     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2176     return false;
    2177   }
    2178
    2179   final private boolean jj_3R_72() {
    2180     if (jj_scan_token(46)) return true;
    2181     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2182     return false;
    2183   }
    2184
    2185   final private boolean jj_3R_45() {
    2186     if (jj_scan_token(14)) return true;
    2187     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2188     if (jj_scan_token(12)) return true;
    2189     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2190     if (jj_3R_16()) return true;
    2191     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2192     if (jj_scan_token(13)) return true;
    2193     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2194     return false;
    2195   }
    2196
    2197   final private boolean jj_3R_27() {
    2198     if (jj_3R_16()) return true;
    2199     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2200     return false;
    2201   }
    2202
    2203   final private boolean jj_3R_65() {
    2204     if (jj_scan_token(45)) return true;
    2205     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2206     return false;
    2207   }
    2208
    2209   final private boolean jj_3R_55() {
    2210     if (jj_3R_16()) return true;
    2211     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2212     return false;
    2213   }
    2214
    2215   final private boolean jj_3R_41() {
    2216     if (jj_3R_37()) return true;
    2217     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2218     return false;
    2219   }
    2220
    2221   final private boolean jj_3R_44() {
    2222     if (jj_scan_token(11)) return true;
    2223     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2224     Token xsp;
    2225     xsp = jj_scanpos;
    2226     if (jj_3R_55()) {
    2227     jj_scanpos = xsp;
    2228     if (jj_3R_56()) return true;
    2229     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2230     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2231     return false;
    2232   }
    2233
    2234   final private boolean jj_3R_21() {
    2235     if (jj_3R_16()) return true;
    2236     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2237     return false;
    2238   }
    2239
    2240   final private boolean jj_3R_54() {
    2241     if (jj_3R_65()) return true;
    2242     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2243     return false;
    2244   }
    2245
    2246   final private boolean jj_3R_53() {
    2247     if (jj_3R_64()) return true;
    2248     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2249     return false;
    2250   }
    2251
    2252   final private boolean jj_3R_67() {
    2253     if (jj_3R_16()) return true;
    2254     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2255     return false;
    2256   }
    2257
    2258   final private boolean jj_3R_52() {
    2259     if (jj_3R_63()) return true;
    2260     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2261     return false;
    2262   }
    2263
    2264   final private boolean jj_3R_61() {
    2265     if (jj_3R_16()) return true;
    2266     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2267     return false;
    2268   }
    2269
    2270   final private boolean jj_3R_51() {
    2271     if (jj_3R_62()) return true;
    2272     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2273     return false;
    2274   }
    2275
    2276   final private boolean jj_3R_43() {
    2277     Token xsp;
    2278     xsp = jj_scanpos;
    2279     if (jj_3R_50()) {
    2280     jj_scanpos = xsp;
    2281     if (jj_3R_51()) {
    2282     jj_scanpos = xsp;
    2283     if (jj_3R_52()) {
    2284     jj_scanpos = xsp;
    2285     if (jj_3R_53()) {
    2286     jj_scanpos = xsp;
    2287     if (jj_3R_54()) return true;
    2288     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2289     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2290     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2291     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2292     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2293     return false;
    2294   }
    2295
    2296   final private boolean jj_3R_50() {
    2297     if (jj_3R_37()) return true;
    2298     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2299     return false;
    2300   }
    2301
    2302   final private boolean jj_3R_26() {
    2303     if (jj_3R_37()) return true;
    2304     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2305     return false;
    2306   }
    2307
    2308   final private boolean jj_3R_40() {
    2309     if (jj_3R_18()) return true;
    2310     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2311     return false;
    2312   }
    2313
    2314   final private boolean jj_3R_20() {
    2315     if (jj_3R_37()) return true;
    2316     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2317     return false;
    2318   }
    2319
    2320   final private boolean jj_3R_32() {
    2321     if (jj_3R_45()) return true;
    2322     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2323     return false;
    2324   }
    2325
    2326   final private boolean jj_3R_60() {
    2327     if (jj_3R_43()) return true;
    2328     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2329     return false;
    2330   }
    2331
    2332   final private boolean jj_3R_31() {
    2333     if (jj_3R_44()) return true;
    2334     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2335     return false;
    2336   }
    2337
    2338   final private boolean jj_3R_30() {
    2339     if (jj_scan_token(12)) return true;
    2340     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2341     if (jj_3R_17()) return true;
    2342     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2343     if (jj_scan_token(13)) return true;
    2344     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2345     return false;
    2346   }
    2347
    2348   final private boolean jj_3R_66() {
    2349     if (jj_3R_37()) return true;
    2350     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2351     return false;
    2352   }
    2353
    2354   final private boolean jj_3R_29() {
    2355     if (jj_3R_16()) return true;
    2356     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2357     return false;
    2358   }
    2359
    2360   final private boolean jj_3R_28() {
    2361     if (jj_3R_43()) return true;
    2362     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2363     return false;
    2364   }
    2365
    2366   final private boolean jj_3R_15() {
    2367     Token xsp;
    2368     xsp = jj_scanpos;
    2369     if (jj_3R_28()) {
    2370     jj_scanpos = xsp;
    2371     if (jj_3R_29()) {
    2372     jj_scanpos = xsp;
    2373     if (jj_3R_30()) {
    2374     jj_scanpos = xsp;
    2375     if (jj_3R_31()) {
    2376     jj_scanpos = xsp;
    2377     if (jj_3R_32()) return true;
    2378     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2379     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2380     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2381     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2382     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2383     return false;
    2384   }
    2385
    2386   final private boolean jj_3R_25() {
    2387     if (jj_3R_17()) return true;
    2388     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2389     return false;
    2390   }
    2391
    2392   final private boolean jj_3R_39() {
    2393     if (jj_3R_48()) return true;
    2394     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2395     return false;
    2396   }
    2397
    2398   final private boolean jj_3R_109() {
    2399     if (jj_3R_15()) return true;
    2400     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2401     return false;
    2402   }
    2403
    2404   final private boolean jj_3R_19() {
    2405     if (jj_3R_17()) return true;
    2406     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2407     return false;
    2408   }
    2409
    2410   final private boolean jj_3R_108() {
    2411     if (jj_scan_token(44)) return true;
    2412     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2413     if (jj_3R_101()) return true;
    2414     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2415     return false;
    2416   }
    2417
    2418   final private boolean jj_3R_107() {
    2419     if (jj_scan_token(43)) return true;
    2420     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2421     if (jj_3R_101()) return true;
    2422     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2423     return false;
    2424   }
    2425
    2426   final private boolean jj_3R_106() {
    2427     if (jj_scan_token(42)) return true;
    2428     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2429     if (jj_3R_101()) return true;
    2430     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2431     return false;
    2432   }
    2433
    2434   final private boolean jj_3R_105() {
    2435     if (jj_scan_token(36)) return true;
    2436     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2437     if (jj_3R_101()) return true;
    2438     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2439     return false;
    2440   }
    2441
    2442   final private boolean jj_3R_101() {
    2443     Token xsp;
    2444     xsp = jj_scanpos;
    2445     if (jj_3R_105()) {
    2446     jj_scanpos = xsp;
    2447     if (jj_3R_106()) {
    2448     jj_scanpos = xsp;
    2449     if (jj_3R_107()) {
    2450     jj_scanpos = xsp;
    2451     if (jj_3R_108()) {
    2452     jj_scanpos = xsp;
    2453     if (jj_3R_109()) return true;
    2454     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2455     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2456     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2457     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2458     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2459     return false;
    2460   }
    2461
    2462   final private boolean jj_3R_78() {
    2463     if (jj_scan_token(54)) return true;
    2464     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2465     if (jj_3R_49()) return true;
    2466     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2467     return false;
    2468   }
    2469
    2470   final private boolean jj_3R_114() {
    2471     if (jj_scan_token(41)) return true;
    2472     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2473     if (jj_3R_101()) return true;
    2474     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2475     return false;
    2476   }
    2477
    2478   final private boolean jj_3_8() {
    2479     if (jj_3R_18()) return true;
    2480     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2481     if (jj_scan_token(55)) return true;
    2482     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2483     Token xsp;
    2484     xsp = jj_scanpos;
    2485     if (jj_3R_25()) {
    2486     jj_scanpos = xsp;
    2487     if (jj_3R_26()) {
    2488     jj_scanpos = xsp;
    2489     if (jj_3R_27()) return true;
    2490     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2491     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2492     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2493     if (jj_scan_token(56)) return true;
    2494     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2495     return false;
    2496   }
    2497
    2498   final private boolean jj_3R_113() {
    2499     if (jj_scan_token(40)) return true;
    2500     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2501     if (jj_3R_101()) return true;
    2502     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2503     return false;
    2504   }
    2505
    2506   final private boolean jj_3_9() {
    2507     if (jj_3R_17()) return true;
    2508     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2509     return false;
    2510   }
    2511
    2512   final private boolean jj_3R_49() {
    2513     Token xsp;
    2514     xsp = jj_scanpos;
    2515     if (jj_3_9()) {
    2516     jj_scanpos = xsp;
    2517     if (jj_3R_60()) {
    2518     jj_scanpos = xsp;
    2519     if (jj_3R_61()) return true;
    2520     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2521     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2522     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2523     return false;
    2524   }
    2525
    2526   final private boolean jj_3R_112() {
    2527     if (jj_scan_token(39)) return true;
    2528     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2529     if (jj_3R_101()) return true;
    2530     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2531     return false;
    2532   }
    2533
    2534   final private boolean jj_3_4() {
    2535     if (jj_3R_17()) return true;
    2536     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2537     return false;
    2538   }
    2539
    2540   final private boolean jj_3R_111() {
    2541     if (jj_scan_token(38)) return true;
    2542     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2543     if (jj_3R_101()) return true;
    2544     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2545     return false;
    2546   }
    2547
    2548   final private boolean jj_3_5() {
    2549     if (jj_3R_18()) return true;
    2550     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2551     if (jj_scan_token(55)) return true;
    2552     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2553     Token xsp;
    2554     xsp = jj_scanpos;
    2555     if (jj_3R_19()) {
    2556     jj_scanpos = xsp;
    2557     if (jj_3R_20()) {
    2558     jj_scanpos = xsp;
    2559     if (jj_3R_21()) return true;
    2560     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2561     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2562     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2563     if (jj_scan_token(56)) return true;
    2564     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2565     return false;
    2566   }
    2567
    2568   final private boolean jj_3_7() {
    2569     if (jj_3R_24()) return true;
    2570     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2571     return false;
    2572   }
    2573
    2574   final private boolean jj_3R_110() {
    2575     if (jj_scan_token(37)) return true;
    2576     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2577     if (jj_3R_101()) return true;
    2578     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2579     return false;
    2580   }
    2581
    2582   final private boolean jj_3R_102() {
    2583     Token xsp;
    2584     xsp = jj_scanpos;
    2585     if (jj_3R_110()) {
    2586     jj_scanpos = xsp;
    2587     if (jj_3R_111()) {
    2588     jj_scanpos = xsp;
    2589     if (jj_3R_112()) {
    2590     jj_scanpos = xsp;
    2591     if (jj_3R_113()) {
    2592     jj_scanpos = xsp;
    2593     if (jj_3R_114()) return true;
    2594     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2595     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2596     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2597     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2598     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2599     return false;
    2600   }
    2601
    2602   final private boolean jj_3R_23() {
    2603     Token xsp;
    2604     xsp = jj_scanpos;
    2605     if (jj_3_7()) {
    2606     jj_scanpos = xsp;
    2607     if (jj_3R_39()) {
    2608     jj_scanpos = xsp;
    2609     if (jj_3R_40()) {
    2610     jj_scanpos = xsp;
    2611     if (jj_3R_41()) return true;
    2612     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2613     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2614     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2615     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2616     return false;
    2617   }
    2618
    2619   final private boolean jj_3R_22() {
    2620     if (jj_3R_38()) return true;
    2621     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2622     return false;
    2623   }
    2624
    2625   final private boolean jj_3R_57() {
    2626     if (jj_scan_token(55)) return true;
    2627     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2628     Token xsp;
    2629     xsp = jj_scanpos;
    2630     if (jj_3_4()) {
    2631     jj_scanpos = xsp;
    2632     if (jj_3R_66()) {
    2633     jj_scanpos = xsp;
    2634     if (jj_3R_67()) return true;
    2635     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2636     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2637     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2638     if (jj_scan_token(56)) return true;
    2639     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2640     return false;
    2641   }
    2642
    2643   final private boolean jj_3R_91() {
    2644     if (jj_3R_101()) return true;
    2645     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2646     Token xsp;
    2647     while (true) {
    2648       xsp = jj_scanpos;
    2649       if (jj_3R_102()) { jj_scanpos = xsp; break; }
    2650       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2651     }
    2652     return false;
    2653   }
    2654
    2655   final private boolean jj_3R_42() {
    2656     if (jj_3R_49()) return true;
    2657     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2658     Token xsp;
    2659     while (true) {
    2660       xsp = jj_scanpos;
    2661       if (jj_3R_78()) { jj_scanpos = xsp; break; }
    2662       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2663     }
    2664     return false;
    2665   }
    2666
    2667   final private boolean jj_3_6() {
    2668     if (jj_scan_token(57)) return true;
    2669     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2670     Token xsp;
    2671     xsp = jj_scanpos;
    2672     if (jj_3R_22()) {
    2673     jj_scanpos = xsp;
    2674     if (jj_3R_23()) return true;
    2675     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2676     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2677     return false;
    2678   }
    2679
    2680   final private boolean jj_3R_33() {
    2681     if (jj_3R_38()) return true;
    2682     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2683     return false;
    2684   }
    2685
    2686   final private boolean jj_3R_48() {
    2687     if (jj_scan_token(14)) return true;
    2688     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2689     if (jj_scan_token(12)) return true;
    2690     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2691     if (jj_scan_token(13)) return true;
    2692     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2693     return false;
    2694   }
    2695
    2696   final private boolean jj_3R_104() {
    2697     if (jj_scan_token(36)) return true;
    2698     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2699     if (jj_3R_91()) return true;
    2700     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2701     return false;
    2702   }
    2703
    2704   final private boolean jj_3R_16() {
    2705     Token xsp;
    2706     xsp = jj_scanpos;
    2707     if (jj_3R_33()) {
    2708     jj_scanpos = xsp;
    2709     if (jj_3R_34()) return true;
    2710     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2711     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2712     while (true) {
    2713       xsp = jj_scanpos;
    2714       if (jj_3_6()) { jj_scanpos = xsp; break; }
    2715       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2716     }
    2717     return false;
    2718   }
    2719
    2720   final private boolean jj_3R_103() {
    2721     if (jj_scan_token(35)) return true;
    2722     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2723     if (jj_3R_91()) return true;
    2724     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2725     return false;
    2726   }
    2727
    2728   final private boolean jj_3R_92() {
    2729     Token xsp;
    2730     xsp = jj_scanpos;
    2731     if (jj_3R_103()) {
    2732     jj_scanpos = xsp;
    2733     if (jj_3R_104()) return true;
    2734     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2735     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2736     return false;
    2737   }
    2738
    2739   final private boolean jj_3R_85() {
    2740     if (jj_3R_91()) return true;
    2741     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2742     Token xsp;
    2743     while (true) {
    2744       xsp = jj_scanpos;
    2745       if (jj_3R_92()) { jj_scanpos = xsp; break; }
    2746       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2747     }
    2748     return false;
    2749   }
    2750
    2751   final private boolean jj_3R_38() {
    2752     if (jj_3R_18()) return true;
    2753     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2754     Token xsp;
    2755     if (jj_3R_57()) return true;
    2756     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2757     while (true) {
    2758       xsp = jj_scanpos;
    2759       if (jj_3R_57()) { jj_scanpos = xsp; break; }
    2760       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2761     }
    2762     return false;
    2763   }
    2764
    2765   final private boolean jj_3R_100() {
    2766     if (jj_scan_token(34)) return true;
    2767     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2768     if (jj_3R_85()) return true;
    2769     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2770     return false;
    2771   }
    2772
    2773   final private boolean jj_3R_99() {
    2774     if (jj_scan_token(33)) return true;
    2775     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2776     if (jj_3R_85()) return true;
    2777     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2778     return false;
    2779   }
    2780
    2781   final private boolean jj_3R_24() {
    2782     if (jj_3R_18()) return true;
    2783     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2784     if (jj_scan_token(12)) return true;
    2785     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2786     Token xsp;
    2787     xsp = jj_scanpos;
    2788     if (jj_3R_42()) jj_scanpos = xsp;
    2789     else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2790     if (jj_scan_token(13)) return true;
    2791     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2792     return false;
    2793   }
    2794
    2795   final private boolean jj_3R_98() {
    2796     if (jj_scan_token(32)) return true;
    2797     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2798     if (jj_3R_85()) return true;
    2799     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2800     return false;
    2801   }
    2802
    2803   final private boolean jj_3R_97() {
    2804     if (jj_scan_token(31)) return true;
    2805     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2806     if (jj_3R_85()) return true;
    2807     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2808     return false;
    2809   }
    2810
    2811   final private boolean jj_3R_96() {
    2812     if (jj_scan_token(30)) return true;
    2813     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2814     if (jj_3R_85()) return true;
    2815     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2816     return false;
    2817   }
    2818
    2819   final private boolean jj_3R_95() {
    2820     if (jj_scan_token(29)) return true;
    2821     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2822     if (jj_3R_85()) return true;
    2823     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2824     return false;
    2825   }
    2826
    2827   final private boolean jj_3R_94() {
    2828     if (jj_scan_token(28)) return true;
    2829     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2830     if (jj_3R_85()) return true;
    2831     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2832     return false;
    2833   }
    2834
    2835   final private boolean jj_3R_93() {
    2836     if (jj_scan_token(27)) return true;
    2837     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2838     if (jj_3R_85()) return true;
    2839     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2840     return false;
    2841   }
    2842
    2843   final private boolean jj_3R_86() {
    2844     Token xsp;
    2845     xsp = jj_scanpos;
    2846     if (jj_3R_93()) {
    2847     jj_scanpos = xsp;
    2848     if (jj_3R_94()) {
    2849     jj_scanpos = xsp;
    2850     if (jj_3R_95()) {
    2851     jj_scanpos = xsp;
    2852     if (jj_3R_96()) {
    2853     jj_scanpos = xsp;
    2854     if (jj_3R_97()) {
    2855     jj_scanpos = xsp;
    2856     if (jj_3R_98()) {
    2857     jj_scanpos = xsp;
    2858     if (jj_3R_99()) {
    2859     jj_scanpos = xsp;
    2860     if (jj_3R_100()) return true;
    2861     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2862     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2863     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2864     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2865     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2866     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2867     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2868     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2869     return false;
    2870   }
    2871
    2872   final private boolean jj_3R_83() {
    2873     if (jj_3R_85()) return true;
    2874     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2875     Token xsp;
    2876     while (true) {
    2877       xsp = jj_scanpos;
    2878       if (jj_3R_86()) { jj_scanpos = xsp; break; }
    2879       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2880     }
    2881     return false;
    2882   }
    2883
    2884   final private boolean jj_3R_90() {
    2885     if (jj_scan_token(26)) return true;
    2886     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2887     if (jj_3R_83()) return true;
    2888     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2889     return false;
    2890   }
    2891
    2892   final private boolean jj_3R_89() {
    2893     if (jj_scan_token(25)) return true;
    2894     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2895     if (jj_3R_83()) return true;
    2896     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2897     return false;
    2898   }
    2899
    2900   final private boolean jj_3R_88() {
    2901     if (jj_scan_token(24)) return true;
    2902     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2903     if (jj_3R_83()) return true;
    2904     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2905     return false;
    2906   }
    2907
    2908   final private boolean jj_3R_87() {
    2909     if (jj_scan_token(23)) return true;
    2910     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2911     if (jj_3R_83()) return true;
    2912     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2913     return false;
    2914   }
    2915
    2916   final private boolean jj_3R_84() {
    2917     Token xsp;
    2918     xsp = jj_scanpos;
    2919     if (jj_3R_87()) {
    2920     jj_scanpos = xsp;
    2921     if (jj_3R_88()) {
    2922     jj_scanpos = xsp;
    2923     if (jj_3R_89()) {
    2924     jj_scanpos = xsp;
    2925     if (jj_3R_90()) return true;
    2926     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2927     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2928     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2929     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2930     return false;
    2931   }
    2932
    2933   final private boolean jj_3R_81() {
    2934     if (jj_3R_83()) return true;
    2935     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2936     Token xsp;
    2937     while (true) {
    2938       xsp = jj_scanpos;
    2939       if (jj_3R_84()) { jj_scanpos = xsp; break; }
    2940       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2941     }
    2942     return false;
    2943   }
    2944
    2945   final private boolean jj_3R_82() {
    2946     if (jj_scan_token(22)) return true;
    2947     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2948     if (jj_3R_81()) return true;
    2949     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2950     return false;
    2951   }
    2952
    2953   final private boolean jj_3R_79() {
    2954     if (jj_3R_81()) return true;
    2955     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2956     Token xsp;
    2957     while (true) {
    2958       xsp = jj_scanpos;
    2959       if (jj_3R_82()) { jj_scanpos = xsp; break; }
    2960       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2961     }
    2962     return false;
    2963   }
    2964
    2965   final private boolean jj_3_3() {
    2966     if (jj_3R_15()) return true;
    2967     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2968     if (jj_scan_token(15)) return true;
    2969     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2970     return false;
    2971   }
    2972
    2973   final private boolean jj_3_2() {
    2974     if (jj_3R_16()) return true;
    2975     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2976     if (jj_scan_token(48)) return true;
    2977     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2978     return false;
    2979   }
    2980
    2981   final private boolean jj_3R_80() {
    2982     if (jj_scan_token(21)) return true;
    2983     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2984     if (jj_3R_79()) return true;
    2985     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2986     return false;
    2987   }
    2988
    2989   final private boolean jj_3R_74() {
    2990     if (jj_3R_79()) return true;
    2991     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2992     Token xsp;
    2993     while (true) {
    2994       xsp = jj_scanpos;
    2995       if (jj_3R_80()) { jj_scanpos = xsp; break; }
    2996       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    2997     }
    2998     return false;
    2999   }
    3000
    3001   final private boolean jj_3R_75() {
    3002     if (jj_scan_token(20)) return true;
    3003     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3004     if (jj_3R_74()) return true;
    3005     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3006     return false;
    3007   }
    3008
    3009   final private boolean jj_3R_68() {
    3010     if (jj_3R_74()) return true;
    3011     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3012     Token xsp;
    3013     while (true) {
    3014       xsp = jj_scanpos;
    3015       if (jj_3R_75()) { jj_scanpos = xsp; break; }
    3016       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3017     }
    3018     return false;
    3019   }
    3020
    3021   final private boolean jj_3R_77() {
    3022     if (jj_scan_token(19)) return true;
    3023     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3024     if (jj_3R_68()) return true;
    3025     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3026     return false;
    3027   }
    3028
    3029   final private boolean jj_3R_69() {
    3030     Token xsp;
    3031     xsp = jj_scanpos;
    3032     if (jj_3R_76()) {
    3033     jj_scanpos = xsp;
    3034     if (jj_3R_77()) return true;
    3035     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3036     } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3037     return false;
    3038   }
    3039
    3040   final private boolean jj_3R_76() {
    3041     if (jj_scan_token(18)) return true;
    3042     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3043     if (jj_3R_68()) return true;
    3044     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3045     return false;
    3046   }
    3047
    3048   final private boolean jj_3R_58() {
    3049     if (jj_3R_68()) return true;
    3050     if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3051     Token xsp;
    3052     while (true) {
    3053       xsp = jj_scanpos;
    3054       if (jj_3R_69()) { jj_scanpos = xsp; break; }
    3055       if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    3056     }
    3057     return false;
    3058   }
    3059
    3060   public ParserTokenManager token_source;
    3061   SimpleCharStream jj_input_stream;
    3062   public Token token, jj_nt;
    3063   private int jj_ntk;
    3064   private Token jj_scanpos, jj_lastpos;
    3065   private int jj_la;
    3066   public boolean lookingAhead = false;
    3067   private boolean jj_semLA;
    3068   private int jj_gen;
    3069   final private int[] jj_la1 = new int[34];
    3070   final private int[] jj_la1_0 = {0x5b80,0x5b80,0x1000,0x5980,0x30000,0x30000,0xc0000,0xc0000,0x100000,0x200000,0x400000,0x7800000,0x7800000,0xf8000000,0xf8000000,0x0,0x0,0x0,0x0,0x5980,0x5980,0x180,0x0,0x200,0x5980,0x0,0x0,0x5980,0x80,0x0,0x0,0x4080,0x4080,0x180,};
    3071   final private int[] jj_la1_1 = {0x241bfc10,0x241bfc10,0x4000000,0x2400fc10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7,0x7,0x18,0x18,0x3e0,0x3e0,0x2400fc10,0x2400e000,0x2000e000,0xc000,0x10000,0x241afc10,0x40000,0x400000,0x2400fc10,0x4000000,0x800000,0x4000000,0x4000000,0x4000000,0x2400e000,};
    3072   final private JJCalls[] jj_2_rtns = new JJCalls[9];
    3073   private boolean jj_rescan = false;
    3074   private int jj_gc = 0;
    3075
    3076   public Parser(java.io.InputStream stream) {
    3077     jj_input_stream = new SimpleCharStream(stream, 1, 1);
    3078     token_source = new ParserTokenManager(jj_input_stream);
    3079     token = new Token();
    3080     jj_ntk = -1;
    3081     jj_gen = 0;
    3082     for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    3083     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3084   }
    3085
    3086   public void ReInit(java.io.InputStream stream) {
    3087     jj_input_stream.ReInit(stream, 1, 1);
    3088     token_source.ReInit(jj_input_stream);
    3089     token = new Token();
    3090     jj_ntk = -1;
    3091     jjtree.reset();
    3092     jj_gen = 0;
    3093     for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    3094     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3095   }
    3096
    3097   public Parser(java.io.Reader stream) {
    3098     jj_input_stream = new SimpleCharStream(stream, 1, 1);
    3099     token_source = new ParserTokenManager(jj_input_stream);
    3100     token = new Token();
    3101     jj_ntk = -1;
    3102     jj_gen = 0;
    3103     for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    3104     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3105   }
    3106
    3107   public void ReInit(java.io.Reader stream) {
    3108     jj_input_stream.ReInit(stream, 1, 1);
    3109     token_source.ReInit(jj_input_stream);
    3110     token = new Token();
    3111     jj_ntk = -1;
    3112     jjtree.reset();
    3113     jj_gen = 0;
    3114     for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    3115     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3116   }
    3117
    3118   public Parser(ParserTokenManager tm) {
    3119     token_source = tm;
    3120     token = new Token();
    3121     jj_ntk = -1;
    3122     jj_gen = 0;
    3123     for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    3124     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3125   }
    3126
    3127   public void ReInit(ParserTokenManager tm) {
    3128     token_source = tm;
    3129     token = new Token();
    3130     jj_ntk = -1;
    3131     jjtree.reset();
    3132     jj_gen = 0;
    3133     for (int i = 0; i < 34; i++) jj_la1[i] = -1;
    3134     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
    3135   }
    3136
    3137   final private Token jj_consume_token(int kind) throws ParseException {
    3138     Token oldToken;
    3139     if ((oldToken = token).next != null) token = token.next;
    3140     else token = token.next = token_source.getNextToken();
    3141     jj_ntk = -1;
    3142     if (token.kind == kind) {
    3143       jj_gen++;
    3144       if (++jj_gc > 100) {
    3145         jj_gc = 0;
    3146         for (int i = 0; i < jj_2_rtns.length; i++) {
    3147           JJCalls c = jj_2_rtns[i];
    3148           while (c != null) {
    3149             if (c.gen < jj_gen) c.first = null;
    3150             c = c.next;
    3151           }
    3152         }
    3153       }
    3154       return token;
    3155     }
    3156     token = oldToken;
    3157     jj_kind = kind;
    3158     throw generateParseException();
    3159   }
    3160
    3161   final private boolean jj_scan_token(int kind) {
    3162     if (jj_scanpos == jj_lastpos) {
    3163       jj_la--;
    3164       if (jj_scanpos.next == null) {
    3165         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
    3166       } else {
    3167         jj_lastpos = jj_scanpos = jj_scanpos.next;
    3168       }
    3169     } else {
    3170       jj_scanpos = jj_scanpos.next;
    3171     }
    3172     if (jj_rescan) {
    3173       int i = 0; Token tok = token;
    3174       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
    3175       if (tok != null) jj_add_error_token(kind, i);
    3176     }
    3177     return (jj_scanpos.kind != kind);
    3178   }
    3179
    3180   final public Token getNextToken() {
    3181     if (token.next != null) token = token.next;
    3182     else token = token.next = token_source.getNextToken();
    3183     jj_ntk = -1;
    3184     jj_gen++;
    3185     return token;
    3186   }
    3187
    3188   final public Token getToken(int index) {
    3189     Token t = lookingAhead ? jj_scanpos : token;
    3190     for (int i = 0; i < index; i++) {
    3191       if (t.next != null) t = t.next;
    3192       else t = t.next = token_source.getNextToken();
    3193     }
    3194     return t;
    3195   }
    3196
    3197   final private int jj_ntk() {
    3198     if ((jj_nt=token.next) == null)
    3199       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    3200     else
    3201       return (jj_ntk = jj_nt.kind);
    3202   }
    3203
    3204   private java.util.Vector jj_expentries = new java.util.Vector();
    3205   private int[] jj_expentry;
    3206   private int jj_kind = -1;
    3207   private int[] jj_lasttokens = new int[100];
    3208   private int jj_endpos;
    3209
    3210   private void jj_add_error_token(int kind, int pos) {
    3211     if (pos >= 100) return;
    3212     if (pos == jj_endpos + 1) {
    3213       jj_lasttokens[jj_endpos++] = kind;
    3214     } else if (jj_endpos != 0) {
    3215       jj_expentry = new int[jj_endpos];
    3216       for (int i = 0; i < jj_endpos; i++) {
    3217         jj_expentry[i] = jj_lasttokens[i];
    3218       }
    3219       boolean exists = false;
    3220       for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
    3221         int[] oldentry = (int[])(enum.nextElement());
    3222         if (oldentry.length == jj_expentry.length) {
    3223           exists = true;
    3224           for (int i = 0; i < jj_expentry.length; i++) {
    3225             if (oldentry[i] != jj_expentry[i]) {
    3226               exists = false;
    3227               break;
    3228             }
    3229           }
    3230           if (exists) break;
    3231         }
    3232       }
    3233       if (!exists) jj_expentries.addElement(jj_expentry);
    3234       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    3235     }
    3236   }
    3237
    3238   final public ParseException generateParseException() {
    3239     jj_expentries.removeAllElements();
    3240     boolean[] la1tokens = new boolean[62];
    3241     for (int i = 0; i < 62; i++) {
    3242       la1tokens[i] = false;
    3243     }
    3244     if (jj_kind >= 0) {
    3245       la1tokens[jj_kind] = true;
    3246       jj_kind = -1;
    3247     }
    3248     for (int i = 0; i < 34; i++) {
    3249       if (jj_la1[i] == jj_gen) {
    3250         for (int j = 0; j < 32; j++) {
    3251           if ((jj_la1_0[i] & (1<<j)) != 0) {
    3252             la1tokens[j] = true;
    3253           }
    3254           if ((jj_la1_1[i] & (1<<j)) != 0) {
    3255             la1tokens[32+j] = true;
    3256           }
    3257         }
    3258       }
    3259     }
    3260     for (int i = 0; i < 62; i++) {
    3261       if (la1tokens[i]) {
    3262         jj_expentry = new int[1];
    3263         jj_expentry[0] = i;
    3264         jj_expentries.addElement(jj_expentry);
    3265       }
    3266     }
    3267     jj_endpos = 0;
    3268     jj_rescan_token();
    3269     jj_add_error_token(0, 0);
    3270     int[][] exptokseq = new int[jj_expentries.size()][];
    3271     for (int i = 0; i < jj_expentries.size(); i++) {
    3272       exptokseq[i] = (int[])jj_expentries.elementAt(i);
    3273     }
    3274     return new ParseException(token, exptokseq, tokenImage);
    3275   }
    3276
    3277   final public void enable_tracing() {
    3278   }
    3279
    3280   final public void disable_tracing() {
    3281   }
    3282
    3283   final private void jj_rescan_token() {
    3284     jj_rescan = true;
    3285     for (int i = 0; i < 9; i++) {
    3286       JJCalls p = jj_2_rtns[i];
    3287       do {
    3288         if (p.gen > jj_gen) {
    3289           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
    3290           switch (i) {
    3291             case 0: jj_3_1(); break;
    3292             case 1: jj_3_2(); break;
    3293             case 2: jj_3_3(); break;
    3294             case 3: jj_3_4(); break;
    3295             case 4: jj_3_5(); break;
    3296             case 5: jj_3_6(); break;
    3297             case 6: jj_3_7(); break;
    3298             case 7: jj_3_8(); break;
    3299             case 8: jj_3_9(); break;
    3300           }
    3301         }
    3302         p = p.next;
    3303       } while (p != null);
    3304     }
    3305     jj_rescan = false;
    3306   }
    3307
    3308   final private void jj_save(int index, int xla) {
    3309     JJCalls p = jj_2_rtns[index];
    3310     while (p.gen > jj_gen) {
    3311       if (p.next == null) { p = p.next = new JJCalls(); break; }
    3312       p = p.next;
    3313     }
    3314     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
    3315   }
    3316
    3317   static final class JJCalls {
    3318     int gen;
    3319     Token first;
    3320     int arg;
    3321     JJCalls next;
    3322   }
    3323
    3324 }