View Javadoc

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