View Javadoc

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