View Javadoc

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