View Javadoc

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