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               Name();
3732             } else if (jj_2_49(2147483647)) {
3733               ReferenceType();
3734               MethodReference();
3735             } else {
3736               switch (jj_nt.kind) {
3737               case IDENTIFIER:
3738                 Name();
3739                 break;
3740               default:
3741                 jj_la1[96] = jj_gen;
3742                 jj_consume_token(-1);
3743                 throw new ParseException();
3744               }
3745             }
3746           }
3747         }
3748       }
3749     } catch (Throwable jjte000) {
3750     if (jjtc000) {
3751       jjtree.clearNodeScope(jjtn000);
3752       jjtc000 = false;
3753     } else {
3754       jjtree.popNode();
3755     }
3756     if (jjte000 instanceof RuntimeException) {
3757       {if (true) throw (RuntimeException)jjte000;}
3758     }
3759     if (jjte000 instanceof ParseException) {
3760       {if (true) throw (ParseException)jjte000;}
3761     }
3762     {if (true) throw (Error)jjte000;}
3763     } finally {
3764     if (jjtc000) {
3765       jjtree.closeNodeScope(jjtn000, true);
3766     }
3767     }
3768   }
3769 
3770   final public void LambdaExpression() throws ParseException {
3771  /*@bgen(jjtree) LambdaExpression */
3772   ASTLambdaExpression jjtn000 = new ASTLambdaExpression(this, JJTLAMBDAEXPRESSION);
3773   boolean jjtc000 = true;
3774   jjtree.openNodeScope(jjtn000);checkForBadLambdaUsage();
3775     try {
3776       switch (jj_nt.kind) {
3777       case IDENTIFIER:
3778         VariableDeclaratorId();
3779         jj_consume_token(LAMBDA);
3780         switch (jj_nt.kind) {
3781         case BOOLEAN:
3782         case BYTE:
3783         case CHAR:
3784         case DOUBLE:
3785         case FALSE:
3786         case FLOAT:
3787         case INT:
3788         case LONG:
3789         case NEW:
3790         case NULL:
3791         case SHORT:
3792         case SUPER:
3793         case THIS:
3794         case TRUE:
3795         case VOID:
3796         case INTEGER_LITERAL:
3797         case FLOATING_POINT_LITERAL:
3798         case HEX_FLOATING_POINT_LITERAL:
3799         case CHARACTER_LITERAL:
3800         case STRING_LITERAL:
3801         case IDENTIFIER:
3802         case LPAREN:
3803         case BANG:
3804         case TILDE:
3805         case INCR:
3806         case DECR:
3807         case PLUS:
3808         case MINUS:
3809           Expression();
3810           break;
3811         case LBRACE:
3812           Block();
3813           break;
3814         default:
3815           jj_la1[97] = jj_gen;
3816           jj_consume_token(-1);
3817           throw new ParseException();
3818         }
3819         break;
3820       default:
3821         jj_la1[101] = jj_gen;
3822         if (jj_2_50(3)) {
3823           FormalParameters();
3824           jj_consume_token(LAMBDA);
3825           switch (jj_nt.kind) {
3826           case BOOLEAN:
3827           case BYTE:
3828           case CHAR:
3829           case DOUBLE:
3830           case FALSE:
3831           case FLOAT:
3832           case INT:
3833           case LONG:
3834           case NEW:
3835           case NULL:
3836           case SHORT:
3837           case SUPER:
3838           case THIS:
3839           case TRUE:
3840           case VOID:
3841           case INTEGER_LITERAL:
3842           case FLOATING_POINT_LITERAL:
3843           case HEX_FLOATING_POINT_LITERAL:
3844           case CHARACTER_LITERAL:
3845           case STRING_LITERAL:
3846           case IDENTIFIER:
3847           case LPAREN:
3848           case BANG:
3849           case TILDE:
3850           case INCR:
3851           case DECR:
3852           case PLUS:
3853           case MINUS:
3854             Expression();
3855             break;
3856           case LBRACE:
3857             Block();
3858             break;
3859           default:
3860             jj_la1[98] = jj_gen;
3861             jj_consume_token(-1);
3862             throw new ParseException();
3863           }
3864         } else if (jj_2_51(3)) {
3865           jj_consume_token(LPAREN);
3866           VariableDeclaratorId();
3867           label_53:
3868           while (true) {
3869             switch (jj_nt.kind) {
3870             case COMMA:
3871               ;
3872               break;
3873             default:
3874               jj_la1[99] = jj_gen;
3875               break label_53;
3876             }
3877             jj_consume_token(COMMA);
3878             VariableDeclaratorId();
3879           }
3880           jj_consume_token(RPAREN);
3881           jj_consume_token(LAMBDA);
3882           switch (jj_nt.kind) {
3883           case BOOLEAN:
3884           case BYTE:
3885           case CHAR:
3886           case DOUBLE:
3887           case FALSE:
3888           case FLOAT:
3889           case INT:
3890           case LONG:
3891           case NEW:
3892           case NULL:
3893           case SHORT:
3894           case SUPER:
3895           case THIS:
3896           case TRUE:
3897           case VOID:
3898           case INTEGER_LITERAL:
3899           case FLOATING_POINT_LITERAL:
3900           case HEX_FLOATING_POINT_LITERAL:
3901           case CHARACTER_LITERAL:
3902           case STRING_LITERAL:
3903           case IDENTIFIER:
3904           case LPAREN:
3905           case BANG:
3906           case TILDE:
3907           case INCR:
3908           case DECR:
3909           case PLUS:
3910           case MINUS:
3911             Expression();
3912             break;
3913           case LBRACE:
3914             Block();
3915             break;
3916           default:
3917             jj_la1[100] = jj_gen;
3918             jj_consume_token(-1);
3919             throw new ParseException();
3920           }
3921         } else {
3922           jj_consume_token(-1);
3923           throw new ParseException();
3924         }
3925       }
3926     } catch (Throwable jjte000) {
3927     if (jjtc000) {
3928       jjtree.clearNodeScope(jjtn000);
3929       jjtc000 = false;
3930     } else {
3931       jjtree.popNode();
3932     }
3933     if (jjte000 instanceof RuntimeException) {
3934       {if (true) throw (RuntimeException)jjte000;}
3935     }
3936     if (jjte000 instanceof ParseException) {
3937       {if (true) throw (ParseException)jjte000;}
3938     }
3939     {if (true) throw (Error)jjte000;}
3940     } finally {
3941     if (jjtc000) {
3942       jjtree.closeNodeScope(jjtn000, true);
3943     }
3944     }
3945   }
3946 
3947   final public void PrimarySuffix() throws ParseException {
3948  /*@bgen(jjtree) PrimarySuffix */
3949  ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
3950  boolean jjtc000 = true;
3951  jjtree.openNodeScope(jjtn000);Token t;
3952     try {
3953       if (jj_2_52(2)) {
3954         jj_consume_token(DOT);
3955         jj_consume_token(THIS);
3956       } else if (jj_2_53(2)) {
3957         jj_consume_token(DOT);
3958         jj_consume_token(SUPER);
3959       } else if (jj_2_54(2)) {
3960         jj_consume_token(DOT);
3961         AllocationExpression();
3962       } else if (jj_2_55(3)) {
3963         MemberSelector();
3964       } else {
3965         switch (jj_nt.kind) {
3966         case LBRACKET:
3967           jj_consume_token(LBRACKET);
3968           Expression();
3969           jj_consume_token(RBRACKET);
3970                          jjtree.closeNodeScope(jjtn000, true);
3971                          jjtc000 = false;
3972                         jjtn000.setIsArrayDereference();
3973           break;
3974         case DOT:
3975           jj_consume_token(DOT);
3976           t = jj_consume_token(IDENTIFIER);
3977                        jjtree.closeNodeScope(jjtn000, true);
3978                        jjtc000 = false;
3979                       jjtn000.setImage(t.image);
3980           break;
3981         case LPAREN:
3982           Arguments();
3983                 jjtree.closeNodeScope(jjtn000, true);
3984                 jjtc000 = false;
3985                jjtn000.setIsArguments();
3986           break;
3987         default:
3988           jj_la1[102] = jj_gen;
3989           jj_consume_token(-1);
3990           throw new ParseException();
3991         }
3992       }
3993     } catch (Throwable jjte000) {
3994     if (jjtc000) {
3995       jjtree.clearNodeScope(jjtn000);
3996       jjtc000 = false;
3997     } else {
3998       jjtree.popNode();
3999     }
4000     if (jjte000 instanceof RuntimeException) {
4001       {if (true) throw (RuntimeException)jjte000;}
4002     }
4003     if (jjte000 instanceof ParseException) {
4004       {if (true) throw (ParseException)jjte000;}
4005     }
4006     {if (true) throw (Error)jjte000;}
4007     } finally {
4008     if (jjtc000) {
4009       jjtree.closeNodeScope(jjtn000, true);
4010     }
4011     }
4012   }
4013 
4014   final public void Literal() throws ParseException {
4015  /*@bgen(jjtree) Literal */
4016   ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
4017   boolean jjtc000 = true;
4018   jjtree.openNodeScope(jjtn000);
4019     try {
4020       switch (jj_nt.kind) {
4021       case INTEGER_LITERAL:
4022   Token t;
4023         t = jj_consume_token(INTEGER_LITERAL);
4024                         jjtree.closeNodeScope(jjtn000, true);
4025                         jjtc000 = false;
4026                         checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setIntLiteral();
4027         break;
4028       case FLOATING_POINT_LITERAL:
4029         t = jj_consume_token(FLOATING_POINT_LITERAL);
4030                                jjtree.closeNodeScope(jjtn000, true);
4031                                jjtc000 = false;
4032                                checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
4033         break;
4034       case HEX_FLOATING_POINT_LITERAL:
4035         t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
4036                                    jjtree.closeNodeScope(jjtn000, true);
4037                                    jjtc000 = false;
4038                                    checkForBadHexFloatingPointLiteral(); checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
4039         break;
4040       case CHARACTER_LITERAL:
4041         t = jj_consume_token(CHARACTER_LITERAL);
4042                           jjtree.closeNodeScope(jjtn000, true);
4043                           jjtc000 = false;
4044                          jjtn000.setImage(t.image); jjtn000.setCharLiteral();
4045         break;
4046       case STRING_LITERAL:
4047         t = jj_consume_token(STRING_LITERAL);
4048                        jjtree.closeNodeScope(jjtn000, true);
4049                        jjtc000 = false;
4050                       jjtn000.setImage(t.image); jjtn000.setStringLiteral();
4051         break;
4052       case FALSE:
4053       case TRUE:
4054         BooleanLiteral();
4055         break;
4056       case NULL:
4057         NullLiteral();
4058         break;
4059       default:
4060         jj_la1[103] = jj_gen;
4061         jj_consume_token(-1);
4062         throw new ParseException();
4063       }
4064     } catch (Throwable jjte000) {
4065   if (jjtc000) {
4066     jjtree.clearNodeScope(jjtn000);
4067     jjtc000 = false;
4068   } else {
4069     jjtree.popNode();
4070   }
4071   if (jjte000 instanceof RuntimeException) {
4072     {if (true) throw (RuntimeException)jjte000;}
4073   }
4074   if (jjte000 instanceof ParseException) {
4075     {if (true) throw (ParseException)jjte000;}
4076   }
4077   {if (true) throw (Error)jjte000;}
4078     } finally {
4079   if (jjtc000) {
4080     jjtree.closeNodeScope(jjtn000, true);
4081   }
4082     }
4083   }
4084 
4085   final public void BooleanLiteral() throws ParseException {
4086  /*@bgen(jjtree) BooleanLiteral */
4087   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
4088   boolean jjtc000 = true;
4089   jjtree.openNodeScope(jjtn000);
4090     try {
4091       switch (jj_nt.kind) {
4092       case TRUE:
4093         jj_consume_token(TRUE);
4094            jjtree.closeNodeScope(jjtn000, true);
4095            jjtc000 = false;
4096            jjtn000.setTrue();
4097         break;
4098       case FALSE:
4099         jj_consume_token(FALSE);
4100         break;
4101       default:
4102         jj_la1[104] = jj_gen;
4103         jj_consume_token(-1);
4104         throw new ParseException();
4105       }
4106     } finally {
4107     if (jjtc000) {
4108       jjtree.closeNodeScope(jjtn000, true);
4109     }
4110     }
4111   }
4112 
4113   final public void NullLiteral() throws ParseException {
4114  /*@bgen(jjtree) NullLiteral */
4115   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
4116   boolean jjtc000 = true;
4117   jjtree.openNodeScope(jjtn000);
4118     try {
4119       jj_consume_token(NULL);
4120     } finally {
4121     if (jjtc000) {
4122       jjtree.closeNodeScope(jjtn000, true);
4123     }
4124     }
4125   }
4126 
4127   final public void Arguments() throws ParseException {
4128  /*@bgen(jjtree) Arguments */
4129   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
4130   boolean jjtc000 = true;
4131   jjtree.openNodeScope(jjtn000);
4132     try {
4133       jj_consume_token(LPAREN);
4134       switch (jj_nt.kind) {
4135       case BOOLEAN:
4136       case BYTE:
4137       case CHAR:
4138       case DOUBLE:
4139       case FALSE:
4140       case FLOAT:
4141       case INT:
4142       case LONG:
4143       case NEW:
4144       case NULL:
4145       case SHORT:
4146       case SUPER:
4147       case THIS:
4148       case TRUE:
4149       case VOID:
4150       case INTEGER_LITERAL:
4151       case FLOATING_POINT_LITERAL:
4152       case HEX_FLOATING_POINT_LITERAL:
4153       case CHARACTER_LITERAL:
4154       case STRING_LITERAL:
4155       case IDENTIFIER:
4156       case LPAREN:
4157       case BANG:
4158       case TILDE:
4159       case INCR:
4160       case DECR:
4161       case PLUS:
4162       case MINUS:
4163         ArgumentList();
4164         break;
4165       default:
4166         jj_la1[105] = jj_gen;
4167         ;
4168       }
4169       jj_consume_token(RPAREN);
4170     } catch (Throwable jjte000) {
4171     if (jjtc000) {
4172       jjtree.clearNodeScope(jjtn000);
4173       jjtc000 = false;
4174     } else {
4175       jjtree.popNode();
4176     }
4177     if (jjte000 instanceof RuntimeException) {
4178       {if (true) throw (RuntimeException)jjte000;}
4179     }
4180     if (jjte000 instanceof ParseException) {
4181       {if (true) throw (ParseException)jjte000;}
4182     }
4183     {if (true) throw (Error)jjte000;}
4184     } finally {
4185     if (jjtc000) {
4186       jjtree.closeNodeScope(jjtn000, true);
4187     }
4188     }
4189   }
4190 
4191   final public void ArgumentList() throws ParseException {
4192  /*@bgen(jjtree) ArgumentList */
4193   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
4194   boolean jjtc000 = true;
4195   jjtree.openNodeScope(jjtn000);
4196     try {
4197       Expression();
4198       label_54:
4199       while (true) {
4200         switch (jj_nt.kind) {
4201         case COMMA:
4202           ;
4203           break;
4204         default:
4205           jj_la1[106] = jj_gen;
4206           break label_54;
4207         }
4208         jj_consume_token(COMMA);
4209         Expression();
4210       }
4211     } catch (Throwable jjte000) {
4212     if (jjtc000) {
4213       jjtree.clearNodeScope(jjtn000);
4214       jjtc000 = false;
4215     } else {
4216       jjtree.popNode();
4217     }
4218     if (jjte000 instanceof RuntimeException) {
4219       {if (true) throw (RuntimeException)jjte000;}
4220     }
4221     if (jjte000 instanceof ParseException) {
4222       {if (true) throw (ParseException)jjte000;}
4223     }
4224     {if (true) throw (Error)jjte000;}
4225     } finally {
4226     if (jjtc000) {
4227       jjtree.closeNodeScope(jjtn000, true);
4228     }
4229     }
4230   }
4231 
4232   final public void AllocationExpression() throws ParseException {
4233  /*@bgen(jjtree) AllocationExpression */
4234   ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
4235   boolean jjtc000 = true;
4236   jjtree.openNodeScope(jjtn000);
4237     try {
4238       jj_consume_token(NEW);
4239       label_55:
4240       while (true) {
4241         switch (jj_nt.kind) {
4242         case AT:
4243           ;
4244           break;
4245         default:
4246           jj_la1[107] = jj_gen;
4247           break label_55;
4248         }
4249         Annotation();
4250                        checkForBadTypeAnnotations();
4251       }
4252       if (jj_2_56(2)) {
4253         PrimitiveType();
4254         ArrayDimsAndInits();
4255       } else {
4256         switch (jj_nt.kind) {
4257         case IDENTIFIER:
4258           ClassOrInterfaceType();
4259           switch (jj_nt.kind) {
4260           case LT:
4261             TypeArguments();
4262             break;
4263           default:
4264             jj_la1[108] = jj_gen;
4265             ;
4266           }
4267           switch (jj_nt.kind) {
4268           case LBRACKET:
4269             ArrayDimsAndInits();
4270             break;
4271           case LPAREN:
4272             Arguments();
4273             switch (jj_nt.kind) {
4274             case LBRACE:
4275               ClassOrInterfaceBody();
4276               break;
4277             default:
4278               jj_la1[109] = jj_gen;
4279               ;
4280             }
4281             break;
4282           default:
4283             jj_la1[110] = jj_gen;
4284             jj_consume_token(-1);
4285             throw new ParseException();
4286           }
4287           break;
4288         default:
4289           jj_la1[111] = jj_gen;
4290           jj_consume_token(-1);
4291           throw new ParseException();
4292         }
4293       }
4294     } catch (Throwable jjte000) {
4295     if (jjtc000) {
4296       jjtree.clearNodeScope(jjtn000);
4297       jjtc000 = false;
4298     } else {
4299       jjtree.popNode();
4300     }
4301     if (jjte000 instanceof RuntimeException) {
4302       {if (true) throw (RuntimeException)jjte000;}
4303     }
4304     if (jjte000 instanceof ParseException) {
4305       {if (true) throw (ParseException)jjte000;}
4306     }
4307     {if (true) throw (Error)jjte000;}
4308     } finally {
4309     if (jjtc000) {
4310       jjtree.closeNodeScope(jjtn000, true);
4311     }
4312     }
4313   }
4314 
4315 /*
4316  * The second LOOKAHEAD specification below is to parse to PrimarySuffix
4317  * if there is an expression between the "[...]".
4318  */
4319   final public void ArrayDimsAndInits() throws ParseException {
4320  /*@bgen(jjtree) ArrayDimsAndInits */
4321   ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
4322   boolean jjtc000 = true;
4323   jjtree.openNodeScope(jjtn000);
4324     try {
4325       if (jj_2_59(2)) {
4326         label_56:
4327         while (true) {
4328           jj_consume_token(LBRACKET);
4329           Expression();
4330           jj_consume_token(RBRACKET);
4331           if (jj_2_57(2)) {
4332             ;
4333           } else {
4334             break label_56;
4335           }
4336         }
4337         label_57:
4338         while (true) {
4339           if (jj_2_58(2)) {
4340             ;
4341           } else {
4342             break label_57;
4343           }
4344           jj_consume_token(LBRACKET);
4345           jj_consume_token(RBRACKET);
4346         }
4347       } else {
4348         switch (jj_nt.kind) {
4349         case LBRACKET:
4350           label_58:
4351           while (true) {
4352             jj_consume_token(LBRACKET);
4353             jj_consume_token(RBRACKET);
4354             switch (jj_nt.kind) {
4355             case LBRACKET:
4356               ;
4357               break;
4358             default:
4359               jj_la1[112] = jj_gen;
4360               break label_58;
4361             }
4362           }
4363           ArrayInitializer();
4364           break;
4365         default:
4366           jj_la1[113] = jj_gen;
4367           jj_consume_token(-1);
4368           throw new ParseException();
4369         }
4370       }
4371     } catch (Throwable jjte000) {
4372     if (jjtc000) {
4373       jjtree.clearNodeScope(jjtn000);
4374       jjtc000 = false;
4375     } else {
4376       jjtree.popNode();
4377     }
4378     if (jjte000 instanceof RuntimeException) {
4379       {if (true) throw (RuntimeException)jjte000;}
4380     }
4381     if (jjte000 instanceof ParseException) {
4382       {if (true) throw (ParseException)jjte000;}
4383     }
4384     {if (true) throw (Error)jjte000;}
4385     } finally {
4386     if (jjtc000) {
4387       jjtree.closeNodeScope(jjtn000, true);
4388     }
4389     }
4390   }
4391 
4392 /*
4393  * Statement syntax follows.
4394  */
4395   final public void Statement() throws ParseException {
4396  /*@bgen(jjtree) Statement */
4397   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
4398   boolean jjtc000 = true;
4399   jjtree.openNodeScope(jjtn000);
4400     try {
4401       if (isNextTokenAnAssert()) {
4402         AssertStatement();
4403       } else if (jj_2_60(2)) {
4404         LabeledStatement();
4405       } else {
4406         switch (jj_nt.kind) {
4407         case LBRACE:
4408           Block();
4409           break;
4410         case SEMICOLON:
4411           EmptyStatement();
4412           break;
4413         case BOOLEAN:
4414         case BYTE:
4415         case CHAR:
4416         case DOUBLE:
4417         case FALSE:
4418         case FLOAT:
4419         case INT:
4420         case LONG:
4421         case NEW:
4422         case NULL:
4423         case SHORT:
4424         case SUPER:
4425         case THIS:
4426         case TRUE:
4427         case VOID:
4428         case INTEGER_LITERAL:
4429         case FLOATING_POINT_LITERAL:
4430         case HEX_FLOATING_POINT_LITERAL:
4431         case CHARACTER_LITERAL:
4432         case STRING_LITERAL:
4433         case IDENTIFIER:
4434         case LPAREN:
4435         case INCR:
4436         case DECR:
4437           StatementExpression();
4438           jj_consume_token(SEMICOLON);
4439           break;
4440         case SWITCH:
4441           SwitchStatement();
4442           break;
4443         case IF:
4444           IfStatement();
4445           break;
4446         case WHILE:
4447           WhileStatement();
4448           break;
4449         case DO:
4450           DoStatement();
4451           break;
4452         case FOR:
4453           ForStatement();
4454           break;
4455         case BREAK:
4456           BreakStatement();
4457           break;
4458         case CONTINUE:
4459           ContinueStatement();
4460           break;
4461         case RETURN:
4462           ReturnStatement();
4463           break;
4464         case THROW:
4465           ThrowStatement();
4466           break;
4467         case SYNCHRONIZED:
4468           SynchronizedStatement();
4469           break;
4470         case TRY:
4471           TryStatement();
4472           break;
4473         default:
4474           jj_la1[114] = jj_gen;
4475           jj_consume_token(-1);
4476           throw new ParseException();
4477         }
4478       }
4479     } catch (Throwable jjte000) {
4480     if (jjtc000) {
4481       jjtree.clearNodeScope(jjtn000);
4482       jjtc000 = false;
4483     } else {
4484       jjtree.popNode();
4485     }
4486     if (jjte000 instanceof RuntimeException) {
4487       {if (true) throw (RuntimeException)jjte000;}
4488     }
4489     if (jjte000 instanceof ParseException) {
4490       {if (true) throw (ParseException)jjte000;}
4491     }
4492     {if (true) throw (Error)jjte000;}
4493     } finally {
4494     if (jjtc000) {
4495       jjtree.closeNodeScope(jjtn000, true);
4496     }
4497     }
4498   }
4499 
4500   final public void LabeledStatement() throws ParseException {
4501  /*@bgen(jjtree) LabeledStatement */
4502  ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
4503  boolean jjtc000 = true;
4504  jjtree.openNodeScope(jjtn000);Token t;
4505     try {
4506       t = jj_consume_token(IDENTIFIER);
4507                   jjtn000.setImage(t.image);
4508       jj_consume_token(COLON);
4509       Statement();
4510     } catch (Throwable jjte000) {
4511     if (jjtc000) {
4512       jjtree.clearNodeScope(jjtn000);
4513       jjtc000 = false;
4514     } else {
4515       jjtree.popNode();
4516     }
4517     if (jjte000 instanceof RuntimeException) {
4518       {if (true) throw (RuntimeException)jjte000;}
4519     }
4520     if (jjte000 instanceof ParseException) {
4521       {if (true) throw (ParseException)jjte000;}
4522     }
4523     {if (true) throw (Error)jjte000;}
4524     } finally {
4525     if (jjtc000) {
4526       jjtree.closeNodeScope(jjtn000, true);
4527     }
4528     }
4529   }
4530 
4531   final public void Block() throws ParseException {
4532  /*@bgen(jjtree) Block */
4533  ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
4534  boolean jjtc000 = true;
4535  jjtree.openNodeScope(jjtn000);Token t;
4536     try {
4537       jj_consume_token(LBRACE);
4538       label_59:
4539       while (true) {
4540         if (jj_2_61(1)) {
4541           ;
4542         } else {
4543           break label_59;
4544         }
4545         BlockStatement();
4546       }
4547       t = jj_consume_token(RBRACE);
4548                                       jjtree.closeNodeScope(jjtn000, true);
4549                                       jjtc000 = false;
4550                                       if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
4551     } catch (Throwable jjte000) {
4552         if (jjtc000) {
4553           jjtree.clearNodeScope(jjtn000);
4554           jjtc000 = false;
4555         } else {
4556           jjtree.popNode();
4557         }
4558         if (jjte000 instanceof RuntimeException) {
4559           {if (true) throw (RuntimeException)jjte000;}
4560         }
4561         if (jjte000 instanceof ParseException) {
4562           {if (true) throw (ParseException)jjte000;}
4563         }
4564         {if (true) throw (Error)jjte000;}
4565     } finally {
4566         if (jjtc000) {
4567           jjtree.closeNodeScope(jjtn000, true);
4568         }
4569     }
4570   }
4571 
4572   final public void BlockStatement() throws ParseException {
4573  /*@bgen(jjtree) BlockStatement */
4574   ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
4575   boolean jjtc000 = true;
4576   jjtree.openNodeScope(jjtn000);
4577     try {
4578       if (isNextTokenAnAssert()) {
4579         AssertStatement();
4580       } else if (jj_2_62(2147483647)) {
4581         LocalVariableDeclaration();
4582         jj_consume_token(SEMICOLON);
4583       } else if (jj_2_63(1)) {
4584         Statement();
4585       } else if (jj_2_64(2147483647)) {
4586         switch (jj_nt.kind) {
4587         case AT:
4588           Annotation();
4589           break;
4590         default:
4591           jj_la1[115] = jj_gen;
4592           ;
4593         }
4594         ClassOrInterfaceDeclaration(0);
4595       } else {
4596         jj_consume_token(-1);
4597         throw new ParseException();
4598       }
4599     } catch (Throwable jjte000) {
4600     if (jjtc000) {
4601       jjtree.clearNodeScope(jjtn000);
4602       jjtc000 = false;
4603     } else {
4604       jjtree.popNode();
4605     }
4606     if (jjte000 instanceof RuntimeException) {
4607       {if (true) throw (RuntimeException)jjte000;}
4608     }
4609     if (jjte000 instanceof ParseException) {
4610       {if (true) throw (ParseException)jjte000;}
4611     }
4612     {if (true) throw (Error)jjte000;}
4613     } finally {
4614     if (jjtc000) {
4615       jjtree.closeNodeScope(jjtn000, true);
4616     }
4617     }
4618   }
4619 
4620   final public void LocalVariableDeclaration() throws ParseException {
4621  /*@bgen(jjtree) LocalVariableDeclaration */
4622   ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
4623   boolean jjtc000 = true;
4624   jjtree.openNodeScope(jjtn000);
4625     try {
4626       label_60:
4627       while (true) {
4628         switch (jj_nt.kind) {
4629         case FINAL:
4630         case AT:
4631           ;
4632           break;
4633         default:
4634           jj_la1[116] = jj_gen;
4635           break label_60;
4636         }
4637         switch (jj_nt.kind) {
4638         case FINAL:
4639           jj_consume_token(FINAL);
4640              jjtn000.setFinal(true);
4641           break;
4642         case AT:
4643           Annotation();
4644           break;
4645         default:
4646           jj_la1[117] = jj_gen;
4647           jj_consume_token(-1);
4648           throw new ParseException();
4649         }
4650       }
4651       Type();
4652       VariableDeclarator();
4653       label_61:
4654       while (true) {
4655         switch (jj_nt.kind) {
4656         case COMMA:
4657           ;
4658           break;
4659         default:
4660           jj_la1[118] = jj_gen;
4661           break label_61;
4662         }
4663         jj_consume_token(COMMA);
4664         VariableDeclarator();
4665       }
4666     } catch (Throwable jjte000) {
4667     if (jjtc000) {
4668       jjtree.clearNodeScope(jjtn000);
4669       jjtc000 = false;
4670     } else {
4671       jjtree.popNode();
4672     }
4673     if (jjte000 instanceof RuntimeException) {
4674       {if (true) throw (RuntimeException)jjte000;}
4675     }
4676     if (jjte000 instanceof ParseException) {
4677       {if (true) throw (ParseException)jjte000;}
4678     }
4679     {if (true) throw (Error)jjte000;}
4680     } finally {
4681     if (jjtc000) {
4682       jjtree.closeNodeScope(jjtn000, true);
4683     }
4684     }
4685   }
4686 
4687   final public void EmptyStatement() throws ParseException {
4688  /*@bgen(jjtree) EmptyStatement */
4689   ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
4690   boolean jjtc000 = true;
4691   jjtree.openNodeScope(jjtn000);
4692     try {
4693       jj_consume_token(SEMICOLON);
4694     } finally {
4695     if (jjtc000) {
4696       jjtree.closeNodeScope(jjtn000, true);
4697     }
4698     }
4699   }
4700 
4701   final public void StatementExpression() throws ParseException {
4702  /*@bgen(jjtree) StatementExpression */
4703   ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
4704   boolean jjtc000 = true;
4705   jjtree.openNodeScope(jjtn000);
4706     try {
4707       switch (jj_nt.kind) {
4708       case INCR:
4709         PreIncrementExpression();
4710         break;
4711       case DECR:
4712         PreDecrementExpression();
4713         break;
4714       default:
4715         jj_la1[120] = jj_gen;
4716         if (jj_2_65(2147483647)) {
4717           PostfixExpression();
4718         } else {
4719           switch (jj_nt.kind) {
4720           case BOOLEAN:
4721           case BYTE:
4722           case CHAR:
4723           case DOUBLE:
4724           case FALSE:
4725           case FLOAT:
4726           case INT:
4727           case LONG:
4728           case NEW:
4729           case NULL:
4730           case SHORT:
4731           case SUPER:
4732           case THIS:
4733           case TRUE:
4734           case VOID:
4735           case INTEGER_LITERAL:
4736           case FLOATING_POINT_LITERAL:
4737           case HEX_FLOATING_POINT_LITERAL:
4738           case CHARACTER_LITERAL:
4739           case STRING_LITERAL:
4740           case IDENTIFIER:
4741           case LPAREN:
4742             PrimaryExpression();
4743             switch (jj_nt.kind) {
4744             case ASSIGN:
4745             case PLUSASSIGN:
4746             case MINUSASSIGN:
4747             case STARASSIGN:
4748             case SLASHASSIGN:
4749             case ANDASSIGN:
4750             case ORASSIGN:
4751             case XORASSIGN:
4752             case REMASSIGN:
4753             case LSHIFTASSIGN:
4754             case RSIGNEDSHIFTASSIGN:
4755             case RUNSIGNEDSHIFTASSIGN:
4756               AssignmentOperator();
4757               Expression();
4758               break;
4759             default:
4760               jj_la1[119] = jj_gen;
4761               ;
4762             }
4763             break;
4764           default:
4765             jj_la1[121] = jj_gen;
4766             jj_consume_token(-1);
4767             throw new ParseException();
4768           }
4769         }
4770       }
4771     } catch (Throwable jjte000) {
4772     if (jjtc000) {
4773       jjtree.clearNodeScope(jjtn000);
4774       jjtc000 = false;
4775     } else {
4776       jjtree.popNode();
4777     }
4778     if (jjte000 instanceof RuntimeException) {
4779       {if (true) throw (RuntimeException)jjte000;}
4780     }
4781     if (jjte000 instanceof ParseException) {
4782       {if (true) throw (ParseException)jjte000;}
4783     }
4784     {if (true) throw (Error)jjte000;}
4785     } finally {
4786     if (jjtc000) {
4787       jjtree.closeNodeScope(jjtn000, true);
4788     }
4789     }
4790   }
4791 
4792   final public void SwitchStatement() throws ParseException {
4793  /*@bgen(jjtree) SwitchStatement */
4794   ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
4795   boolean jjtc000 = true;
4796   jjtree.openNodeScope(jjtn000);
4797     try {
4798       jj_consume_token(SWITCH);
4799       jj_consume_token(LPAREN);
4800       Expression();
4801       jj_consume_token(RPAREN);
4802       jj_consume_token(LBRACE);
4803       label_62:
4804       while (true) {
4805         switch (jj_nt.kind) {
4806         case CASE:
4807         case _DEFAULT:
4808           ;
4809           break;
4810         default:
4811           jj_la1[122] = jj_gen;
4812           break label_62;
4813         }
4814         SwitchLabel();
4815         label_63:
4816         while (true) {
4817           if (jj_2_66(1)) {
4818             ;
4819           } else {
4820             break label_63;
4821           }
4822           BlockStatement();
4823         }
4824       }
4825       jj_consume_token(RBRACE);
4826     } catch (Throwable jjte000) {
4827     if (jjtc000) {
4828       jjtree.clearNodeScope(jjtn000);
4829       jjtc000 = false;
4830     } else {
4831       jjtree.popNode();
4832     }
4833     if (jjte000 instanceof RuntimeException) {
4834       {if (true) throw (RuntimeException)jjte000;}
4835     }
4836     if (jjte000 instanceof ParseException) {
4837       {if (true) throw (ParseException)jjte000;}
4838     }
4839     {if (true) throw (Error)jjte000;}
4840     } finally {
4841     if (jjtc000) {
4842       jjtree.closeNodeScope(jjtn000, true);
4843     }
4844     }
4845   }
4846 
4847   final public void SwitchLabel() throws ParseException {
4848  /*@bgen(jjtree) SwitchLabel */
4849   ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
4850   boolean jjtc000 = true;
4851   jjtree.openNodeScope(jjtn000);
4852     try {
4853       switch (jj_nt.kind) {
4854       case CASE:
4855         jj_consume_token(CASE);
4856         Expression();
4857         jj_consume_token(COLON);
4858         break;
4859       case _DEFAULT:
4860         jj_consume_token(_DEFAULT);
4861              jjtn000.setDefault();
4862         jj_consume_token(COLON);
4863         break;
4864       default:
4865         jj_la1[123] = jj_gen;
4866         jj_consume_token(-1);
4867         throw new ParseException();
4868       }
4869     } catch (Throwable jjte000) {
4870     if (jjtc000) {
4871       jjtree.clearNodeScope(jjtn000);
4872       jjtc000 = false;
4873     } else {
4874       jjtree.popNode();
4875     }
4876     if (jjte000 instanceof RuntimeException) {
4877       {if (true) throw (RuntimeException)jjte000;}
4878     }
4879     if (jjte000 instanceof ParseException) {
4880       {if (true) throw (ParseException)jjte000;}
4881     }
4882     {if (true) throw (Error)jjte000;}
4883     } finally {
4884     if (jjtc000) {
4885       jjtree.closeNodeScope(jjtn000, true);
4886     }
4887     }
4888   }
4889 
4890   final public void IfStatement() throws ParseException {
4891  /*@bgen(jjtree) IfStatement */
4892   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
4893   boolean jjtc000 = true;
4894   jjtree.openNodeScope(jjtn000);
4895     try {
4896       jj_consume_token(IF);
4897       jj_consume_token(LPAREN);
4898       Expression();
4899       jj_consume_token(RPAREN);
4900       Statement();
4901       switch (jj_nt.kind) {
4902       case ELSE:
4903         jj_consume_token(ELSE);
4904                                                                jjtn000.setHasElse();
4905         Statement();
4906         break;
4907       default:
4908         jj_la1[124] = jj_gen;
4909         ;
4910       }
4911   jjtree.closeNodeScope(jjtn000, true);
4912   jjtc000 = false;
4913 
4914     } catch (Throwable jjte000) {
4915     if (jjtc000) {
4916       jjtree.clearNodeScope(jjtn000);
4917       jjtc000 = false;
4918     } else {
4919       jjtree.popNode();
4920     }
4921     if (jjte000 instanceof RuntimeException) {
4922       {if (true) throw (RuntimeException)jjte000;}
4923     }
4924     if (jjte000 instanceof ParseException) {
4925       {if (true) throw (ParseException)jjte000;}
4926     }
4927     {if (true) throw (Error)jjte000;}
4928     } finally {
4929     if (jjtc000) {
4930       jjtree.closeNodeScope(jjtn000, true);
4931     }
4932     }
4933   }
4934 
4935   final public void WhileStatement() throws ParseException {
4936  /*@bgen(jjtree) WhileStatement */
4937   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
4938   boolean jjtc000 = true;
4939   jjtree.openNodeScope(jjtn000);
4940     try {
4941       jj_consume_token(WHILE);
4942       jj_consume_token(LPAREN);
4943       Expression();
4944       jj_consume_token(RPAREN);
4945       Statement();
4946     } catch (Throwable jjte000) {
4947     if (jjtc000) {
4948       jjtree.clearNodeScope(jjtn000);
4949       jjtc000 = false;
4950     } else {
4951       jjtree.popNode();
4952     }
4953     if (jjte000 instanceof RuntimeException) {
4954       {if (true) throw (RuntimeException)jjte000;}
4955     }
4956     if (jjte000 instanceof ParseException) {
4957       {if (true) throw (ParseException)jjte000;}
4958     }
4959     {if (true) throw (Error)jjte000;}
4960     } finally {
4961     if (jjtc000) {
4962       jjtree.closeNodeScope(jjtn000, true);
4963     }
4964     }
4965   }
4966 
4967   final public void DoStatement() throws ParseException {
4968  /*@bgen(jjtree) DoStatement */
4969   ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
4970   boolean jjtc000 = true;
4971   jjtree.openNodeScope(jjtn000);
4972     try {
4973       jj_consume_token(DO);
4974       Statement();
4975       jj_consume_token(WHILE);
4976       jj_consume_token(LPAREN);
4977       Expression();
4978       jj_consume_token(RPAREN);
4979       jj_consume_token(SEMICOLON);
4980     } catch (Throwable jjte000) {
4981     if (jjtc000) {
4982       jjtree.clearNodeScope(jjtn000);
4983       jjtc000 = false;
4984     } else {
4985       jjtree.popNode();
4986     }
4987     if (jjte000 instanceof RuntimeException) {
4988       {if (true) throw (RuntimeException)jjte000;}
4989     }
4990     if (jjte000 instanceof ParseException) {
4991       {if (true) throw (ParseException)jjte000;}
4992     }
4993     {if (true) throw (Error)jjte000;}
4994     } finally {
4995     if (jjtc000) {
4996       jjtree.closeNodeScope(jjtn000, true);
4997     }
4998     }
4999   }
5000 
5001   final public void ForStatement() throws ParseException {
5002  /*@bgen(jjtree) ForStatement */
5003   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
5004   boolean jjtc000 = true;
5005   jjtree.openNodeScope(jjtn000);
5006     try {
5007       jj_consume_token(FOR);
5008       jj_consume_token(LPAREN);
5009       if (jj_2_67(2147483647)) {
5010        checkForBadJDK15ForLoopSyntaxArgumentsUsage();
5011         LocalVariableDeclaration();
5012         jj_consume_token(COLON);
5013         Expression();
5014       } else {
5015         switch (jj_nt.kind) {
5016         case BOOLEAN:
5017         case BYTE:
5018         case CHAR:
5019         case DOUBLE:
5020         case FALSE:
5021         case FINAL:
5022         case FLOAT:
5023         case INT:
5024         case LONG:
5025         case NEW:
5026         case NULL:
5027         case SHORT:
5028         case SUPER:
5029         case THIS:
5030         case TRUE:
5031         case VOID:
5032         case INTEGER_LITERAL:
5033         case FLOATING_POINT_LITERAL:
5034         case HEX_FLOATING_POINT_LITERAL:
5035         case CHARACTER_LITERAL:
5036         case STRING_LITERAL:
5037         case IDENTIFIER:
5038         case LPAREN:
5039         case SEMICOLON:
5040         case AT:
5041         case INCR:
5042         case DECR:
5043           switch (jj_nt.kind) {
5044           case BOOLEAN:
5045           case BYTE:
5046           case CHAR:
5047           case DOUBLE:
5048           case FALSE:
5049           case FINAL:
5050           case FLOAT:
5051           case INT:
5052           case LONG:
5053           case NEW:
5054           case NULL:
5055           case SHORT:
5056           case SUPER:
5057           case THIS:
5058           case TRUE:
5059           case VOID:
5060           case INTEGER_LITERAL:
5061           case FLOATING_POINT_LITERAL:
5062           case HEX_FLOATING_POINT_LITERAL:
5063           case CHARACTER_LITERAL:
5064           case STRING_LITERAL:
5065           case IDENTIFIER:
5066           case LPAREN:
5067           case AT:
5068           case INCR:
5069           case DECR:
5070             ForInit();
5071             break;
5072           default:
5073             jj_la1[125] = jj_gen;
5074             ;
5075           }
5076           jj_consume_token(SEMICOLON);
5077           switch (jj_nt.kind) {
5078           case BOOLEAN:
5079           case BYTE:
5080           case CHAR:
5081           case DOUBLE:
5082           case FALSE:
5083           case FLOAT:
5084           case INT:
5085           case LONG:
5086           case NEW:
5087           case NULL:
5088           case SHORT:
5089           case SUPER:
5090           case THIS:
5091           case TRUE:
5092           case VOID:
5093           case INTEGER_LITERAL:
5094           case FLOATING_POINT_LITERAL:
5095           case HEX_FLOATING_POINT_LITERAL:
5096           case CHARACTER_LITERAL:
5097           case STRING_LITERAL:
5098           case IDENTIFIER:
5099           case LPAREN:
5100           case BANG:
5101           case TILDE:
5102           case INCR:
5103           case DECR:
5104           case PLUS:
5105           case MINUS:
5106             Expression();
5107             break;
5108           default:
5109             jj_la1[126] = jj_gen;
5110             ;
5111           }
5112           jj_consume_token(SEMICOLON);
5113           switch (jj_nt.kind) {
5114           case BOOLEAN:
5115           case BYTE:
5116           case CHAR:
5117           case DOUBLE:
5118           case FALSE:
5119           case FLOAT:
5120           case INT:
5121           case LONG:
5122           case NEW:
5123           case NULL:
5124           case SHORT:
5125           case SUPER:
5126           case THIS:
5127           case TRUE:
5128           case VOID:
5129           case INTEGER_LITERAL:
5130           case FLOATING_POINT_LITERAL:
5131           case HEX_FLOATING_POINT_LITERAL:
5132           case CHARACTER_LITERAL:
5133           case STRING_LITERAL:
5134           case IDENTIFIER:
5135           case LPAREN:
5136           case INCR:
5137           case DECR:
5138             ForUpdate();
5139             break;
5140           default:
5141             jj_la1[127] = jj_gen;
5142             ;
5143           }
5144           break;
5145         default:
5146           jj_la1[128] = jj_gen;
5147           jj_consume_token(-1);
5148           throw new ParseException();
5149         }
5150       }
5151       jj_consume_token(RPAREN);
5152       Statement();
5153     } catch (Throwable jjte000) {
5154     if (jjtc000) {
5155       jjtree.clearNodeScope(jjtn000);
5156       jjtc000 = false;
5157     } else {
5158       jjtree.popNode();
5159     }
5160     if (jjte000 instanceof RuntimeException) {
5161       {if (true) throw (RuntimeException)jjte000;}
5162     }
5163     if (jjte000 instanceof ParseException) {
5164       {if (true) throw (ParseException)jjte000;}
5165     }
5166     {if (true) throw (Error)jjte000;}
5167     } finally {
5168     if (jjtc000) {
5169       jjtree.closeNodeScope(jjtn000, true);
5170     }
5171     }
5172   }
5173 
5174   final public void ForInit() throws ParseException {
5175  /*@bgen(jjtree) ForInit */
5176   ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
5177   boolean jjtc000 = true;
5178   jjtree.openNodeScope(jjtn000);
5179     try {
5180       if (jj_2_68(2147483647)) {
5181         LocalVariableDeclaration();
5182       } else {
5183         switch (jj_nt.kind) {
5184         case BOOLEAN:
5185         case BYTE:
5186         case CHAR:
5187         case DOUBLE:
5188         case FALSE:
5189         case FLOAT:
5190         case INT:
5191         case LONG:
5192         case NEW:
5193         case NULL:
5194         case SHORT:
5195         case SUPER:
5196         case THIS:
5197         case TRUE:
5198         case VOID:
5199         case INTEGER_LITERAL:
5200         case FLOATING_POINT_LITERAL:
5201         case HEX_FLOATING_POINT_LITERAL:
5202         case CHARACTER_LITERAL:
5203         case STRING_LITERAL:
5204         case IDENTIFIER:
5205         case LPAREN:
5206         case INCR:
5207         case DECR:
5208           StatementExpressionList();
5209           break;
5210         default:
5211           jj_la1[129] = jj_gen;
5212           jj_consume_token(-1);
5213           throw new ParseException();
5214         }
5215       }
5216     } catch (Throwable jjte000) {
5217     if (jjtc000) {
5218       jjtree.clearNodeScope(jjtn000);
5219       jjtc000 = false;
5220     } else {
5221       jjtree.popNode();
5222     }
5223     if (jjte000 instanceof RuntimeException) {
5224       {if (true) throw (RuntimeException)jjte000;}
5225     }
5226     if (jjte000 instanceof ParseException) {
5227       {if (true) throw (ParseException)jjte000;}
5228     }
5229     {if (true) throw (Error)jjte000;}
5230     } finally {
5231     if (jjtc000) {
5232       jjtree.closeNodeScope(jjtn000, true);
5233     }
5234     }
5235   }
5236 
5237   final public void StatementExpressionList() throws ParseException {
5238  /*@bgen(jjtree) StatementExpressionList */
5239   ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
5240   boolean jjtc000 = true;
5241   jjtree.openNodeScope(jjtn000);
5242     try {
5243       StatementExpression();
5244       label_64:
5245       while (true) {
5246         switch (jj_nt.kind) {
5247         case COMMA:
5248           ;
5249           break;
5250         default:
5251           jj_la1[130] = jj_gen;
5252           break label_64;
5253         }
5254         jj_consume_token(COMMA);
5255         StatementExpression();
5256       }
5257     } catch (Throwable jjte000) {
5258     if (jjtc000) {
5259       jjtree.clearNodeScope(jjtn000);
5260       jjtc000 = false;
5261     } else {
5262       jjtree.popNode();
5263     }
5264     if (jjte000 instanceof RuntimeException) {
5265       {if (true) throw (RuntimeException)jjte000;}
5266     }
5267     if (jjte000 instanceof ParseException) {
5268       {if (true) throw (ParseException)jjte000;}
5269     }
5270     {if (true) throw (Error)jjte000;}
5271     } finally {
5272     if (jjtc000) {
5273       jjtree.closeNodeScope(jjtn000, true);
5274     }
5275     }
5276   }
5277 
5278   final public void ForUpdate() throws ParseException {
5279  /*@bgen(jjtree) ForUpdate */
5280   ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
5281   boolean jjtc000 = true;
5282   jjtree.openNodeScope(jjtn000);
5283     try {
5284       StatementExpressionList();
5285     } catch (Throwable jjte000) {
5286     if (jjtc000) {
5287       jjtree.clearNodeScope(jjtn000);
5288       jjtc000 = false;
5289     } else {
5290       jjtree.popNode();
5291     }
5292     if (jjte000 instanceof RuntimeException) {
5293       {if (true) throw (RuntimeException)jjte000;}
5294     }
5295     if (jjte000 instanceof ParseException) {
5296       {if (true) throw (ParseException)jjte000;}
5297     }
5298     {if (true) throw (Error)jjte000;}
5299     } finally {
5300     if (jjtc000) {
5301       jjtree.closeNodeScope(jjtn000, true);
5302     }
5303     }
5304   }
5305 
5306   final public void BreakStatement() throws ParseException {
5307  /*@bgen(jjtree) BreakStatement */
5308  ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
5309  boolean jjtc000 = true;
5310  jjtree.openNodeScope(jjtn000);Token t;
5311     try {
5312       jj_consume_token(BREAK);
5313       switch (jj_nt.kind) {
5314       case IDENTIFIER:
5315         t = jj_consume_token(IDENTIFIER);
5316                             jjtn000.setImage(t.image);
5317         break;
5318       default:
5319         jj_la1[131] = jj_gen;
5320         ;
5321       }
5322       jj_consume_token(SEMICOLON);
5323     } finally {
5324     if (jjtc000) {
5325       jjtree.closeNodeScope(jjtn000, true);
5326     }
5327     }
5328   }
5329 
5330   final public void ContinueStatement() throws ParseException {
5331  /*@bgen(jjtree) ContinueStatement */
5332  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
5333  boolean jjtc000 = true;
5334  jjtree.openNodeScope(jjtn000);Token t;
5335     try {
5336       jj_consume_token(CONTINUE);
5337       switch (jj_nt.kind) {
5338       case IDENTIFIER:
5339         t = jj_consume_token(IDENTIFIER);
5340                                jjtn000.setImage(t.image);
5341         break;
5342       default:
5343         jj_la1[132] = jj_gen;
5344         ;
5345       }
5346       jj_consume_token(SEMICOLON);
5347     } finally {
5348     if (jjtc000) {
5349       jjtree.closeNodeScope(jjtn000, true);
5350     }
5351     }
5352   }
5353 
5354   final public void ReturnStatement() throws ParseException {
5355  /*@bgen(jjtree) ReturnStatement */
5356   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
5357   boolean jjtc000 = true;
5358   jjtree.openNodeScope(jjtn000);
5359     try {
5360       jj_consume_token(RETURN);
5361       switch (jj_nt.kind) {
5362       case BOOLEAN:
5363       case BYTE:
5364       case CHAR:
5365       case DOUBLE:
5366       case FALSE:
5367       case FLOAT:
5368       case INT:
5369       case LONG:
5370       case NEW:
5371       case NULL:
5372       case SHORT:
5373       case SUPER:
5374       case THIS:
5375       case TRUE:
5376       case VOID:
5377       case INTEGER_LITERAL:
5378       case FLOATING_POINT_LITERAL:
5379       case HEX_FLOATING_POINT_LITERAL:
5380       case CHARACTER_LITERAL:
5381       case STRING_LITERAL:
5382       case IDENTIFIER:
5383       case LPAREN:
5384       case BANG:
5385       case TILDE:
5386       case INCR:
5387       case DECR:
5388       case PLUS:
5389       case MINUS:
5390         Expression();
5391         break;
5392       default:
5393         jj_la1[133] = jj_gen;
5394         ;
5395       }
5396       jj_consume_token(SEMICOLON);
5397     } catch (Throwable jjte000) {
5398     if (jjtc000) {
5399       jjtree.clearNodeScope(jjtn000);
5400       jjtc000 = false;
5401     } else {
5402       jjtree.popNode();
5403     }
5404     if (jjte000 instanceof RuntimeException) {
5405       {if (true) throw (RuntimeException)jjte000;}
5406     }
5407     if (jjte000 instanceof ParseException) {
5408       {if (true) throw (ParseException)jjte000;}
5409     }
5410     {if (true) throw (Error)jjte000;}
5411     } finally {
5412     if (jjtc000) {
5413       jjtree.closeNodeScope(jjtn000, true);
5414     }
5415     }
5416   }
5417 
5418   final public void ThrowStatement() throws ParseException {
5419  /*@bgen(jjtree) ThrowStatement */
5420   ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
5421   boolean jjtc000 = true;
5422   jjtree.openNodeScope(jjtn000);
5423     try {
5424       jj_consume_token(THROW);
5425       Expression();
5426       jj_consume_token(SEMICOLON);
5427     } catch (Throwable jjte000) {
5428     if (jjtc000) {
5429       jjtree.clearNodeScope(jjtn000);
5430       jjtc000 = false;
5431     } else {
5432       jjtree.popNode();
5433     }
5434     if (jjte000 instanceof RuntimeException) {
5435       {if (true) throw (RuntimeException)jjte000;}
5436     }
5437     if (jjte000 instanceof ParseException) {
5438       {if (true) throw (ParseException)jjte000;}
5439     }
5440     {if (true) throw (Error)jjte000;}
5441     } finally {
5442     if (jjtc000) {
5443       jjtree.closeNodeScope(jjtn000, true);
5444     }
5445     }
5446   }
5447 
5448   final public void SynchronizedStatement() throws ParseException {
5449  /*@bgen(jjtree) SynchronizedStatement */
5450   ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
5451   boolean jjtc000 = true;
5452   jjtree.openNodeScope(jjtn000);
5453     try {
5454       jj_consume_token(SYNCHRONIZED);
5455       jj_consume_token(LPAREN);
5456       Expression();
5457       jj_consume_token(RPAREN);
5458       Block();
5459     } catch (Throwable jjte000) {
5460     if (jjtc000) {
5461       jjtree.clearNodeScope(jjtn000);
5462       jjtc000 = false;
5463     } else {
5464       jjtree.popNode();
5465     }
5466     if (jjte000 instanceof RuntimeException) {
5467       {if (true) throw (RuntimeException)jjte000;}
5468     }
5469     if (jjte000 instanceof ParseException) {
5470       {if (true) throw (ParseException)jjte000;}
5471     }
5472     {if (true) throw (Error)jjte000;}
5473     } finally {
5474     if (jjtc000) {
5475       jjtree.closeNodeScope(jjtn000, true);
5476     }
5477     }
5478   }
5479 
5480   final public void TryStatement() throws ParseException {
5481  /*@bgen(jjtree) TryStatement */
5482   ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
5483   boolean jjtc000 = true;
5484   jjtree.openNodeScope(jjtn000);
5485     try {
5486       jj_consume_token(TRY);
5487       switch (jj_nt.kind) {
5488       case LPAREN:
5489         ResourceSpecification();
5490         break;
5491       default:
5492         jj_la1[134] = jj_gen;
5493         ;
5494       }
5495       Block();
5496       label_65:
5497       while (true) {
5498         switch (jj_nt.kind) {
5499         case CATCH:
5500           ;
5501           break;
5502         default:
5503           jj_la1[135] = jj_gen;
5504           break label_65;
5505         }
5506         CatchStatement();
5507       }
5508       switch (jj_nt.kind) {
5509       case FINALLY:
5510         FinallyStatement();
5511         break;
5512       default:
5513         jj_la1[136] = jj_gen;
5514         ;
5515       }
5516     } catch (Throwable jjte000) {
5517     if (jjtc000) {
5518       jjtree.clearNodeScope(jjtn000);
5519       jjtc000 = false;
5520     } else {
5521       jjtree.popNode();
5522     }
5523     if (jjte000 instanceof RuntimeException) {
5524       {if (true) throw (RuntimeException)jjte000;}
5525     }
5526     if (jjte000 instanceof ParseException) {
5527       {if (true) throw (ParseException)jjte000;}
5528     }
5529     {if (true) throw (Error)jjte000;}
5530     } finally {
5531     if (jjtc000) {
5532       jjtree.closeNodeScope(jjtn000, true);
5533     }
5534     }
5535   }
5536 
5537   final public void ResourceSpecification() throws ParseException {
5538  /*@bgen(jjtree) ResourceSpecification */
5539   ASTResourceSpecification jjtn000 = new ASTResourceSpecification(this, JJTRESOURCESPECIFICATION);
5540   boolean jjtc000 = true;
5541   jjtree.openNodeScope(jjtn000);
5542     try {
5543      checkForBadTryWithResourcesUsage();
5544       jj_consume_token(LPAREN);
5545       Resources();
5546       if (jj_2_69(2)) {
5547         jj_consume_token(SEMICOLON);
5548       } else {
5549         ;
5550       }
5551       jj_consume_token(RPAREN);
5552     } catch (Throwable jjte000) {
5553       if (jjtc000) {
5554         jjtree.clearNodeScope(jjtn000);
5555         jjtc000 = false;
5556       } else {
5557         jjtree.popNode();
5558       }
5559       if (jjte000 instanceof RuntimeException) {
5560         {if (true) throw (RuntimeException)jjte000;}
5561       }
5562       if (jjte000 instanceof ParseException) {
5563         {if (true) throw (ParseException)jjte000;}
5564       }
5565       {if (true) throw (Error)jjte000;}
5566     } finally {
5567       if (jjtc000) {
5568         jjtree.closeNodeScope(jjtn000, true);
5569       }
5570     }
5571   }
5572 
5573   final public void Resources() throws ParseException {
5574  /*@bgen(jjtree) Resources */
5575   ASTResources jjtn000 = new ASTResources(this, JJTRESOURCES);
5576   boolean jjtc000 = true;
5577   jjtree.openNodeScope(jjtn000);
5578     try {
5579       Resource();
5580       label_66:
5581       while (true) {
5582         if (jj_2_70(2)) {
5583           ;
5584         } else {
5585           break label_66;
5586         }
5587         jj_consume_token(SEMICOLON);
5588         Resource();
5589       }
5590     } catch (Throwable jjte000) {
5591           if (jjtc000) {
5592             jjtree.clearNodeScope(jjtn000);
5593             jjtc000 = false;
5594           } else {
5595             jjtree.popNode();
5596           }
5597           if (jjte000 instanceof RuntimeException) {
5598             {if (true) throw (RuntimeException)jjte000;}
5599           }
5600           if (jjte000 instanceof ParseException) {
5601             {if (true) throw (ParseException)jjte000;}
5602           }
5603           {if (true) throw (Error)jjte000;}
5604     } finally {
5605           if (jjtc000) {
5606             jjtree.closeNodeScope(jjtn000, true);
5607           }
5608     }
5609   }
5610 
5611   final public void Resource() throws ParseException {
5612  /*@bgen(jjtree) Resource */
5613   ASTResource jjtn000 = new ASTResource(this, JJTRESOURCE);
5614   boolean jjtc000 = true;
5615   jjtree.openNodeScope(jjtn000);
5616     try {
5617       label_67:
5618       while (true) {
5619         switch (jj_nt.kind) {
5620         case FINAL:
5621         case AT:
5622           ;
5623           break;
5624         default:
5625           jj_la1[137] = jj_gen;
5626           break label_67;
5627         }
5628         switch (jj_nt.kind) {
5629         case FINAL:
5630           jj_consume_token(FINAL);
5631           break;
5632         case AT:
5633           Annotation();
5634           break;
5635         default:
5636           jj_la1[138] = jj_gen;
5637           jj_consume_token(-1);
5638           throw new ParseException();
5639         }
5640       }
5641       Type();
5642       VariableDeclaratorId();
5643       jj_consume_token(ASSIGN);
5644       Expression();
5645     } catch (Throwable jjte000) {
5646           if (jjtc000) {
5647             jjtree.clearNodeScope(jjtn000);
5648             jjtc000 = false;
5649           } else {
5650             jjtree.popNode();
5651           }
5652           if (jjte000 instanceof RuntimeException) {
5653             {if (true) throw (RuntimeException)jjte000;}
5654           }
5655           if (jjte000 instanceof ParseException) {
5656             {if (true) throw (ParseException)jjte000;}
5657           }
5658           {if (true) throw (Error)jjte000;}
5659     } finally {
5660           if (jjtc000) {
5661             jjtree.closeNodeScope(jjtn000, true);
5662           }
5663     }
5664   }
5665 
5666   final public void CatchStatement() throws ParseException {
5667  /*@bgen(jjtree) CatchStatement */
5668   ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
5669   boolean jjtc000 = true;
5670   jjtree.openNodeScope(jjtn000);
5671     try {
5672       jj_consume_token(CATCH);
5673       jj_consume_token(LPAREN);
5674       FormalParameter();
5675       jj_consume_token(RPAREN);
5676       Block();
5677     } catch (Throwable jjte000) {
5678     if (jjtc000) {
5679       jjtree.clearNodeScope(jjtn000);
5680       jjtc000 = false;
5681     } else {
5682       jjtree.popNode();
5683     }
5684     if (jjte000 instanceof RuntimeException) {
5685       {if (true) throw (RuntimeException)jjte000;}
5686     }
5687     if (jjte000 instanceof ParseException) {
5688       {if (true) throw (ParseException)jjte000;}
5689     }
5690     {if (true) throw (Error)jjte000;}
5691     } finally {
5692     if (jjtc000) {
5693       jjtree.closeNodeScope(jjtn000, true);
5694     }
5695     }
5696   }
5697 
5698   final public void FinallyStatement() throws ParseException {
5699  /*@bgen(jjtree) FinallyStatement */
5700   ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
5701   boolean jjtc000 = true;
5702   jjtree.openNodeScope(jjtn000);
5703     try {
5704       jj_consume_token(FINALLY);
5705       Block();
5706     } catch (Throwable jjte000) {
5707       if (jjtc000) {
5708         jjtree.clearNodeScope(jjtn000);
5709         jjtc000 = false;
5710       } else {
5711         jjtree.popNode();
5712       }
5713       if (jjte000 instanceof RuntimeException) {
5714         {if (true) throw (RuntimeException)jjte000;}
5715       }
5716       if (jjte000 instanceof ParseException) {
5717         {if (true) throw (ParseException)jjte000;}
5718       }
5719       {if (true) throw (Error)jjte000;}
5720     } finally {
5721       if (jjtc000) {
5722         jjtree.closeNodeScope(jjtn000, true);
5723       }
5724     }
5725   }
5726 
5727   final public void AssertStatement() throws ParseException {
5728  /*@bgen(jjtree) AssertStatement */
5729     ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
5730     boolean jjtc000 = true;
5731     jjtree.openNodeScope(jjtn000);if (jdkVersion <= 3) {
5732         throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
5733     }
5734     try {
5735       jj_consume_token(IDENTIFIER);
5736       Expression();
5737       switch (jj_nt.kind) {
5738       case COLON:
5739         jj_consume_token(COLON);
5740         Expression();
5741         break;
5742       default:
5743         jj_la1[139] = jj_gen;
5744         ;
5745       }
5746       jj_consume_token(SEMICOLON);
5747     } catch (Throwable jjte000) {
5748     if (jjtc000) {
5749       jjtree.clearNodeScope(jjtn000);
5750       jjtc000 = false;
5751     } else {
5752       jjtree.popNode();
5753     }
5754     if (jjte000 instanceof RuntimeException) {
5755       {if (true) throw (RuntimeException)jjte000;}
5756     }
5757     if (jjte000 instanceof ParseException) {
5758       {if (true) throw (ParseException)jjte000;}
5759     }
5760     {if (true) throw (Error)jjte000;}
5761     } finally {
5762     if (jjtc000) {
5763       jjtree.closeNodeScope(jjtn000, true);
5764     }
5765     }
5766   }
5767 
5768 /* We use productions to match >>>, >> and > so that we can keep the
5769  * type declaration syntax with generics clean
5770  */
5771   final public void RUNSIGNEDSHIFT() throws ParseException {
5772  /*@bgen(jjtree) RUNSIGNEDSHIFT */
5773   ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
5774   boolean jjtc000 = true;
5775   jjtree.openNodeScope(jjtn000);
5776     try {
5777       if (getToken(1).kind == GT &&
5778                       ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
5779 
5780       } else {
5781         jj_consume_token(-1);
5782         throw new ParseException();
5783       }
5784       jj_consume_token(GT);
5785       jj_consume_token(GT);
5786       jj_consume_token(GT);
5787     } finally {
5788     if (jjtc000) {
5789       jjtree.closeNodeScope(jjtn000, true);
5790     }
5791     }
5792   }
5793 
5794   final public void RSIGNEDSHIFT() throws ParseException {
5795  /*@bgen(jjtree) RSIGNEDSHIFT */
5796   ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
5797   boolean jjtc000 = true;
5798   jjtree.openNodeScope(jjtn000);
5799     try {
5800       if (getToken(1).kind == GT &&
5801                       ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
5802 
5803       } else {
5804         jj_consume_token(-1);
5805         throw new ParseException();
5806       }
5807       jj_consume_token(GT);
5808       jj_consume_token(GT);
5809     } finally {
5810     if (jjtc000) {
5811       jjtree.closeNodeScope(jjtn000, true);
5812     }
5813     }
5814   }
5815 
5816 /* Annotation syntax follows. */
5817   final public void Annotation() throws ParseException {
5818  /*@bgen(jjtree) Annotation */
5819   ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
5820   boolean jjtc000 = true;
5821   jjtree.openNodeScope(jjtn000);
5822     try {
5823       if (jj_2_71(2147483647)) {
5824         NormalAnnotation();
5825       } else if (jj_2_72(2147483647)) {
5826         SingleMemberAnnotation();
5827       } else {
5828         switch (jj_nt.kind) {
5829         case AT:
5830           MarkerAnnotation();
5831           break;
5832         default:
5833           jj_la1[140] = jj_gen;
5834           jj_consume_token(-1);
5835           throw new ParseException();
5836         }
5837       }
5838     } catch (Throwable jjte000) {
5839      if (jjtc000) {
5840        jjtree.clearNodeScope(jjtn000);
5841        jjtc000 = false;
5842      } else {
5843        jjtree.popNode();
5844      }
5845      if (jjte000 instanceof RuntimeException) {
5846        {if (true) throw (RuntimeException)jjte000;}
5847      }
5848      if (jjte000 instanceof ParseException) {
5849        {if (true) throw (ParseException)jjte000;}
5850      }
5851      {if (true) throw (Error)jjte000;}
5852     } finally {
5853      if (jjtc000) {
5854        jjtree.closeNodeScope(jjtn000, true);
5855      }
5856     }
5857   }
5858 
5859   final public void NormalAnnotation() throws ParseException {
5860  /*@bgen(jjtree) NormalAnnotation */
5861   ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
5862   boolean jjtc000 = true;
5863   jjtree.openNodeScope(jjtn000);
5864     try {
5865       jj_consume_token(AT);
5866       Name();
5867       jj_consume_token(LPAREN);
5868       switch (jj_nt.kind) {
5869       case IDENTIFIER:
5870         MemberValuePairs();
5871         break;
5872       default:
5873         jj_la1[141] = jj_gen;
5874         ;
5875       }
5876       jj_consume_token(RPAREN);
5877                                                jjtree.closeNodeScope(jjtn000, true);
5878                                                jjtc000 = false;
5879                                               checkForBadAnnotationUsage();
5880     } catch (Throwable jjte000) {
5881      if (jjtc000) {
5882        jjtree.clearNodeScope(jjtn000);
5883        jjtc000 = false;
5884      } else {
5885        jjtree.popNode();
5886      }
5887      if (jjte000 instanceof RuntimeException) {
5888        {if (true) throw (RuntimeException)jjte000;}
5889      }
5890      if (jjte000 instanceof ParseException) {
5891        {if (true) throw (ParseException)jjte000;}
5892      }
5893      {if (true) throw (Error)jjte000;}
5894     } finally {
5895      if (jjtc000) {
5896        jjtree.closeNodeScope(jjtn000, true);
5897      }
5898     }
5899   }
5900 
5901   final public void MarkerAnnotation() throws ParseException {
5902  /*@bgen(jjtree) MarkerAnnotation */
5903   ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
5904   boolean jjtc000 = true;
5905   jjtree.openNodeScope(jjtn000);
5906     try {
5907       jj_consume_token(AT);
5908       Name();
5909                jjtree.closeNodeScope(jjtn000, true);
5910                jjtc000 = false;
5911               checkForBadAnnotationUsage();
5912     } catch (Throwable jjte000) {
5913     if (jjtc000) {
5914       jjtree.clearNodeScope(jjtn000);
5915       jjtc000 = false;
5916     } else {
5917       jjtree.popNode();
5918     }
5919     if (jjte000 instanceof RuntimeException) {
5920       {if (true) throw (RuntimeException)jjte000;}
5921     }
5922     if (jjte000 instanceof ParseException) {
5923       {if (true) throw (ParseException)jjte000;}
5924     }
5925     {if (true) throw (Error)jjte000;}
5926     } finally {
5927     if (jjtc000) {
5928       jjtree.closeNodeScope(jjtn000, true);
5929     }
5930     }
5931   }
5932 
5933   final public void SingleMemberAnnotation() throws ParseException {
5934  /*@bgen(jjtree) SingleMemberAnnotation */
5935   ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
5936   boolean jjtc000 = true;
5937   jjtree.openNodeScope(jjtn000);
5938     try {
5939       jj_consume_token(AT);
5940       Name();
5941       jj_consume_token(LPAREN);
5942       MemberValue();
5943       jj_consume_token(RPAREN);
5944                                      jjtree.closeNodeScope(jjtn000, true);
5945                                      jjtc000 = false;
5946                                     checkForBadAnnotationUsage();
5947     } catch (Throwable jjte000) {
5948     if (jjtc000) {
5949       jjtree.clearNodeScope(jjtn000);
5950       jjtc000 = false;
5951     } else {
5952       jjtree.popNode();
5953     }
5954     if (jjte000 instanceof RuntimeException) {
5955       {if (true) throw (RuntimeException)jjte000;}
5956     }
5957     if (jjte000 instanceof ParseException) {
5958       {if (true) throw (ParseException)jjte000;}
5959     }
5960     {if (true) throw (Error)jjte000;}
5961     } finally {
5962     if (jjtc000) {
5963       jjtree.closeNodeScope(jjtn000, true);
5964     }
5965     }
5966   }
5967 
5968   final public void MemberValuePairs() throws ParseException {
5969  /*@bgen(jjtree) MemberValuePairs */
5970   ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
5971   boolean jjtc000 = true;
5972   jjtree.openNodeScope(jjtn000);
5973     try {
5974       MemberValuePair();
5975       label_68:
5976       while (true) {
5977         switch (jj_nt.kind) {
5978         case COMMA:
5979           ;
5980           break;
5981         default:
5982           jj_la1[142] = jj_gen;
5983           break label_68;
5984         }
5985         jj_consume_token(COMMA);
5986         MemberValuePair();
5987       }
5988     } catch (Throwable jjte000) {
5989      if (jjtc000) {
5990        jjtree.clearNodeScope(jjtn000);
5991        jjtc000 = false;
5992      } else {
5993        jjtree.popNode();
5994      }
5995      if (jjte000 instanceof RuntimeException) {
5996        {if (true) throw (RuntimeException)jjte000;}
5997      }
5998      if (jjte000 instanceof ParseException) {
5999        {if (true) throw (ParseException)jjte000;}
6000      }
6001      {if (true) throw (Error)jjte000;}
6002     } finally {
6003      if (jjtc000) {
6004        jjtree.closeNodeScope(jjtn000, true);
6005      }
6006     }
6007   }
6008 
6009   final public void MemberValuePair() throws ParseException {
6010  /*@bgen(jjtree) MemberValuePair */
6011  ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
6012  boolean jjtc000 = true;
6013  jjtree.openNodeScope(jjtn000);Token t;
6014     try {
6015       t = jj_consume_token(IDENTIFIER);
6016                      jjtn000.setImage(t.image);
6017       jj_consume_token(ASSIGN);
6018       MemberValue();
6019     } catch (Throwable jjte000) {
6020       if (jjtc000) {
6021         jjtree.clearNodeScope(jjtn000);
6022         jjtc000 = false;
6023       } else {
6024         jjtree.popNode();
6025       }
6026       if (jjte000 instanceof RuntimeException) {
6027         {if (true) throw (RuntimeException)jjte000;}
6028       }
6029       if (jjte000 instanceof ParseException) {
6030         {if (true) throw (ParseException)jjte000;}
6031       }
6032       {if (true) throw (Error)jjte000;}
6033     } finally {
6034       if (jjtc000) {
6035         jjtree.closeNodeScope(jjtn000, true);
6036       }
6037     }
6038   }
6039 
6040   final public void MemberValue() throws ParseException {
6041  /*@bgen(jjtree) MemberValue */
6042   ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
6043   boolean jjtc000 = true;
6044   jjtree.openNodeScope(jjtn000);
6045     try {
6046       switch (jj_nt.kind) {
6047       case AT:
6048         Annotation();
6049         break;
6050       case LBRACE:
6051         MemberValueArrayInitializer();
6052         break;
6053       case BOOLEAN:
6054       case BYTE:
6055       case CHAR:
6056       case DOUBLE:
6057       case FALSE:
6058       case FLOAT:
6059       case INT:
6060       case LONG:
6061       case NEW:
6062       case NULL:
6063       case SHORT:
6064       case SUPER:
6065       case THIS:
6066       case TRUE:
6067       case VOID:
6068       case INTEGER_LITERAL:
6069       case FLOATING_POINT_LITERAL:
6070       case HEX_FLOATING_POINT_LITERAL:
6071       case CHARACTER_LITERAL:
6072       case STRING_LITERAL:
6073       case IDENTIFIER:
6074       case LPAREN:
6075       case BANG:
6076       case TILDE:
6077       case INCR:
6078       case DECR:
6079       case PLUS:
6080       case MINUS:
6081         ConditionalExpression();
6082         break;
6083       default:
6084         jj_la1[143] = jj_gen;
6085         jj_consume_token(-1);
6086         throw new ParseException();
6087       }
6088     } catch (Throwable jjte000) {
6089      if (jjtc000) {
6090        jjtree.clearNodeScope(jjtn000);
6091        jjtc000 = false;
6092      } else {
6093        jjtree.popNode();
6094      }
6095      if (jjte000 instanceof RuntimeException) {
6096        {if (true) throw (RuntimeException)jjte000;}
6097      }
6098      if (jjte000 instanceof ParseException) {
6099        {if (true) throw (ParseException)jjte000;}
6100      }
6101      {if (true) throw (Error)jjte000;}
6102     } finally {
6103      if (jjtc000) {
6104        jjtree.closeNodeScope(jjtn000, true);
6105      }
6106     }
6107   }
6108 
6109   final public void MemberValueArrayInitializer() throws ParseException {
6110  /*@bgen(jjtree) MemberValueArrayInitializer */
6111   ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
6112   boolean jjtc000 = true;
6113   jjtree.openNodeScope(jjtn000);
6114     try {
6115       jj_consume_token(LBRACE);
6116       switch (jj_nt.kind) {
6117       case BOOLEAN:
6118       case BYTE:
6119       case CHAR:
6120       case DOUBLE:
6121       case FALSE:
6122       case FLOAT:
6123       case INT:
6124       case LONG:
6125       case NEW:
6126       case NULL:
6127       case SHORT:
6128       case SUPER:
6129       case THIS:
6130       case TRUE:
6131       case VOID:
6132       case INTEGER_LITERAL:
6133       case FLOATING_POINT_LITERAL:
6134       case HEX_FLOATING_POINT_LITERAL:
6135       case CHARACTER_LITERAL:
6136       case STRING_LITERAL:
6137       case IDENTIFIER:
6138       case LPAREN:
6139       case LBRACE:
6140       case AT:
6141       case BANG:
6142       case TILDE:
6143       case INCR:
6144       case DECR:
6145       case PLUS:
6146       case MINUS:
6147         MemberValue();
6148         label_69:
6149         while (true) {
6150           if (jj_2_73(2)) {
6151             ;
6152           } else {
6153             break label_69;
6154           }
6155           jj_consume_token(COMMA);
6156           MemberValue();
6157         }
6158         switch (jj_nt.kind) {
6159         case COMMA:
6160           jj_consume_token(COMMA);
6161           break;
6162         default:
6163           jj_la1[144] = jj_gen;
6164           ;
6165         }
6166         break;
6167       default:
6168         jj_la1[145] = jj_gen;
6169         ;
6170       }
6171       jj_consume_token(RBRACE);
6172     } catch (Throwable jjte000) {
6173     if (jjtc000) {
6174       jjtree.clearNodeScope(jjtn000);
6175       jjtc000 = false;
6176     } else {
6177       jjtree.popNode();
6178     }
6179     if (jjte000 instanceof RuntimeException) {
6180       {if (true) throw (RuntimeException)jjte000;}
6181     }
6182     if (jjte000 instanceof ParseException) {
6183       {if (true) throw (ParseException)jjte000;}
6184     }
6185     {if (true) throw (Error)jjte000;}
6186     } finally {
6187     if (jjtc000) {
6188       jjtree.closeNodeScope(jjtn000, true);
6189     }
6190     }
6191   }
6192 
6193 /* Annotation Types. */
6194   final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
6195  /*@bgen(jjtree) AnnotationTypeDeclaration */
6196 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
6197 boolean jjtc000 = true;
6198 jjtree.openNodeScope(jjtn000);Token t;
6199 jjtn000.setModifiers(modifiers);
6200     try {
6201       jj_consume_token(AT);
6202       jj_consume_token(INTERFACE);
6203       t = jj_consume_token(IDENTIFIER);
6204                                   checkForBadAnnotationUsage();jjtn000.setImage(t.image);
6205       AnnotationTypeBody();
6206     } catch (Throwable jjte000) {
6207     if (jjtc000) {
6208       jjtree.clearNodeScope(jjtn000);
6209       jjtc000 = false;
6210     } else {
6211       jjtree.popNode();
6212     }
6213     if (jjte000 instanceof RuntimeException) {
6214       {if (true) throw (RuntimeException)jjte000;}
6215     }
6216     if (jjte000 instanceof ParseException) {
6217       {if (true) throw (ParseException)jjte000;}
6218     }
6219     {if (true) throw (Error)jjte000;}
6220     } finally {
6221     if (jjtc000) {
6222       jjtree.closeNodeScope(jjtn000, true);
6223     }
6224     }
6225   }
6226 
6227   final public void AnnotationTypeBody() throws ParseException {
6228  /*@bgen(jjtree) AnnotationTypeBody */
6229   ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
6230   boolean jjtc000 = true;
6231   jjtree.openNodeScope(jjtn000);
6232     try {
6233       jj_consume_token(LBRACE);
6234       label_70:
6235       while (true) {
6236         switch (jj_nt.kind) {
6237         case ABSTRACT:
6238         case BOOLEAN:
6239         case BYTE:
6240         case CHAR:
6241         case CLASS:
6242         case _DEFAULT:
6243         case DOUBLE:
6244         case FINAL:
6245         case FLOAT:
6246         case INT:
6247         case INTERFACE:
6248         case LONG:
6249         case NATIVE:
6250         case PRIVATE:
6251         case PROTECTED:
6252         case PUBLIC:
6253         case SHORT:
6254         case STATIC:
6255         case SYNCHRONIZED:
6256         case TRANSIENT:
6257         case VOLATILE:
6258         case STRICTFP:
6259         case IDENTIFIER:
6260         case SEMICOLON:
6261         case AT:
6262           ;
6263           break;
6264         default:
6265           jj_la1[146] = jj_gen;
6266           break label_70;
6267         }
6268         AnnotationTypeMemberDeclaration();
6269       }
6270       jj_consume_token(RBRACE);
6271     } catch (Throwable jjte000) {
6272     if (jjtc000) {
6273       jjtree.clearNodeScope(jjtn000);
6274       jjtc000 = false;
6275     } else {
6276       jjtree.popNode();
6277     }
6278     if (jjte000 instanceof RuntimeException) {
6279       {if (true) throw (RuntimeException)jjte000;}
6280     }
6281     if (jjte000 instanceof ParseException) {
6282       {if (true) throw (ParseException)jjte000;}
6283     }
6284     {if (true) throw (Error)jjte000;}
6285     } finally {
6286     if (jjtc000) {
6287       jjtree.closeNodeScope(jjtn000, true);
6288     }
6289     }
6290   }
6291 
6292   final public void AnnotationTypeMemberDeclaration() throws ParseException {
6293  /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
6294    ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
6295    boolean jjtc000 = true;
6296    jjtree.openNodeScope(jjtn000);int modifiers;
6297     try {
6298       switch (jj_nt.kind) {
6299       case ABSTRACT:
6300       case BOOLEAN:
6301       case BYTE:
6302       case CHAR:
6303       case CLASS:
6304       case _DEFAULT:
6305       case DOUBLE:
6306       case FINAL:
6307       case FLOAT:
6308       case INT:
6309       case INTERFACE:
6310       case LONG:
6311       case NATIVE:
6312       case PRIVATE:
6313       case PROTECTED:
6314       case PUBLIC:
6315       case SHORT:
6316       case STATIC:
6317       case SYNCHRONIZED:
6318       case TRANSIENT:
6319       case VOLATILE:
6320       case STRICTFP:
6321       case IDENTIFIER:
6322       case AT:
6323         modifiers = Modifiers();
6324         if (jj_2_74(3)) {
6325           AnnotationMethodDeclaration(modifiers);
6326         } else {
6327           switch (jj_nt.kind) {
6328           case ABSTRACT:
6329           case CLASS:
6330           case FINAL:
6331           case INTERFACE:
6332             ClassOrInterfaceDeclaration(modifiers);
6333             break;
6334           default:
6335             jj_la1[147] = jj_gen;
6336             if (jj_2_75(3)) {
6337               EnumDeclaration(modifiers);
6338             } else {
6339               switch (jj_nt.kind) {
6340               case AT:
6341                 AnnotationTypeDeclaration(modifiers);
6342                 break;
6343               case BOOLEAN:
6344               case BYTE:
6345               case CHAR:
6346               case DOUBLE:
6347               case FLOAT:
6348               case INT:
6349               case LONG:
6350               case SHORT:
6351               case IDENTIFIER:
6352                 FieldDeclaration(modifiers);
6353                 break;
6354               default:
6355                 jj_la1[148] = jj_gen;
6356                 jj_consume_token(-1);
6357                 throw new ParseException();
6358               }
6359             }
6360           }
6361         }
6362         break;
6363       case SEMICOLON:
6364         jj_consume_token(SEMICOLON);
6365         break;
6366       default:
6367         jj_la1[149] = jj_gen;
6368         jj_consume_token(-1);
6369         throw new ParseException();
6370       }
6371     } catch (Throwable jjte000) {
6372    if (jjtc000) {
6373      jjtree.clearNodeScope(jjtn000);
6374      jjtc000 = false;
6375    } else {
6376      jjtree.popNode();
6377    }
6378    if (jjte000 instanceof RuntimeException) {
6379      {if (true) throw (RuntimeException)jjte000;}
6380    }
6381    if (jjte000 instanceof ParseException) {
6382      {if (true) throw (ParseException)jjte000;}
6383    }
6384    {if (true) throw (Error)jjte000;}
6385     } finally {
6386    if (jjtc000) {
6387      jjtree.closeNodeScope(jjtn000, true);
6388    }
6389     }
6390   }
6391 
6392   final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {
6393  /*@bgen(jjtree) AnnotationMethodDeclaration */
6394   ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);
6395   boolean jjtc000 = true;
6396   jjtree.openNodeScope(jjtn000);Token t;
6397   jjtn000.setModifiers(modifiers);
6398     try {
6399       Type();
6400       t = jj_consume_token(IDENTIFIER);
6401       jj_consume_token(LPAREN);
6402       jj_consume_token(RPAREN);
6403       switch (jj_nt.kind) {
6404       case _DEFAULT:
6405         DefaultValue();
6406         break;
6407       default:
6408         jj_la1[150] = jj_gen;
6409         ;
6410       }
6411       jj_consume_token(SEMICOLON);
6412     jjtree.closeNodeScope(jjtn000, true);
6413     jjtc000 = false;
6414     jjtn000.setImage(t.image);
6415     } catch (Throwable jjte000) {
6416     if (jjtc000) {
6417       jjtree.clearNodeScope(jjtn000);
6418       jjtc000 = false;
6419     } else {
6420       jjtree.popNode();
6421     }
6422     if (jjte000 instanceof RuntimeException) {
6423       {if (true) throw (RuntimeException)jjte000;}
6424     }
6425     if (jjte000 instanceof ParseException) {
6426       {if (true) throw (ParseException)jjte000;}
6427     }
6428     {if (true) throw (Error)jjte000;}
6429     } finally {
6430     if (jjtc000) {
6431       jjtree.closeNodeScope(jjtn000, true);
6432     }
6433     }
6434   }
6435 
6436   final public void DefaultValue() throws ParseException {
6437  /*@bgen(jjtree) DefaultValue */
6438   ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
6439   boolean jjtc000 = true;
6440   jjtree.openNodeScope(jjtn000);
6441     try {
6442       jj_consume_token(_DEFAULT);
6443       MemberValue();
6444     } catch (Throwable jjte000) {
6445     if (jjtc000) {
6446       jjtree.clearNodeScope(jjtn000);
6447       jjtc000 = false;
6448     } else {
6449       jjtree.popNode();
6450     }
6451     if (jjte000 instanceof RuntimeException) {
6452       {if (true) throw (RuntimeException)jjte000;}
6453     }
6454     if (jjte000 instanceof ParseException) {
6455       {if (true) throw (ParseException)jjte000;}
6456     }
6457     {if (true) throw (Error)jjte000;}
6458     } finally {
6459     if (jjtc000) {
6460       jjtree.closeNodeScope(jjtn000, true);
6461     }
6462     }
6463   }
6464 
6465   private boolean jj_2_1(int xla) {
6466     jj_la = xla; jj_lastpos = jj_scanpos = token;
6467     try { return !jj_3_1(); }
6468     catch(LookaheadSuccess ls) { return true; }
6469     finally { jj_save(0, xla); }
6470   }
6471 
6472   private boolean jj_2_2(int xla) {
6473     jj_la = xla; jj_lastpos = jj_scanpos = token;
6474     try { return !jj_3_2(); }
6475     catch(LookaheadSuccess ls) { return true; }
6476     finally { jj_save(1, xla); }
6477   }
6478 
6479   private boolean jj_2_3(int xla) {
6480     jj_la = xla; jj_lastpos = jj_scanpos = token;
6481     try { return !jj_3_3(); }
6482     catch(LookaheadSuccess ls) { return true; }
6483     finally { jj_save(2, xla); }
6484   }
6485 
6486   private boolean jj_2_4(int xla) {
6487     jj_la = xla; jj_lastpos = jj_scanpos = token;
6488     try { return !jj_3_4(); }
6489     catch(LookaheadSuccess ls) { return true; }
6490     finally { jj_save(3, xla); }
6491   }
6492 
6493   private boolean jj_2_5(int xla) {
6494     jj_la = xla; jj_lastpos = jj_scanpos = token;
6495     try { return !jj_3_5(); }
6496     catch(LookaheadSuccess ls) { return true; }
6497     finally { jj_save(4, xla); }
6498   }
6499 
6500   private boolean jj_2_6(int xla) {
6501     jj_la = xla; jj_lastpos = jj_scanpos = token;
6502     try { return !jj_3_6(); }
6503     catch(LookaheadSuccess ls) { return true; }
6504     finally { jj_save(5, xla); }
6505   }
6506 
6507   private boolean jj_2_7(int xla) {
6508     jj_la = xla; jj_lastpos = jj_scanpos = token;
6509     try { return !jj_3_7(); }
6510     catch(LookaheadSuccess ls) { return true; }
6511     finally { jj_save(6, xla); }
6512   }
6513 
6514   private boolean jj_2_8(int xla) {
6515     jj_la = xla; jj_lastpos = jj_scanpos = token;
6516     try { return !jj_3_8(); }
6517     catch(LookaheadSuccess ls) { return true; }
6518     finally { jj_save(7, xla); }
6519   }
6520 
6521   private boolean jj_2_9(int xla) {
6522     jj_la = xla; jj_lastpos = jj_scanpos = token;
6523     try { return !jj_3_9(); }
6524     catch(LookaheadSuccess ls) { return true; }
6525     finally { jj_save(8, xla); }
6526   }
6527 
6528   private boolean jj_2_10(int xla) {
6529     jj_la = xla; jj_lastpos = jj_scanpos = token;
6530     try { return !jj_3_10(); }
6531     catch(LookaheadSuccess ls) { return true; }
6532     finally { jj_save(9, xla); }
6533   }
6534 
6535   private boolean jj_2_11(int xla) {
6536     jj_la = xla; jj_lastpos = jj_scanpos = token;
6537     try { return !jj_3_11(); }
6538     catch(LookaheadSuccess ls) { return true; }
6539     finally { jj_save(10, xla); }
6540   }
6541 
6542   private boolean jj_2_12(int xla) {
6543     jj_la = xla; jj_lastpos = jj_scanpos = token;
6544     try { return !jj_3_12(); }
6545     catch(LookaheadSuccess ls) { return true; }
6546     finally { jj_save(11, xla); }
6547   }
6548 
6549   private boolean jj_2_13(int xla) {
6550     jj_la = xla; jj_lastpos = jj_scanpos = token;
6551     try { return !jj_3_13(); }
6552     catch(LookaheadSuccess ls) { return true; }
6553     finally { jj_save(12, xla); }
6554   }
6555 
6556   private boolean jj_2_14(int xla) {
6557     jj_la = xla; jj_lastpos = jj_scanpos = token;
6558     try { return !jj_3_14(); }
6559     catch(LookaheadSuccess ls) { return true; }
6560     finally { jj_save(13, xla); }
6561   }
6562 
6563   private boolean jj_2_15(int xla) {
6564     jj_la = xla; jj_lastpos = jj_scanpos = token;
6565     try { return !jj_3_15(); }
6566     catch(LookaheadSuccess ls) { return true; }
6567     finally { jj_save(14, xla); }
6568   }
6569 
6570   private boolean jj_2_16(int xla) {
6571     jj_la = xla; jj_lastpos = jj_scanpos = token;
6572     try { return !jj_3_16(); }
6573     catch(LookaheadSuccess ls) { return true; }
6574     finally { jj_save(15, xla); }
6575   }
6576 
6577   private boolean jj_2_17(int xla) {
6578     jj_la = xla; jj_lastpos = jj_scanpos = token;
6579     try { return !jj_3_17(); }
6580     catch(LookaheadSuccess ls) { return true; }
6581     finally { jj_save(16, xla); }
6582   }
6583 
6584   private boolean jj_2_18(int xla) {
6585     jj_la = xla; jj_lastpos = jj_scanpos = token;
6586     try { return !jj_3_18(); }
6587     catch(LookaheadSuccess ls) { return true; }
6588     finally { jj_save(17, xla); }
6589   }
6590 
6591   private boolean jj_2_19(int xla) {
6592     jj_la = xla; jj_lastpos = jj_scanpos = token;
6593     try { return !jj_3_19(); }
6594     catch(LookaheadSuccess ls) { return true; }
6595     finally { jj_save(18, xla); }
6596   }
6597 
6598   private boolean jj_2_20(int xla) {
6599     jj_la = xla; jj_lastpos = jj_scanpos = token;
6600     try { return !jj_3_20(); }
6601     catch(LookaheadSuccess ls) { return true; }
6602     finally { jj_save(19, xla); }
6603   }
6604 
6605   private boolean jj_2_21(int xla) {
6606     jj_la = xla; jj_lastpos = jj_scanpos = token;
6607     try { return !jj_3_21(); }
6608     catch(LookaheadSuccess ls) { return true; }
6609     finally { jj_save(20, xla); }
6610   }
6611 
6612   private boolean jj_2_22(int xla) {
6613     jj_la = xla; jj_lastpos = jj_scanpos = token;
6614     try { return !jj_3_22(); }
6615     catch(LookaheadSuccess ls) { return true; }
6616     finally { jj_save(21, xla); }
6617   }
6618 
6619   private boolean jj_2_23(int xla) {
6620     jj_la = xla; jj_lastpos = jj_scanpos = token;
6621     try { return !jj_3_23(); }
6622     catch(LookaheadSuccess ls) { return true; }
6623     finally { jj_save(22, xla); }
6624   }
6625 
6626   private boolean jj_2_24(int xla) {
6627     jj_la = xla; jj_lastpos = jj_scanpos = token;
6628     try { return !jj_3_24(); }
6629     catch(LookaheadSuccess ls) { return true; }
6630     finally { jj_save(23, xla); }
6631   }
6632 
6633   private boolean jj_2_25(int xla) {
6634     jj_la = xla; jj_lastpos = jj_scanpos = token;
6635     try { return !jj_3_25(); }
6636     catch(LookaheadSuccess ls) { return true; }
6637     finally { jj_save(24, xla); }
6638   }
6639 
6640   private boolean jj_2_26(int xla) {
6641     jj_la = xla; jj_lastpos = jj_scanpos = token;
6642     try { return !jj_3_26(); }
6643     catch(LookaheadSuccess ls) { return true; }
6644     finally { jj_save(25, xla); }
6645   }
6646 
6647   private boolean jj_2_27(int xla) {
6648     jj_la = xla; jj_lastpos = jj_scanpos = token;
6649     try { return !jj_3_27(); }
6650     catch(LookaheadSuccess ls) { return true; }
6651     finally { jj_save(26, xla); }
6652   }
6653 
6654   private boolean jj_2_28(int xla) {
6655     jj_la = xla; jj_lastpos = jj_scanpos = token;
6656     try { return !jj_3_28(); }
6657     catch(LookaheadSuccess ls) { return true; }
6658     finally { jj_save(27, xla); }
6659   }
6660 
6661   private boolean jj_2_29(int xla) {
6662     jj_la = xla; jj_lastpos = jj_scanpos = token;
6663     try { return !jj_3_29(); }
6664     catch(LookaheadSuccess ls) { return true; }
6665     finally { jj_save(28, xla); }
6666   }
6667 
6668   private boolean jj_2_30(int xla) {
6669     jj_la = xla; jj_lastpos = jj_scanpos = token;
6670     try { return !jj_3_30(); }
6671     catch(LookaheadSuccess ls) { return true; }
6672     finally { jj_save(29, xla); }
6673   }
6674 
6675   private boolean jj_2_31(int xla) {
6676     jj_la = xla; jj_lastpos = jj_scanpos = token;
6677     try { return !jj_3_31(); }
6678     catch(LookaheadSuccess ls) { return true; }
6679     finally { jj_save(30, xla); }
6680   }
6681 
6682   private boolean jj_2_32(int xla) {
6683     jj_la = xla; jj_lastpos = jj_scanpos = token;
6684     try { return !jj_3_32(); }
6685     catch(LookaheadSuccess ls) { return true; }
6686     finally { jj_save(31, xla); }
6687   }
6688 
6689   private boolean jj_2_33(int xla) {
6690     jj_la = xla; jj_lastpos = jj_scanpos = token;
6691     try { return !jj_3_33(); }
6692     catch(LookaheadSuccess ls) { return true; }
6693     finally { jj_save(32, xla); }
6694   }
6695 
6696   private boolean jj_2_34(int xla) {
6697     jj_la = xla; jj_lastpos = jj_scanpos = token;
6698     try { return !jj_3_34(); }
6699     catch(LookaheadSuccess ls) { return true; }
6700     finally { jj_save(33, xla); }
6701   }
6702 
6703   private boolean jj_2_35(int xla) {
6704     jj_la = xla; jj_lastpos = jj_scanpos = token;
6705     try { return !jj_3_35(); }
6706     catch(LookaheadSuccess ls) { return true; }
6707     finally { jj_save(34, xla); }
6708   }
6709 
6710   private boolean jj_2_36(int xla) {
6711     jj_la = xla; jj_lastpos = jj_scanpos = token;
6712     try { return !jj_3_36(); }
6713     catch(LookaheadSuccess ls) { return true; }
6714     finally { jj_save(35, xla); }
6715   }
6716 
6717   private boolean jj_2_37(int xla) {
6718     jj_la = xla; jj_lastpos = jj_scanpos = token;
6719     try { return !jj_3_37(); }
6720     catch(LookaheadSuccess ls) { return true; }
6721     finally { jj_save(36, xla); }
6722   }
6723 
6724   private boolean jj_2_38(int xla) {
6725     jj_la = xla; jj_lastpos = jj_scanpos = token;
6726     try { return !jj_3_38(); }
6727     catch(LookaheadSuccess ls) { return true; }
6728     finally { jj_save(37, xla); }
6729   }
6730 
6731   private boolean jj_2_39(int xla) {
6732     jj_la = xla; jj_lastpos = jj_scanpos = token;
6733     try { return !jj_3_39(); }
6734     catch(LookaheadSuccess ls) { return true; }
6735     finally { jj_save(38, xla); }
6736   }
6737 
6738   private boolean jj_2_40(int xla) {
6739     jj_la = xla; jj_lastpos = jj_scanpos = token;
6740     try { return !jj_3_40(); }
6741     catch(LookaheadSuccess ls) { return true; }
6742     finally { jj_save(39, xla); }
6743   }
6744 
6745   private boolean jj_2_41(int xla) {
6746     jj_la = xla; jj_lastpos = jj_scanpos = token;
6747     try { return !jj_3_41(); }
6748     catch(LookaheadSuccess ls) { return true; }
6749     finally { jj_save(40, xla); }
6750   }
6751 
6752   private boolean jj_2_42(int xla) {
6753     jj_la = xla; jj_lastpos = jj_scanpos = token;
6754     try { return !jj_3_42(); }
6755     catch(LookaheadSuccess ls) { return true; }
6756     finally { jj_save(41, xla); }
6757   }
6758 
6759   private boolean jj_2_43(int xla) {
6760     jj_la = xla; jj_lastpos = jj_scanpos = token;
6761     try { return !jj_3_43(); }
6762     catch(LookaheadSuccess ls) { return true; }
6763     finally { jj_save(42, xla); }
6764   }
6765 
6766   private boolean jj_2_44(int xla) {
6767     jj_la = xla; jj_lastpos = jj_scanpos = token;
6768     try { return !jj_3_44(); }
6769     catch(LookaheadSuccess ls) { return true; }
6770     finally { jj_save(43, xla); }
6771   }
6772 
6773   private boolean jj_2_45(int xla) {
6774     jj_la = xla; jj_lastpos = jj_scanpos = token;
6775     try { return !jj_3_45(); }
6776     catch(LookaheadSuccess ls) { return true; }
6777     finally { jj_save(44, xla); }
6778   }
6779 
6780   private boolean jj_2_46(int xla) {
6781     jj_la = xla; jj_lastpos = jj_scanpos = token;
6782     try { return !jj_3_46(); }
6783     catch(LookaheadSuccess ls) { return true; }
6784     finally { jj_save(45, xla); }
6785   }
6786 
6787   private boolean jj_2_47(int xla) {
6788     jj_la = xla; jj_lastpos = jj_scanpos = token;
6789     try { return !jj_3_47(); }
6790     catch(LookaheadSuccess ls) { return true; }
6791     finally { jj_save(46, xla); }
6792   }
6793 
6794   private boolean jj_2_48(int xla) {
6795     jj_la = xla; jj_lastpos = jj_scanpos = token;
6796     try { return !jj_3_48(); }
6797     catch(LookaheadSuccess ls) { return true; }
6798     finally { jj_save(47, xla); }
6799   }
6800 
6801   private boolean jj_2_49(int xla) {
6802     jj_la = xla; jj_lastpos = jj_scanpos = token;
6803     try { return !jj_3_49(); }
6804     catch(LookaheadSuccess ls) { return true; }
6805     finally { jj_save(48, xla); }
6806   }
6807 
6808   private boolean jj_2_50(int xla) {
6809     jj_la = xla; jj_lastpos = jj_scanpos = token;
6810     try { return !jj_3_50(); }
6811     catch(LookaheadSuccess ls) { return true; }
6812     finally { jj_save(49, xla); }
6813   }
6814 
6815   private boolean jj_2_51(int xla) {
6816     jj_la = xla; jj_lastpos = jj_scanpos = token;
6817     try { return !jj_3_51(); }
6818     catch(LookaheadSuccess ls) { return true; }
6819     finally { jj_save(50, xla); }
6820   }
6821 
6822   private boolean jj_2_52(int xla) {
6823     jj_la = xla; jj_lastpos = jj_scanpos = token;
6824     try { return !jj_3_52(); }
6825     catch(LookaheadSuccess ls) { return true; }
6826     finally { jj_save(51, xla); }
6827   }
6828 
6829   private boolean jj_2_53(int xla) {
6830     jj_la = xla; jj_lastpos = jj_scanpos = token;
6831     try { return !jj_3_53(); }
6832     catch(LookaheadSuccess ls) { return true; }
6833     finally { jj_save(52, xla); }
6834   }
6835 
6836   private boolean jj_2_54(int xla) {
6837     jj_la = xla; jj_lastpos = jj_scanpos = token;
6838     try { return !jj_3_54(); }
6839     catch(LookaheadSuccess ls) { return true; }
6840     finally { jj_save(53, xla); }
6841   }
6842 
6843   private boolean jj_2_55(int xla) {
6844     jj_la = xla; jj_lastpos = jj_scanpos = token;
6845     try { return !jj_3_55(); }
6846     catch(LookaheadSuccess ls) { return true; }
6847     finally { jj_save(54, xla); }
6848   }
6849 
6850   private boolean jj_2_56(int xla) {
6851     jj_la = xla; jj_lastpos = jj_scanpos = token;
6852     try { return !jj_3_56(); }
6853     catch(LookaheadSuccess ls) { return true; }
6854     finally { jj_save(55, xla); }
6855   }
6856 
6857   private boolean jj_2_57(int xla) {
6858     jj_la = xla; jj_lastpos = jj_scanpos = token;
6859     try { return !jj_3_57(); }
6860     catch(LookaheadSuccess ls) { return true; }
6861     finally { jj_save(56, xla); }
6862   }
6863 
6864   private boolean jj_2_58(int xla) {
6865     jj_la = xla; jj_lastpos = jj_scanpos = token;
6866     try { return !jj_3_58(); }
6867     catch(LookaheadSuccess ls) { return true; }
6868     finally { jj_save(57, xla); }
6869   }
6870 
6871   private boolean jj_2_59(int xla) {
6872     jj_la = xla; jj_lastpos = jj_scanpos = token;
6873     try { return !jj_3_59(); }
6874     catch(LookaheadSuccess ls) { return true; }
6875     finally { jj_save(58, xla); }
6876   }
6877 
6878   private boolean jj_2_60(int xla) {
6879     jj_la = xla; jj_lastpos = jj_scanpos = token;
6880     try { return !jj_3_60(); }
6881     catch(LookaheadSuccess ls) { return true; }
6882     finally { jj_save(59, xla); }
6883   }
6884 
6885   private boolean jj_2_61(int xla) {
6886     jj_la = xla; jj_lastpos = jj_scanpos = token;
6887     try { return !jj_3_61(); }
6888     catch(LookaheadSuccess ls) { return true; }
6889     finally { jj_save(60, xla); }
6890   }
6891 
6892   private boolean jj_2_62(int xla) {
6893     jj_la = xla; jj_lastpos = jj_scanpos = token;
6894     try { return !jj_3_62(); }
6895     catch(LookaheadSuccess ls) { return true; }
6896     finally { jj_save(61, xla); }
6897   }
6898 
6899   private boolean jj_2_63(int xla) {
6900     jj_la = xla; jj_lastpos = jj_scanpos = token;
6901     try { return !jj_3_63(); }
6902     catch(LookaheadSuccess ls) { return true; }
6903     finally { jj_save(62, xla); }
6904   }
6905 
6906   private boolean jj_2_64(int xla) {
6907     jj_la = xla; jj_lastpos = jj_scanpos = token;
6908     try { return !jj_3_64(); }
6909     catch(LookaheadSuccess ls) { return true; }
6910     finally { jj_save(63, xla); }
6911   }
6912 
6913   private boolean jj_2_65(int xla) {
6914     jj_la = xla; jj_lastpos = jj_scanpos = token;
6915     try { return !jj_3_65(); }
6916     catch(LookaheadSuccess ls) { return true; }
6917     finally { jj_save(64, xla); }
6918   }
6919 
6920   private boolean jj_2_66(int xla) {
6921     jj_la = xla; jj_lastpos = jj_scanpos = token;
6922     try { return !jj_3_66(); }
6923     catch(LookaheadSuccess ls) { return true; }
6924     finally { jj_save(65, xla); }
6925   }
6926 
6927   private boolean jj_2_67(int xla) {
6928     jj_la = xla; jj_lastpos = jj_scanpos = token;
6929     try { return !jj_3_67(); }
6930     catch(LookaheadSuccess ls) { return true; }
6931     finally { jj_save(66, xla); }
6932   }
6933 
6934   private boolean jj_2_68(int xla) {
6935     jj_la = xla; jj_lastpos = jj_scanpos = token;
6936     try { return !jj_3_68(); }
6937     catch(LookaheadSuccess ls) { return true; }
6938     finally { jj_save(67, xla); }
6939   }
6940 
6941   private boolean jj_2_69(int xla) {
6942     jj_la = xla; jj_lastpos = jj_scanpos = token;
6943     try { return !jj_3_69(); }
6944     catch(LookaheadSuccess ls) { return true; }
6945     finally { jj_save(68, xla); }
6946   }
6947 
6948   private boolean jj_2_70(int xla) {
6949     jj_la = xla; jj_lastpos = jj_scanpos = token;
6950     try { return !jj_3_70(); }
6951     catch(LookaheadSuccess ls) { return true; }
6952     finally { jj_save(69, xla); }
6953   }
6954 
6955   private boolean jj_2_71(int xla) {
6956     jj_la = xla; jj_lastpos = jj_scanpos = token;
6957     try { return !jj_3_71(); }
6958     catch(LookaheadSuccess ls) { return true; }
6959     finally { jj_save(70, xla); }
6960   }
6961 
6962   private boolean jj_2_72(int xla) {
6963     jj_la = xla; jj_lastpos = jj_scanpos = token;
6964     try { return !jj_3_72(); }
6965     catch(LookaheadSuccess ls) { return true; }
6966     finally { jj_save(71, xla); }
6967   }
6968 
6969   private boolean jj_2_73(int xla) {
6970     jj_la = xla; jj_lastpos = jj_scanpos = token;
6971     try { return !jj_3_73(); }
6972     catch(LookaheadSuccess ls) { return true; }
6973     finally { jj_save(72, xla); }
6974   }
6975 
6976   private boolean jj_2_74(int xla) {
6977     jj_la = xla; jj_lastpos = jj_scanpos = token;
6978     try { return !jj_3_74(); }
6979     catch(LookaheadSuccess ls) { return true; }
6980     finally { jj_save(73, xla); }
6981   }
6982 
6983   private boolean jj_2_75(int xla) {
6984     jj_la = xla; jj_lastpos = jj_scanpos = token;
6985     try { return !jj_3_75(); }
6986     catch(LookaheadSuccess ls) { return true; }
6987     finally { jj_save(74, xla); }
6988   }
6989 
6990   private boolean jj_3R_219() {
6991     if (jj_scan_token(BYTE)) return true;
6992     return false;
6993   }
6994 
6995   private boolean jj_3R_218() {
6996     if (jj_scan_token(CHAR)) return true;
6997     return false;
6998   }
6999 
7000   private boolean jj_3R_142() {
7001     Token xsp;
7002     xsp = jj_scanpos;
7003     if (jj_3R_217()) {
7004     jj_scanpos = xsp;
7005     if (jj_3R_218()) {
7006     jj_scanpos = xsp;
7007     if (jj_3R_219()) {
7008     jj_scanpos = xsp;
7009     if (jj_3R_220()) {
7010     jj_scanpos = xsp;
7011     if (jj_3R_221()) {
7012     jj_scanpos = xsp;
7013     if (jj_3R_222()) {
7014     jj_scanpos = xsp;
7015     if (jj_3R_223()) {
7016     jj_scanpos = xsp;
7017     if (jj_3R_224()) return true;
7018     }
7019     }
7020     }
7021     }
7022     }
7023     }
7024     }
7025     return false;
7026   }
7027 
7028   private boolean jj_3R_217() {
7029     if (jj_scan_token(BOOLEAN)) return true;
7030     return false;
7031   }
7032 
7033   private boolean jj_3R_259() {
7034     if (jj_3R_97()) return true;
7035     return false;
7036   }
7037 
7038   private boolean jj_3R_360() {
7039     if (jj_scan_token(SUPER)) return true;
7040     Token xsp;
7041     while (true) {
7042       xsp = jj_scanpos;
7043       if (jj_3R_366()) { jj_scanpos = xsp; break; }
7044     }
7045     if (jj_3R_98()) return true;
7046     return false;
7047   }
7048 
7049   private boolean jj_3R_359() {
7050     if (jj_scan_token(EXTENDS)) return true;
7051     Token xsp;
7052     while (true) {
7053       xsp = jj_scanpos;
7054       if (jj_3R_365()) { jj_scanpos = xsp; break; }
7055     }
7056     if (jj_3R_98()) return true;
7057     return false;
7058   }
7059 
7060   private boolean jj_3R_353() {
7061     Token xsp;
7062     xsp = jj_scanpos;
7063     if (jj_3R_359()) {
7064     jj_scanpos = xsp;
7065     if (jj_3R_360()) return true;
7066     }
7067     return false;
7068   }
7069 
7070   private boolean jj_3R_341() {
7071     if (jj_3R_353()) return true;
7072     return false;
7073   }
7074 
7075   private boolean jj_3_17() {
7076     if (jj_scan_token(LBRACKET)) return true;
7077     if (jj_scan_token(RBRACKET)) return true;
7078     return false;
7079   }
7080 
7081   private boolean jj_3R_179() {
7082     if (jj_scan_token(HOOK)) return true;
7083     Token xsp;
7084     xsp = jj_scanpos;
7085     if (jj_3R_341()) jj_scanpos = xsp;
7086     return false;
7087   }
7088 
7089   private boolean jj_3R_442() {
7090     if (jj_3R_443()) return true;
7091     return false;
7092   }
7093 
7094   private boolean jj_3R_277() {
7095     if (jj_3R_154()) return true;
7096     return false;
7097   }
7098 
7099   private boolean jj_3R_99() {
7100     Token xsp;
7101     xsp = jj_scanpos;
7102     if (jj_3R_178()) {
7103     jj_scanpos = xsp;
7104     if (jj_3R_179()) return true;
7105     }
7106     return false;
7107   }
7108 
7109   private boolean jj_3R_178() {
7110     Token xsp;
7111     while (true) {
7112       xsp = jj_scanpos;
7113       if (jj_3R_277()) { jj_scanpos = xsp; break; }
7114     }
7115     if (jj_3R_98()) return true;
7116     return false;
7117   }
7118 
7119   private boolean jj_3R_175() {
7120     if (jj_scan_token(LT)) return true;
7121     if (jj_scan_token(GT)) return true;
7122     return false;
7123   }
7124 
7125   private boolean jj_3R_97() {
7126     Token xsp;
7127     xsp = jj_scanpos;
7128     if (jj_3_21()) {
7129     jj_scanpos = xsp;
7130     if (jj_3R_175()) return true;
7131     }
7132     return false;
7133   }
7134 
7135   private boolean jj_3_21() {
7136     if (jj_scan_token(LT)) return true;
7137     if (jj_3R_99()) return true;
7138     Token xsp;
7139     while (true) {
7140       xsp = jj_scanpos;
7141       if (jj_3R_275()) { jj_scanpos = xsp; break; }
7142     }
7143     if (jj_scan_token(GT)) return true;
7144     return false;
7145   }
7146 
7147   private boolean jj_3_16() {
7148     if (jj_scan_token(LBRACKET)) return true;
7149     if (jj_scan_token(RBRACKET)) return true;
7150     return false;
7151   }
7152 
7153   private boolean jj_3_19() {
7154     if (jj_scan_token(DOT)) return true;
7155     if (jj_scan_token(IDENTIFIER)) return true;
7156     Token xsp;
7157     xsp = jj_scanpos;
7158     if (jj_3_20()) jj_scanpos = xsp;
7159     return false;
7160   }
7161 
7162   private boolean jj_3_18() {
7163     if (jj_3R_97()) return true;
7164     return false;
7165   }
7166 
7167   private boolean jj_3R_276() {
7168     if (jj_scan_token(IDENTIFIER)) return true;
7169     Token xsp;
7170     xsp = jj_scanpos;
7171     if (jj_3_18()) jj_scanpos = xsp;
7172     while (true) {
7173       xsp = jj_scanpos;
7174       if (jj_3_19()) { jj_scanpos = xsp; break; }
7175     }
7176     return false;
7177   }
7178 
7179   private boolean jj_3R_443() {
7180     if (jj_scan_token(_DEFAULT)) return true;
7181     if (jj_3R_152()) return true;
7182     return false;
7183   }
7184 
7185   private boolean jj_3R_177() {
7186     if (jj_3R_276()) return true;
7187     Token xsp;
7188     while (true) {
7189       xsp = jj_scanpos;
7190       if (jj_3_17()) { jj_scanpos = xsp; break; }
7191     }
7192     return false;
7193   }
7194 
7195   private boolean jj_3R_98() {
7196     Token xsp;
7197     xsp = jj_scanpos;
7198     if (jj_3R_176()) {
7199     jj_scanpos = xsp;
7200     if (jj_3R_177()) return true;
7201     }
7202     return false;
7203   }
7204 
7205   private boolean jj_3R_176() {
7206     if (jj_3R_142()) return true;
7207     Token xsp;
7208     if (jj_3_16()) return true;
7209     while (true) {
7210       xsp = jj_scanpos;
7211       if (jj_3_16()) { jj_scanpos = xsp; break; }
7212     }
7213     return false;
7214   }
7215 
7216   private boolean jj_3R_153() {
7217     if (jj_3R_90()) return true;
7218     if (jj_scan_token(IDENTIFIER)) return true;
7219     if (jj_scan_token(LPAREN)) return true;
7220     if (jj_scan_token(RPAREN)) return true;
7221     Token xsp;
7222     xsp = jj_scanpos;
7223     if (jj_3R_442()) jj_scanpos = xsp;
7224     if (jj_scan_token(SEMICOLON)) return true;
7225     return false;
7226   }
7227 
7228   private boolean jj_3R_413() {
7229     if (jj_scan_token(THROWS)) return true;
7230     if (jj_3R_426()) return true;
7231     return false;
7232   }
7233 
7234   private boolean jj_3R_164() {
7235     if (jj_3R_142()) return true;
7236     return false;
7237   }
7238 
7239   private boolean jj_3R_90() {
7240     Token xsp;
7241     xsp = jj_scanpos;
7242     if (jj_3_15()) {
7243     jj_scanpos = xsp;
7244     if (jj_3R_164()) return true;
7245     }
7246     return false;
7247   }
7248 
7249   private boolean jj_3_15() {
7250     if (jj_3R_98()) return true;
7251     return false;
7252   }
7253 
7254   private boolean jj_3R_289() {
7255     if (jj_3R_154()) return true;
7256     return false;
7257   }
7258 
7259   private boolean jj_3_12() {
7260     if (jj_3R_95()) return true;
7261     if (jj_scan_token(DOT)) return true;
7262     return false;
7263   }
7264 
7265   private boolean jj_3R_441() {
7266     if (jj_3R_404()) return true;
7267     return false;
7268   }
7269 
7270   private boolean jj_3R_440() {
7271     if (jj_3R_406()) return true;
7272     return false;
7273   }
7274 
7275   private boolean jj_3R_402() {
7276     if (jj_scan_token(STATIC)) return true;
7277     return false;
7278   }
7279 
7280   private boolean jj_3_14() {
7281     if (jj_3R_97()) return true;
7282     if (jj_scan_token(THIS)) return true;
7283     if (jj_3R_96()) return true;
7284     if (jj_scan_token(SEMICOLON)) return true;
7285     return false;
7286   }
7287 
7288   private boolean jj_3_75() {
7289     if (jj_3R_88()) return true;
7290     return false;
7291   }
7292 
7293   private boolean jj_3R_386() {
7294     Token xsp;
7295     xsp = jj_scanpos;
7296     if (jj_3R_402()) jj_scanpos = xsp;
7297     if (jj_3R_297()) return true;
7298     return false;
7299   }
7300 
7301   private boolean jj_3_13() {
7302     if (jj_scan_token(THIS)) return true;
7303     if (jj_3R_96()) return true;
7304     if (jj_scan_token(SEMICOLON)) return true;
7305     return false;
7306   }
7307 
7308   private boolean jj_3R_439() {
7309     if (jj_3R_87()) return true;
7310     return false;
7311   }
7312 
7313   private boolean jj_3_74() {
7314     if (jj_3R_153()) return true;
7315     return false;
7316   }
7317 
7318   private boolean jj_3_10() {
7319     if (jj_3R_93()) return true;
7320     return false;
7321   }
7322 
7323   private boolean jj_3R_258() {
7324     if (jj_3R_95()) return true;
7325     if (jj_scan_token(DOT)) return true;
7326     return false;
7327   }
7328 
7329   private boolean jj_3R_169() {
7330     Token xsp;
7331     xsp = jj_scanpos;
7332     if (jj_3R_258()) jj_scanpos = xsp;
7333     xsp = jj_scanpos;
7334     if (jj_3R_259()) jj_scanpos = xsp;
7335     if (jj_scan_token(SUPER)) return true;
7336     if (jj_3R_96()) return true;
7337     if (jj_scan_token(SEMICOLON)) return true;
7338     return false;
7339   }
7340 
7341   private boolean jj_3R_438() {
7342     if (jj_3R_387()) return true;
7343     Token xsp;
7344     xsp = jj_scanpos;
7345     if (jj_3_74()) {
7346     jj_scanpos = xsp;
7347     if (jj_3R_439()) {
7348     jj_scanpos = xsp;
7349     if (jj_3_75()) {
7350     jj_scanpos = xsp;
7351     if (jj_3R_440()) {
7352     jj_scanpos = xsp;
7353     if (jj_3R_441()) return true;
7354     }
7355     }
7356     }
7357     }
7358     return false;
7359   }
7360 
7361   private boolean jj_3R_434() {
7362     Token xsp;
7363     xsp = jj_scanpos;
7364     if (jj_3R_438()) {
7365     jj_scanpos = xsp;
7366     if (jj_scan_token(82)) return true;
7367     }
7368     return false;
7369   }
7370 
7371   private boolean jj_3R_428() {
7372     if (jj_3R_434()) return true;
7373     return false;
7374   }
7375 
7376   private boolean jj_3R_168() {
7377     if (jj_3R_97()) return true;
7378     if (jj_scan_token(THIS)) return true;
7379     if (jj_3R_96()) return true;
7380     if (jj_scan_token(SEMICOLON)) return true;
7381     return false;
7382   }
7383 
7384   private boolean jj_3R_93() {
7385     Token xsp;
7386     xsp = jj_scanpos;
7387     if (jj_3R_167()) {
7388     jj_scanpos = xsp;
7389     if (jj_3R_168()) {
7390     jj_scanpos = xsp;
7391     if (jj_3R_169()) return true;
7392     }
7393     }
7394     return false;
7395   }
7396 
7397   private boolean jj_3R_167() {
7398     if (jj_scan_token(THIS)) return true;
7399     if (jj_3R_96()) return true;
7400     if (jj_scan_token(SEMICOLON)) return true;
7401     return false;
7402   }
7403 
7404   private boolean jj_3_73() {
7405     if (jj_scan_token(COMMA)) return true;
7406     if (jj_3R_152()) return true;
7407     return false;
7408   }
7409 
7410   private boolean jj_3R_345() {
7411     if (jj_scan_token(COMMA)) return true;
7412     if (jj_3R_132()) return true;
7413     return false;
7414   }
7415 
7416   private boolean jj_3_11() {
7417     if (jj_3R_94()) return true;
7418     return false;
7419   }
7420 
7421   private boolean jj_3R_420() {
7422     if (jj_scan_token(LBRACE)) return true;
7423     Token xsp;
7424     while (true) {
7425       xsp = jj_scanpos;
7426       if (jj_3R_428()) { jj_scanpos = xsp; break; }
7427     }
7428     if (jj_scan_token(RBRACE)) return true;
7429     return false;
7430   }
7431 
7432   private boolean jj_3R_414() {
7433     if (jj_3R_93()) return true;
7434     return false;
7435   }
7436 
7437   private boolean jj_3R_412() {
7438     if (jj_3R_163()) return true;
7439     return false;
7440   }
7441 
7442   private boolean jj_3R_403() {
7443     Token xsp;
7444     xsp = jj_scanpos;
7445     if (jj_3R_412()) jj_scanpos = xsp;
7446     if (jj_scan_token(IDENTIFIER)) return true;
7447     if (jj_3R_138()) return true;
7448     xsp = jj_scanpos;
7449     if (jj_3R_413()) jj_scanpos = xsp;
7450     if (jj_scan_token(LBRACE)) return true;
7451     xsp = jj_scanpos;
7452     if (jj_3R_414()) jj_scanpos = xsp;
7453     while (true) {
7454       xsp = jj_scanpos;
7455       if (jj_3_11()) { jj_scanpos = xsp; break; }
7456     }
7457     if (jj_scan_token(RBRACE)) return true;
7458     return false;
7459   }
7460 
7461   private boolean jj_3R_406() {
7462     if (jj_scan_token(AT)) return true;
7463     if (jj_scan_token(INTERFACE)) return true;
7464     if (jj_scan_token(IDENTIFIER)) return true;
7465     if (jj_3R_420()) return true;
7466     return false;
7467   }
7468 
7469   private boolean jj_3R_208() {
7470     if (jj_scan_token(BIT_OR)) return true;
7471     if (jj_3R_90()) return true;
7472     return false;
7473   }
7474 
7475   private boolean jj_3R_427() {
7476     if (jj_scan_token(LBRACKET)) return true;
7477     if (jj_scan_token(RBRACKET)) return true;
7478     return false;
7479   }
7480 
7481   private boolean jj_3R_418() {
7482     if (jj_scan_token(THROWS)) return true;
7483     if (jj_3R_426()) return true;
7484     return false;
7485   }
7486 
7487   private boolean jj_3R_209() {
7488     if (jj_scan_token(ELLIPSIS)) return true;
7489     return false;
7490   }
7491 
7492   private boolean jj_3R_364() {
7493     if (jj_3R_152()) return true;
7494     Token xsp;
7495     while (true) {
7496       xsp = jj_scanpos;
7497       if (jj_3_73()) { jj_scanpos = xsp; break; }
7498     }
7499     xsp = jj_scanpos;
7500     if (jj_scan_token(83)) jj_scanpos = xsp;
7501     return false;
7502   }
7503 
7504   private boolean jj_3R_288() {
7505     if (jj_scan_token(FINAL)) return true;
7506     return false;
7507   }
7508 
7509   private boolean jj_3R_207() {
7510     Token xsp;
7511     xsp = jj_scanpos;
7512     if (jj_3R_288()) {
7513     jj_scanpos = xsp;
7514     if (jj_3R_289()) return true;
7515     }
7516     return false;
7517   }
7518 
7519   private boolean jj_3R_132() {
7520     Token xsp;
7521     while (true) {
7522       xsp = jj_scanpos;
7523       if (jj_3R_207()) { jj_scanpos = xsp; break; }
7524     }
7525     if (jj_3R_90()) return true;
7526     while (true) {
7527       xsp = jj_scanpos;
7528       if (jj_3R_208()) { jj_scanpos = xsp; break; }
7529     }
7530     xsp = jj_scanpos;
7531     if (jj_3R_209()) jj_scanpos = xsp;
7532     if (jj_3R_130()) return true;
7533     return false;
7534   }
7535 
7536   private boolean jj_3R_315() {
7537     if (jj_scan_token(LBRACE)) return true;
7538     Token xsp;
7539     xsp = jj_scanpos;
7540     if (jj_3R_364()) jj_scanpos = xsp;
7541     if (jj_scan_token(RBRACE)) return true;
7542     return false;
7543   }
7544 
7545   private boolean jj_3R_214() {
7546     if (jj_3R_132()) return true;
7547     Token xsp;
7548     while (true) {
7549       xsp = jj_scanpos;
7550       if (jj_3R_345()) { jj_scanpos = xsp; break; }
7551     }
7552     return false;
7553   }
7554 
7555   private boolean jj_3R_356() {
7556     if (jj_scan_token(COMMA)) return true;
7557     if (jj_3R_355()) return true;
7558     return false;
7559   }
7560 
7561   private boolean jj_3_9() {
7562     if (jj_scan_token(COMMA)) return true;
7563     if (jj_3R_92()) 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_138() {
7573     if (jj_scan_token(LPAREN)) return true;
7574     Token xsp;
7575     xsp = jj_scanpos;
7576     if (jj_3R_214()) jj_scanpos = xsp;
7577     if (jj_scan_token(RPAREN)) return true;
7578     return false;
7579   }
7580 
7581   private boolean jj_3R_247() {
7582     if (jj_3R_315()) return true;
7583     return false;
7584   }
7585 
7586   private boolean jj_3R_152() {
7587     Token xsp;
7588     xsp = jj_scanpos;
7589     if (jj_3R_246()) {
7590     jj_scanpos = xsp;
7591     if (jj_3R_247()) {
7592     jj_scanpos = xsp;
7593     if (jj_3R_248()) return true;
7594     }
7595     }
7596     return false;
7597   }
7598 
7599   private boolean jj_3R_246() {
7600     if (jj_3R_154()) return true;
7601     return false;
7602   }
7603 
7604   private boolean jj_3R_355() {
7605     if (jj_scan_token(IDENTIFIER)) return true;
7606     if (jj_scan_token(ASSIGN)) return true;
7607     if (jj_3R_152()) return true;
7608     return false;
7609   }
7610 
7611   private boolean jj_3R_417() {
7612     if (jj_scan_token(IDENTIFIER)) return true;
7613     if (jj_3R_138()) return true;
7614     Token xsp;
7615     while (true) {
7616       xsp = jj_scanpos;
7617       if (jj_3R_427()) { jj_scanpos = xsp; break; }
7618     }
7619     return false;
7620   }
7621 
7622   private boolean jj_3R_346() {
7623     if (jj_3R_355()) return true;
7624     Token xsp;
7625     while (true) {
7626       xsp = jj_scanpos;
7627       if (jj_3R_356()) { jj_scanpos = xsp; break; }
7628     }
7629     return false;
7630   }
7631 
7632   private boolean jj_3R_330() {
7633     if (jj_3R_346()) return true;
7634     return false;
7635   }
7636 
7637   private boolean jj_3R_419() {
7638     if (jj_3R_297()) return true;
7639     return false;
7640   }
7641 
7642   private boolean jj_3R_151() {
7643     if (jj_scan_token(IDENTIFIER)) return true;
7644     if (jj_scan_token(ASSIGN)) return true;
7645     return false;
7646   }
7647 
7648   private boolean jj_3R_416() {
7649     if (jj_3R_163()) return true;
7650     return false;
7651   }
7652 
7653   private boolean jj_3R_405() {
7654     Token xsp;
7655     xsp = jj_scanpos;
7656     if (jj_3R_416()) jj_scanpos = xsp;
7657     if (jj_3R_135()) return true;
7658     if (jj_3R_417()) return true;
7659     xsp = jj_scanpos;
7660     if (jj_3R_418()) jj_scanpos = xsp;
7661     xsp = jj_scanpos;
7662     if (jj_3R_419()) {
7663     jj_scanpos = xsp;
7664     if (jj_scan_token(82)) return true;
7665     }
7666     return false;
7667   }
7668 
7669   private boolean jj_3R_363() {
7670     if (jj_3R_92()) return true;
7671     Token xsp;
7672     while (true) {
7673       xsp = jj_scanpos;
7674       if (jj_3_9()) { jj_scanpos = xsp; break; }
7675     }
7676     return false;
7677   }
7678 
7679   private boolean jj_3R_317() {
7680     if (jj_scan_token(AT)) return true;
7681     if (jj_3R_136()) return true;
7682     if (jj_scan_token(LPAREN)) return true;
7683     if (jj_3R_152()) return true;
7684     if (jj_scan_token(RPAREN)) return true;
7685     return false;
7686   }
7687 
7688   private boolean jj_3R_313() {
7689     if (jj_scan_token(ASSIGN)) return true;
7690     if (jj_3R_92()) return true;
7691     return false;
7692   }
7693 
7694   private boolean jj_3R_257() {
7695     if (jj_scan_token(LBRACE)) return true;
7696     Token xsp;
7697     xsp = jj_scanpos;
7698     if (jj_3R_363()) jj_scanpos = xsp;
7699     xsp = jj_scanpos;
7700     if (jj_scan_token(83)) jj_scanpos = xsp;
7701     if (jj_scan_token(RBRACE)) return true;
7702     return false;
7703   }
7704 
7705   private boolean jj_3R_415() {
7706     if (jj_scan_token(COMMA)) return true;
7707     if (jj_3R_243()) return true;
7708     return false;
7709   }
7710 
7711   private boolean jj_3R_318() {
7712     if (jj_scan_token(AT)) return true;
7713     if (jj_3R_136()) return true;
7714     return false;
7715   }
7716 
7717   private boolean jj_3_72() {
7718     if (jj_scan_token(AT)) return true;
7719     if (jj_3R_136()) return true;
7720     if (jj_scan_token(LPAREN)) return true;
7721     return false;
7722   }
7723 
7724   private boolean jj_3R_91() {
7725     if (jj_scan_token(LBRACKET)) return true;
7726     if (jj_scan_token(RBRACKET)) return true;
7727     return false;
7728   }
7729 
7730   private boolean jj_3R_316() {
7731     if (jj_scan_token(AT)) return true;
7732     if (jj_3R_136()) return true;
7733     if (jj_scan_token(LPAREN)) return true;
7734     Token xsp;
7735     xsp = jj_scanpos;
7736     if (jj_3R_330()) jj_scanpos = xsp;
7737     if (jj_scan_token(RPAREN)) return true;
7738     return false;
7739   }
7740 
7741   private boolean jj_3R_166() {
7742     if (jj_3R_101()) return true;
7743     return false;
7744   }
7745 
7746   private boolean jj_3R_92() {
7747     Token xsp;
7748     xsp = jj_scanpos;
7749     if (jj_3R_165()) {
7750     jj_scanpos = xsp;
7751     if (jj_3R_166()) return true;
7752     }
7753     return false;
7754   }
7755 
7756   private boolean jj_3R_165() {
7757     if (jj_3R_257()) return true;
7758     return false;
7759   }
7760 
7761   private boolean jj_3_71() {
7762     if (jj_scan_token(AT)) return true;
7763     if (jj_3R_136()) return true;
7764     if (jj_scan_token(LPAREN)) return true;
7765     Token xsp;
7766     xsp = jj_scanpos;
7767     if (jj_3R_151()) {
7768     jj_scanpos = xsp;
7769     if (jj_scan_token(77)) return true;
7770     }
7771     return false;
7772   }
7773 
7774   private boolean jj_3R_251() {
7775     if (jj_3R_318()) return true;
7776     return false;
7777   }
7778 
7779   private boolean jj_3R_250() {
7780     if (jj_3R_317()) return true;
7781     return false;
7782   }
7783 
7784   private boolean jj_3R_206() {
7785     if (jj_scan_token(LBRACKET)) return true;
7786     if (jj_scan_token(RBRACKET)) return true;
7787     return false;
7788   }
7789 
7790   private boolean jj_3R_436() {
7791     if (jj_3R_160()) return true;
7792     return false;
7793   }
7794 
7795   private boolean jj_3R_154() {
7796     Token xsp;
7797     xsp = jj_scanpos;
7798     if (jj_3R_249()) {
7799     jj_scanpos = xsp;
7800     if (jj_3R_250()) {
7801     jj_scanpos = xsp;
7802     if (jj_3R_251()) return true;
7803     }
7804     }
7805     return false;
7806   }
7807 
7808   private boolean jj_3R_194() {
7809     return false;
7810   }
7811 
7812   private boolean jj_3R_249() {
7813     if (jj_3R_316()) return true;
7814     return false;
7815   }
7816 
7817   private boolean jj_3R_320() {
7818     if (jj_3R_331()) return true;
7819     return false;
7820   }
7821 
7822   private boolean jj_3R_130() {
7823     if (jj_scan_token(IDENTIFIER)) return true;
7824     Token xsp;
7825     while (true) {
7826       xsp = jj_scanpos;
7827       if (jj_3R_206()) { jj_scanpos = xsp; break; }
7828     }
7829     return false;
7830   }
7831 
7832   private boolean jj_3R_256() {
7833     if (jj_scan_token(COMMA)) return true;
7834     if (jj_3R_255()) return true;
7835     return false;
7836   }
7837 
7838   private boolean jj_3R_368() {
7839     if (jj_scan_token(COLON)) return true;
7840     if (jj_3R_101()) return true;
7841     return false;
7842   }
7843 
7844   private boolean jj_3R_347() {
7845     if (jj_scan_token(BIT_AND)) return true;
7846     if (jj_3R_276()) return true;
7847     return false;
7848   }
7849 
7850   private boolean jj_3R_243() {
7851     if (jj_3R_130()) return true;
7852     Token xsp;
7853     xsp = jj_scanpos;
7854     if (jj_3R_313()) jj_scanpos = xsp;
7855     return false;
7856   }
7857 
7858   private boolean jj_3R_89() {
7859     if (jj_3R_163()) return true;
7860     return false;
7861   }
7862 
7863   private boolean jj_3_7() {
7864     if (jj_3R_90()) return true;
7865     if (jj_scan_token(IDENTIFIER)) return true;
7866     Token xsp;
7867     while (true) {
7868       xsp = jj_scanpos;
7869       if (jj_3R_91()) { jj_scanpos = xsp; break; }
7870     }
7871     xsp = jj_scanpos;
7872     if (jj_scan_token(83)) {
7873     jj_scanpos = xsp;
7874     if (jj_scan_token(86)) {
7875     jj_scanpos = xsp;
7876     if (jj_scan_token(82)) return true;
7877     }
7878     }
7879     return false;
7880   }
7881 
7882   private boolean jj_3R_195() {
7883     return false;
7884   }
7885 
7886   private boolean jj_3_6() {
7887     Token xsp;
7888     xsp = jj_scanpos;
7889     if (jj_3R_89()) jj_scanpos = xsp;
7890     if (jj_scan_token(IDENTIFIER)) return true;
7891     if (jj_scan_token(LPAREN)) return true;
7892     return false;
7893   }
7894 
7895   private boolean jj_3R_117() {
7896     jj_lookingAhead = true;
7897     jj_semLA = getToken(1).kind == GT &&
7898                 ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
7899     jj_lookingAhead = false;
7900     if (!jj_semLA || jj_3R_194()) return true;
7901     if (jj_scan_token(GT)) return true;
7902     if (jj_scan_token(GT)) return true;
7903     return false;
7904   }
7905 
7906   private boolean jj_3R_404() {
7907     if (jj_3R_90()) return true;
7908     if (jj_3R_243()) return true;
7909     Token xsp;
7910     while (true) {
7911       xsp = jj_scanpos;
7912       if (jj_3R_415()) { jj_scanpos = xsp; break; }
7913     }
7914     if (jj_scan_token(SEMICOLON)) return true;
7915     return false;
7916   }
7917 
7918   private boolean jj_3R_85() {
7919     if (jj_3R_154()) return true;
7920     return false;
7921   }
7922 
7923   private boolean jj_3R_435() {
7924     if (jj_3R_96()) return true;
7925     return false;
7926   }
7927 
7928   private boolean jj_3R_391() {
7929     if (jj_3R_406()) return true;
7930     return false;
7931   }
7932 
7933   private boolean jj_3R_156() {
7934     if (jj_scan_token(INTERFACE)) return true;
7935     return false;
7936   }
7937 
7938   private boolean jj_3R_390() {
7939     if (jj_3R_405()) return true;
7940     return false;
7941   }
7942 
7943   private boolean jj_3_8() {
7944     Token xsp;
7945     xsp = jj_scanpos;
7946     if (jj_scan_token(49)) jj_scanpos = xsp;
7947     if (jj_scan_token(LBRACE)) return true;
7948     return false;
7949   }
7950 
7951   private boolean jj_3R_389() {
7952     if (jj_3R_404()) return true;
7953     return false;
7954   }
7955 
7956   private boolean jj_3R_388() {
7957     if (jj_3R_403()) return true;
7958     return false;
7959   }
7960 
7961   private boolean jj_3R_118() {
7962     jj_lookingAhead = true;
7963     jj_semLA = getToken(1).kind == GT &&
7964                 ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
7965     jj_lookingAhead = false;
7966     if (!jj_semLA || jj_3R_195()) return true;
7967     if (jj_scan_token(GT)) return true;
7968     if (jj_scan_token(GT)) return true;
7969     if (jj_scan_token(GT)) return true;
7970     return false;
7971   }
7972 
7973   private boolean jj_3_5() {
7974     if (jj_3R_88()) return true;
7975     return false;
7976   }
7977 
7978   private boolean jj_3_4() {
7979     if (jj_3R_87()) return true;
7980     return false;
7981   }
7982 
7983   private boolean jj_3R_371() {
7984     if (jj_3R_387()) return true;
7985     Token xsp;
7986     xsp = jj_scanpos;
7987     if (jj_3_4()) {
7988     jj_scanpos = xsp;
7989     if (jj_3_5()) {
7990     jj_scanpos = xsp;
7991     if (jj_3R_388()) {
7992     jj_scanpos = xsp;
7993     if (jj_3R_389()) {
7994     jj_scanpos = xsp;
7995     if (jj_3R_390()) {
7996     jj_scanpos = xsp;
7997     if (jj_3R_391()) return true;
7998     }
7999     }
8000     }
8001     }
8002     }
8003     return false;
8004   }
8005 
8006   private boolean jj_3R_369() {
8007     Token xsp;
8008     xsp = jj_scanpos;
8009     if (jj_3R_370()) {
8010     jj_scanpos = xsp;
8011     if (jj_3R_371()) {
8012     jj_scanpos = xsp;
8013     if (jj_scan_token(82)) return true;
8014     }
8015     }
8016     return false;
8017   }
8018 
8019   private boolean jj_3R_370() {
8020     if (jj_3R_386()) return true;
8021     return false;
8022   }
8023 
8024   private boolean jj_3R_367() {
8025     if (jj_3R_369()) return true;
8026     return false;
8027   }
8028 
8029   private boolean jj_3R_260() {
8030     if (jj_scan_token(IDENTIFIER)) return true;
8031     if (jj_3R_101()) return true;
8032     Token xsp;
8033     xsp = jj_scanpos;
8034     if (jj_3R_368()) jj_scanpos = xsp;
8035     if (jj_scan_token(SEMICOLON)) return true;
8036     return false;
8037   }
8038 
8039   private boolean jj_3_3() {
8040     if (jj_scan_token(COMMA)) return true;
8041     Token xsp;
8042     while (true) {
8043       xsp = jj_scanpos;
8044       if (jj_3R_85()) { jj_scanpos = xsp; break; }
8045     }
8046     if (jj_3R_86()) return true;
8047     return false;
8048   }
8049 
8050   private boolean jj_3R_160() {
8051     if (jj_scan_token(LBRACE)) return true;
8052     Token xsp;
8053     while (true) {
8054       xsp = jj_scanpos;
8055       if (jj_3R_367()) { jj_scanpos = xsp; break; }
8056     }
8057     if (jj_scan_token(RBRACE)) return true;
8058     return false;
8059   }
8060 
8061   private boolean jj_3R_399() {
8062     if (jj_scan_token(FINALLY)) return true;
8063     if (jj_3R_297()) return true;
8064     return false;
8065   }
8066 
8067   private boolean jj_3R_331() {
8068     if (jj_scan_token(EXTENDS)) return true;
8069     if (jj_3R_276()) return true;
8070     Token xsp;
8071     while (true) {
8072       xsp = jj_scanpos;
8073       if (jj_3R_347()) { jj_scanpos = xsp; break; }
8074     }
8075     return false;
8076   }
8077 
8078   private boolean jj_3R_314() {
8079     if (jj_3R_154()) return true;
8080     return false;
8081   }
8082 
8083   private boolean jj_3R_319() {
8084     if (jj_3R_154()) return true;
8085     return false;
8086   }
8087 
8088   private boolean jj_3_70() {
8089     if (jj_scan_token(SEMICOLON)) return true;
8090     if (jj_3R_150()) return true;
8091     return false;
8092   }
8093 
8094   private boolean jj_3R_252() {
8095     Token xsp;
8096     xsp = jj_scanpos;
8097     if (jj_scan_token(28)) {
8098     jj_scanpos = xsp;
8099     if (jj_scan_token(12)) return true;
8100     }
8101     return false;
8102   }
8103 
8104   private boolean jj_3R_255() {
8105     Token xsp;
8106     while (true) {
8107       xsp = jj_scanpos;
8108       if (jj_3R_319()) { jj_scanpos = xsp; break; }
8109     }
8110     if (jj_scan_token(IDENTIFIER)) return true;
8111     xsp = jj_scanpos;
8112     if (jj_3R_320()) jj_scanpos = xsp;
8113     return false;
8114   }
8115 
8116   private boolean jj_3R_398() {
8117     if (jj_scan_token(CATCH)) return true;
8118     if (jj_scan_token(LPAREN)) return true;
8119     if (jj_3R_132()) return true;
8120     if (jj_scan_token(RPAREN)) return true;
8121     if (jj_3R_297()) return true;
8122     return false;
8123   }
8124 
8125   private boolean jj_3R_155() {
8126     Token xsp;
8127     xsp = jj_scanpos;
8128     if (jj_3R_252()) jj_scanpos = xsp;
8129     if (jj_scan_token(CLASS)) return true;
8130     return false;
8131   }
8132 
8133   private boolean jj_3R_245() {
8134     Token xsp;
8135     xsp = jj_scanpos;
8136     if (jj_scan_token(28)) {
8137     jj_scanpos = xsp;
8138     if (jj_3R_314()) return true;
8139     }
8140     return false;
8141   }
8142 
8143   private boolean jj_3R_150() {
8144     Token xsp;
8145     while (true) {
8146       xsp = jj_scanpos;
8147       if (jj_3R_245()) { jj_scanpos = xsp; break; }
8148     }
8149     if (jj_3R_90()) return true;
8150     if (jj_3R_130()) return true;
8151     if (jj_scan_token(ASSIGN)) return true;
8152     if (jj_3R_101()) return true;
8153     return false;
8154   }
8155 
8156   private boolean jj_3R_163() {
8157     if (jj_scan_token(LT)) return true;
8158     if (jj_3R_255()) return true;
8159     Token xsp;
8160     while (true) {
8161       xsp = jj_scanpos;
8162       if (jj_3R_256()) { jj_scanpos = xsp; break; }
8163     }
8164     if (jj_scan_token(GT)) return true;
8165     return false;
8166   }
8167 
8168   private boolean jj_3R_431() {
8169     if (jj_3R_369()) return true;
8170     return false;
8171   }
8172 
8173   private boolean jj_3R_411() {
8174     if (jj_3R_150()) return true;
8175     Token xsp;
8176     while (true) {
8177       xsp = jj_scanpos;
8178       if (jj_3_70()) { jj_scanpos = xsp; break; }
8179     }
8180     return false;
8181   }
8182 
8183   private boolean jj_3R_86() {
8184     if (jj_scan_token(IDENTIFIER)) return true;
8185     Token xsp;
8186     xsp = jj_scanpos;
8187     if (jj_3R_435()) jj_scanpos = xsp;
8188     xsp = jj_scanpos;
8189     if (jj_3R_436()) jj_scanpos = xsp;
8190     return false;
8191   }
8192 
8193   private boolean jj_3R_425() {
8194     if (jj_scan_token(SEMICOLON)) return true;
8195     Token xsp;
8196     while (true) {
8197       xsp = jj_scanpos;
8198       if (jj_3R_431()) { jj_scanpos = xsp; break; }
8199     }
8200     return false;
8201   }
8202 
8203   private boolean jj_3_69() {
8204     if (jj_scan_token(SEMICOLON)) return true;
8205     return false;
8206   }
8207 
8208   private boolean jj_3R_430() {
8209     if (jj_3R_154()) return true;
8210     return false;
8211   }
8212 
8213   private boolean jj_3R_424() {
8214     Token xsp;
8215     while (true) {
8216       xsp = jj_scanpos;
8217       if (jj_3R_430()) { jj_scanpos = xsp; break; }
8218     }
8219     if (jj_3R_86()) return true;
8220     while (true) {
8221       xsp = jj_scanpos;
8222       if (jj_3_3()) { jj_scanpos = xsp; break; }
8223     }
8224     return false;
8225   }
8226 
8227   private boolean jj_3R_162() {
8228     if (jj_scan_token(LBRACE)) return true;
8229     Token xsp;
8230     xsp = jj_scanpos;
8231     if (jj_3R_424()) jj_scanpos = xsp;
8232     xsp = jj_scanpos;
8233     if (jj_scan_token(83)) jj_scanpos = xsp;
8234     xsp = jj_scanpos;
8235     if (jj_3R_425()) jj_scanpos = xsp;
8236     if (jj_scan_token(RBRACE)) return true;
8237     return false;
8238   }
8239 
8240   private boolean jj_3R_397() {
8241     if (jj_scan_token(LPAREN)) return true;
8242     if (jj_3R_411()) return true;
8243     Token xsp;
8244     xsp = jj_scanpos;
8245     if (jj_3_69()) jj_scanpos = xsp;
8246     if (jj_scan_token(RPAREN)) return true;
8247     return false;
8248   }
8249 
8250   private boolean jj_3R_379() {
8251     if (jj_3R_397()) return true;
8252     return false;
8253   }
8254 
8255   private boolean jj_3R_161() {
8256     if (jj_3R_254()) return true;
8257     return false;
8258   }
8259 
8260   private boolean jj_3R_381() {
8261     if (jj_3R_399()) return true;
8262     return false;
8263   }
8264 
8265   private boolean jj_3R_380() {
8266     if (jj_3R_398()) return true;
8267     return false;
8268   }
8269 
8270   private boolean jj_3R_310() {
8271     if (jj_scan_token(TRY)) return true;
8272     Token xsp;
8273     xsp = jj_scanpos;
8274     if (jj_3R_379()) jj_scanpos = xsp;
8275     if (jj_3R_297()) return true;
8276     while (true) {
8277       xsp = jj_scanpos;
8278       if (jj_3R_380()) { jj_scanpos = xsp; break; }
8279     }
8280     xsp = jj_scanpos;
8281     if (jj_3R_381()) jj_scanpos = xsp;
8282     return false;
8283   }
8284 
8285   private boolean jj_3R_384() {
8286     if (jj_3R_154()) return true;
8287     return false;
8288   }
8289 
8290   private boolean jj_3R_88() {
8291     if (jj_scan_token(IDENTIFIER)) return true;
8292     if (jj_scan_token(IDENTIFIER)) return true;
8293     Token xsp;
8294     xsp = jj_scanpos;
8295     if (jj_3R_161()) jj_scanpos = xsp;
8296     if (jj_3R_162()) return true;
8297     return false;
8298   }
8299 
8300   private boolean jj_3R_401() {
8301     if (jj_3R_154()) return true;
8302     return false;
8303   }
8304 
8305   private boolean jj_3R_309() {
8306     if (jj_scan_token(SYNCHRONIZED)) return true;
8307     if (jj_scan_token(LPAREN)) return true;
8308     if (jj_3R_101()) return true;
8309     if (jj_scan_token(RPAREN)) return true;
8310     if (jj_3R_297()) return true;
8311     return false;
8312   }
8313 
8314   private boolean jj_3R_382() {
8315     if (jj_3R_154()) return true;
8316     return false;
8317   }
8318 
8319   private boolean jj_3R_378() {
8320     if (jj_3R_101()) return true;
8321     return false;
8322   }
8323 
8324   private boolean jj_3R_385() {
8325     if (jj_scan_token(COMMA)) return true;
8326     Token xsp;
8327     while (true) {
8328       xsp = jj_scanpos;
8329       if (jj_3R_401()) { jj_scanpos = xsp; break; }
8330     }
8331     if (jj_3R_276()) return true;
8332     return false;
8333   }
8334 
8335   private boolean jj_3R_400() {
8336     if (jj_3R_154()) return true;
8337     return false;
8338   }
8339 
8340   private boolean jj_3R_377() {
8341     if (jj_scan_token(IDENTIFIER)) return true;
8342     return false;
8343   }
8344 
8345   private boolean jj_3R_254() {
8346     if (jj_scan_token(IMPLEMENTS)) return true;
8347     Token xsp;
8348     while (true) {
8349       xsp = jj_scanpos;
8350       if (jj_3R_384()) { jj_scanpos = xsp; break; }
8351     }
8352     if (jj_3R_276()) return true;
8353     while (true) {
8354       xsp = jj_scanpos;
8355       if (jj_3R_385()) { jj_scanpos = xsp; break; }
8356     }
8357     return false;
8358   }
8359 
8360   private boolean jj_3R_308() {
8361     if (jj_scan_token(THROW)) return true;
8362     if (jj_3R_101()) return true;
8363     if (jj_scan_token(SEMICOLON)) return true;
8364     return false;
8365   }
8366 
8367   private boolean jj_3R_383() {
8368     if (jj_scan_token(COMMA)) return true;
8369     Token xsp;
8370     while (true) {
8371       xsp = jj_scanpos;
8372       if (jj_3R_400()) { jj_scanpos = xsp; break; }
8373     }
8374     if (jj_3R_276()) return true;
8375     return false;
8376   }
8377 
8378   private boolean jj_3R_429() {
8379     if (jj_scan_token(COMMA)) return true;
8380     if (jj_3R_299()) return true;
8381     return false;
8382   }
8383 
8384   private boolean jj_3R_307() {
8385     if (jj_scan_token(RETURN)) return true;
8386     Token xsp;
8387     xsp = jj_scanpos;
8388     if (jj_3R_378()) jj_scanpos = xsp;
8389     if (jj_scan_token(SEMICOLON)) return true;
8390     return false;
8391   }
8392 
8393   private boolean jj_3R_253() {
8394     if (jj_scan_token(EXTENDS)) return true;
8395     Token xsp;
8396     while (true) {
8397       xsp = jj_scanpos;
8398       if (jj_3R_382()) { jj_scanpos = xsp; break; }
8399     }
8400     if (jj_3R_276()) return true;
8401     while (true) {
8402       xsp = jj_scanpos;
8403       if (jj_3R_383()) { jj_scanpos = xsp; break; }
8404     }
8405     return false;
8406   }
8407 
8408   private boolean jj_3R_376() {
8409     if (jj_scan_token(IDENTIFIER)) return true;
8410     return false;
8411   }
8412 
8413   private boolean jj_3R_306() {
8414     if (jj_scan_token(CONTINUE)) return true;
8415     Token xsp;
8416     xsp = jj_scanpos;
8417     if (jj_3R_377()) jj_scanpos = xsp;
8418     if (jj_scan_token(SEMICOLON)) return true;
8419     return false;
8420   }
8421 
8422   private boolean jj_3R_159() {
8423     if (jj_3R_254()) return true;
8424     return false;
8425   }
8426 
8427   private boolean jj_3R_158() {
8428     if (jj_3R_253()) return true;
8429     return false;
8430   }
8431 
8432   private boolean jj_3R_157() {
8433     if (jj_3R_163()) return true;
8434     return false;
8435   }
8436 
8437   private boolean jj_3R_305() {
8438     if (jj_scan_token(BREAK)) return true;
8439     Token xsp;
8440     xsp = jj_scanpos;
8441     if (jj_3R_376()) jj_scanpos = xsp;
8442     if (jj_scan_token(SEMICOLON)) return true;
8443     return false;
8444   }
8445 
8446   private boolean jj_3R_87() {
8447     Token xsp;
8448     xsp = jj_scanpos;
8449     if (jj_3R_155()) {
8450     jj_scanpos = xsp;
8451     if (jj_3R_156()) return true;
8452     }
8453     if (jj_scan_token(IDENTIFIER)) return true;
8454     xsp = jj_scanpos;
8455     if (jj_3R_157()) jj_scanpos = xsp;
8456     xsp = jj_scanpos;
8457     if (jj_3R_158()) jj_scanpos = xsp;
8458     xsp = jj_scanpos;
8459     if (jj_3R_159()) jj_scanpos = xsp;
8460     if (jj_3R_160()) return true;
8461     return false;
8462   }
8463 
8464   private boolean jj_3R_410() {
8465     if (jj_3R_423()) return true;
8466     return false;
8467   }
8468 
8469   private boolean jj_3_68() {
8470     if (jj_3R_149()) return true;
8471     return false;
8472   }
8473 
8474   private boolean jj_3R_423() {
8475     if (jj_3R_299()) return true;
8476     Token xsp;
8477     while (true) {
8478       xsp = jj_scanpos;
8479       if (jj_3R_429()) { jj_scanpos = xsp; break; }
8480     }
8481     return false;
8482   }
8483 
8484   private boolean jj_3R_373() {
8485     if (jj_scan_token(ELSE)) return true;
8486     if (jj_3R_146()) return true;
8487     return false;
8488   }
8489 
8490   private boolean jj_3R_422() {
8491     if (jj_3R_423()) return true;
8492     return false;
8493   }
8494 
8495   private boolean jj_3R_421() {
8496     if (jj_3R_149()) return true;
8497     return false;
8498   }
8499 
8500   private boolean jj_3R_409() {
8501     Token xsp;
8502     xsp = jj_scanpos;
8503     if (jj_3R_421()) {
8504     jj_scanpos = xsp;
8505     if (jj_3R_422()) return true;
8506     }
8507     return false;
8508   }
8509 
8510   private boolean jj_3_67() {
8511     if (jj_3R_149()) return true;
8512     if (jj_scan_token(COLON)) return true;
8513     return false;
8514   }
8515 
8516   private boolean jj_3R_396() {
8517     if (jj_3R_410()) return true;
8518     return false;
8519   }
8520 
8521   private boolean jj_3R_395() {
8522     if (jj_3R_101()) return true;
8523     return false;
8524   }
8525 
8526   private boolean jj_3R_394() {
8527     if (jj_3R_409()) return true;
8528     return false;
8529   }
8530 
8531   private boolean jj_3R_375() {
8532     Token xsp;
8533     xsp = jj_scanpos;
8534     if (jj_3R_394()) jj_scanpos = xsp;
8535     if (jj_scan_token(SEMICOLON)) return true;
8536     xsp = jj_scanpos;
8537     if (jj_3R_395()) jj_scanpos = xsp;
8538     if (jj_scan_token(SEMICOLON)) return true;
8539     xsp = jj_scanpos;
8540     if (jj_3R_396()) jj_scanpos = xsp;
8541     return false;
8542   }
8543 
8544   private boolean jj_3R_374() {
8545     if (jj_3R_149()) return true;
8546     if (jj_scan_token(COLON)) return true;
8547     if (jj_3R_101()) return true;
8548     return false;
8549   }
8550 
8551   private boolean jj_3R_84() {
8552     if (jj_3R_154()) return true;
8553     return false;
8554   }
8555 
8556   private boolean jj_3R_83() {
8557     if (jj_scan_token(_DEFAULT)) return true;
8558     return false;
8559   }
8560 
8561   private boolean jj_3R_304() {
8562     if (jj_scan_token(FOR)) return true;
8563     if (jj_scan_token(LPAREN)) return true;
8564     Token xsp;
8565     xsp = jj_scanpos;
8566     if (jj_3R_374()) {
8567     jj_scanpos = xsp;
8568     if (jj_3R_375()) return true;
8569     }
8570     if (jj_scan_token(RPAREN)) return true;
8571     if (jj_3R_146()) return true;
8572     return false;
8573   }
8574 
8575   private boolean jj_3R_82() {
8576     if (jj_scan_token(STRICTFP)) return true;
8577     return false;
8578   }
8579 
8580   private boolean jj_3R_81() {
8581     if (jj_scan_token(VOLATILE)) return true;
8582     return false;
8583   }
8584 
8585   private boolean jj_3R_80() {
8586     if (jj_scan_token(TRANSIENT)) return true;
8587     return false;
8588   }
8589 
8590   private boolean jj_3R_79() {
8591     if (jj_scan_token(NATIVE)) return true;
8592     return false;
8593   }
8594 
8595   private boolean jj_3R_78() {
8596     if (jj_scan_token(SYNCHRONIZED)) return true;
8597     return false;
8598   }
8599 
8600   private boolean jj_3R_77() {
8601     if (jj_scan_token(ABSTRACT)) return true;
8602     return false;
8603   }
8604 
8605   private boolean jj_3R_303() {
8606     if (jj_scan_token(DO)) return true;
8607     if (jj_3R_146()) return true;
8608     if (jj_scan_token(WHILE)) return true;
8609     if (jj_scan_token(LPAREN)) return true;
8610     if (jj_3R_101()) return true;
8611     if (jj_scan_token(RPAREN)) return true;
8612     if (jj_scan_token(SEMICOLON)) return true;
8613     return false;
8614   }
8615 
8616   private boolean jj_3R_76() {
8617     if (jj_scan_token(FINAL)) return true;
8618     return false;
8619   }
8620 
8621   private boolean jj_3R_75() {
8622     if (jj_scan_token(PRIVATE)) return true;
8623     return false;
8624   }
8625 
8626   private boolean jj_3R_74() {
8627     if (jj_scan_token(PROTECTED)) return true;
8628     return false;
8629   }
8630 
8631   private boolean jj_3R_73() {
8632     if (jj_scan_token(STATIC)) return true;
8633     return false;
8634   }
8635 
8636   private boolean jj_3R_72() {
8637     if (jj_scan_token(PUBLIC)) return true;
8638     return false;
8639   }
8640 
8641   private boolean jj_3R_302() {
8642     if (jj_scan_token(WHILE)) return true;
8643     if (jj_scan_token(LPAREN)) return true;
8644     if (jj_3R_101()) return true;
8645     if (jj_scan_token(RPAREN)) return true;
8646     if (jj_3R_146()) return true;
8647     return false;
8648   }
8649 
8650   private boolean jj_3_2() {
8651     Token xsp;
8652     xsp = jj_scanpos;
8653     if (jj_3R_72()) {
8654     jj_scanpos = xsp;
8655     if (jj_3R_73()) {
8656     jj_scanpos = xsp;
8657     if (jj_3R_74()) {
8658     jj_scanpos = xsp;
8659     if (jj_3R_75()) {
8660     jj_scanpos = xsp;
8661     if (jj_3R_76()) {
8662     jj_scanpos = xsp;
8663     if (jj_3R_77()) {
8664     jj_scanpos = xsp;
8665     if (jj_3R_78()) {
8666     jj_scanpos = xsp;
8667     if (jj_3R_79()) {
8668     jj_scanpos = xsp;
8669     if (jj_3R_80()) {
8670     jj_scanpos = xsp;
8671     if (jj_3R_81()) {
8672     jj_scanpos = xsp;
8673     if (jj_3R_82()) {
8674     jj_scanpos = xsp;
8675     if (jj_3R_83()) {
8676     jj_scanpos = xsp;
8677     if (jj_3R_84()) return true;
8678     }
8679     }
8680     }
8681     }
8682     }
8683     }
8684     }
8685     }
8686     }
8687     }
8688     }
8689     }
8690     return false;
8691   }
8692 
8693   private boolean jj_3R_387() {
8694     Token xsp;
8695     while (true) {
8696       xsp = jj_scanpos;
8697       if (jj_3_2()) { jj_scanpos = xsp; break; }
8698     }
8699     return false;
8700   }
8701 
8702   private boolean jj_3R_301() {
8703     if (jj_scan_token(IF)) return true;
8704     if (jj_scan_token(LPAREN)) return true;
8705     if (jj_3R_101()) return true;
8706     if (jj_scan_token(RPAREN)) return true;
8707     if (jj_3R_146()) return true;
8708     Token xsp;
8709     xsp = jj_scanpos;
8710     if (jj_3R_373()) jj_scanpos = xsp;
8711     return false;
8712   }
8713 
8714   private boolean jj_3_66() {
8715     if (jj_3R_94()) return true;
8716     return false;
8717   }
8718 
8719   private boolean jj_3R_261() {
8720     if (jj_3R_154()) return true;
8721     return false;
8722   }
8723 
8724   private boolean jj_3R_408() {
8725     if (jj_scan_token(_DEFAULT)) return true;
8726     if (jj_scan_token(COLON)) return true;
8727     return false;
8728   }
8729 
8730   private boolean jj_3R_407() {
8731     if (jj_scan_token(CASE)) return true;
8732     if (jj_3R_101()) return true;
8733     if (jj_scan_token(COLON)) return true;
8734     return false;
8735   }
8736 
8737   private boolean jj_3R_393() {
8738     Token xsp;
8739     xsp = jj_scanpos;
8740     if (jj_3R_407()) {
8741     jj_scanpos = xsp;
8742     if (jj_3R_408()) return true;
8743     }
8744     return false;
8745   }
8746 
8747   private boolean jj_3R_312() {
8748     if (jj_3R_154()) return true;
8749     return false;
8750   }
8751 
8752   private boolean jj_3R_71() {
8753     if (jj_3R_154()) return true;
8754     return false;
8755   }
8756 
8757   private boolean jj_3R_372() {
8758     if (jj_3R_393()) return true;
8759     Token xsp;
8760     while (true) {
8761       xsp = jj_scanpos;
8762       if (jj_3_66()) { jj_scanpos = xsp; break; }
8763     }
8764     return false;
8765   }
8766 
8767   private boolean jj_3_1() {
8768     Token xsp;
8769     while (true) {
8770       xsp = jj_scanpos;
8771       if (jj_3R_71()) { jj_scanpos = xsp; break; }
8772     }
8773     if (jj_scan_token(PACKAGE)) return true;
8774     return false;
8775   }
8776 
8777   private boolean jj_3R_300() {
8778     if (jj_scan_token(SWITCH)) return true;
8779     if (jj_scan_token(LPAREN)) return true;
8780     if (jj_3R_101()) return true;
8781     if (jj_scan_token(RPAREN)) return true;
8782     if (jj_scan_token(LBRACE)) return true;
8783     Token xsp;
8784     while (true) {
8785       xsp = jj_scanpos;
8786       if (jj_3R_372()) { jj_scanpos = xsp; break; }
8787     }
8788     if (jj_scan_token(RBRACE)) return true;
8789     return false;
8790   }
8791 
8792   private boolean jj_3_65() {
8793     if (jj_3R_95()) return true;
8794     Token xsp;
8795     xsp = jj_scanpos;
8796     if (jj_scan_token(98)) {
8797     jj_scanpos = xsp;
8798     if (jj_scan_token(99)) return true;
8799     }
8800     return false;
8801   }
8802 
8803   private boolean jj_3R_392() {
8804     if (jj_3R_100()) return true;
8805     if (jj_3R_101()) return true;
8806     return false;
8807   }
8808 
8809   private boolean jj_3R_329() {
8810     if (jj_3R_95()) return true;
8811     Token xsp;
8812     xsp = jj_scanpos;
8813     if (jj_3R_392()) jj_scanpos = xsp;
8814     return false;
8815   }
8816 
8817   private boolean jj_3R_148() {
8818     Token xsp;
8819     xsp = jj_scanpos;
8820     if (jj_scan_token(28)) {
8821     jj_scanpos = xsp;
8822     if (jj_scan_token(12)) return true;
8823     }
8824     return false;
8825   }
8826 
8827   private boolean jj_3R_328() {
8828     if (jj_3R_344()) return true;
8829     return false;
8830   }
8831 
8832   private boolean jj_3R_327() {
8833     if (jj_3R_282()) return true;
8834     return false;
8835   }
8836 
8837   private boolean jj_3R_326() {
8838     if (jj_3R_281()) return true;
8839     return false;
8840   }
8841 
8842   private boolean jj_3R_299() {
8843     Token xsp;
8844     xsp = jj_scanpos;
8845     if (jj_3R_326()) {
8846     jj_scanpos = xsp;
8847     if (jj_3R_327()) {
8848     jj_scanpos = xsp;
8849     if (jj_3R_328()) {
8850     jj_scanpos = xsp;
8851     if (jj_3R_329()) return true;
8852     }
8853     }
8854     }
8855     return false;
8856   }
8857 
8858   private boolean jj_3R_298() {
8859     if (jj_scan_token(SEMICOLON)) return true;
8860     return false;
8861   }
8862 
8863   private boolean jj_3R_147() {
8864     if (jj_3R_154()) return true;
8865     return false;
8866   }
8867 
8868   private boolean jj_3_64() {
8869     Token xsp;
8870     xsp = jj_scanpos;
8871     if (jj_3R_147()) jj_scanpos = xsp;
8872     xsp = jj_scanpos;
8873     if (jj_3R_148()) jj_scanpos = xsp;
8874     if (jj_scan_token(CLASS)) return true;
8875     return false;
8876   }
8877 
8878   private boolean jj_3R_226() {
8879     if (jj_3R_154()) return true;
8880     return false;
8881   }
8882 
8883   private boolean jj_3R_244() {
8884     if (jj_scan_token(COMMA)) return true;
8885     if (jj_3R_243()) return true;
8886     return false;
8887   }
8888 
8889   private boolean jj_3R_311() {
8890     if (jj_scan_token(FINAL)) return true;
8891     return false;
8892   }
8893 
8894   private boolean jj_3R_242() {
8895     Token xsp;
8896     xsp = jj_scanpos;
8897     if (jj_3R_311()) {
8898     jj_scanpos = xsp;
8899     if (jj_3R_312()) return true;
8900     }
8901     return false;
8902   }
8903 
8904   private boolean jj_3R_149() {
8905     Token xsp;
8906     while (true) {
8907       xsp = jj_scanpos;
8908       if (jj_3R_242()) { jj_scanpos = xsp; break; }
8909     }
8910     if (jj_3R_90()) return true;
8911     if (jj_3R_243()) return true;
8912     while (true) {
8913       xsp = jj_scanpos;
8914       if (jj_3R_244()) { jj_scanpos = xsp; break; }
8915     }
8916     return false;
8917   }
8918 
8919   private boolean jj_3R_145() {
8920     Token xsp;
8921     xsp = jj_scanpos;
8922     if (jj_scan_token(28)) {
8923     jj_scanpos = xsp;
8924     if (jj_3R_226()) return true;
8925     }
8926     return false;
8927   }
8928 
8929   private boolean jj_3R_172() {
8930     Token xsp;
8931     xsp = jj_scanpos;
8932     if (jj_3R_261()) jj_scanpos = xsp;
8933     if (jj_3R_87()) return true;
8934     return false;
8935   }
8936 
8937   private boolean jj_3_62() {
8938     Token xsp;
8939     while (true) {
8940       xsp = jj_scanpos;
8941       if (jj_3R_145()) { jj_scanpos = xsp; break; }
8942     }
8943     if (jj_3R_90()) return true;
8944     if (jj_scan_token(IDENTIFIER)) return true;
8945     return false;
8946   }
8947 
8948   private boolean jj_3_63() {
8949     if (jj_3R_146()) return true;
8950     return false;
8951   }
8952 
8953   private boolean jj_3R_171() {
8954     if (jj_3R_149()) return true;
8955     if (jj_scan_token(SEMICOLON)) return true;
8956     return false;
8957   }
8958 
8959   private boolean jj_3R_94() {
8960     Token xsp;
8961     xsp = jj_scanpos;
8962     jj_lookingAhead = true;
8963     jj_semLA = isNextTokenAnAssert();
8964     jj_lookingAhead = false;
8965     if (!jj_semLA || jj_3R_170()) {
8966     jj_scanpos = xsp;
8967     if (jj_3R_171()) {
8968     jj_scanpos = xsp;
8969     if (jj_3_63()) {
8970     jj_scanpos = xsp;
8971     if (jj_3R_172()) return true;
8972     }
8973     }
8974     }
8975     return false;
8976   }
8977 
8978   private boolean jj_3_61() {
8979     if (jj_3R_94()) return true;
8980     return false;
8981   }
8982 
8983   private boolean jj_3R_170() {
8984     if (jj_3R_260()) return true;
8985     return false;
8986   }
8987 
8988   private boolean jj_3R_297() {
8989     if (jj_scan_token(LBRACE)) return true;
8990     Token xsp;
8991     while (true) {
8992       xsp = jj_scanpos;
8993       if (jj_3_61()) { jj_scanpos = xsp; break; }
8994     }
8995     if (jj_scan_token(RBRACE)) return true;
8996     return false;
8997   }
8998 
8999   private boolean jj_3_58() {
9000     if (jj_scan_token(LBRACKET)) return true;
9001     if (jj_scan_token(RBRACKET)) return true;
9002     return false;
9003   }
9004 
9005   private boolean jj_3R_144() {
9006     if (jj_scan_token(IDENTIFIER)) return true;
9007     if (jj_scan_token(COLON)) return true;
9008     if (jj_3R_146()) return true;
9009     return false;
9010   }
9011 
9012   private boolean jj_3R_241() {
9013     if (jj_3R_310()) return true;
9014     return false;
9015   }
9016 
9017   private boolean jj_3R_240() {
9018     if (jj_3R_309()) return true;
9019     return false;
9020   }
9021 
9022   private boolean jj_3R_239() {
9023     if (jj_3R_308()) return true;
9024     return false;
9025   }
9026 
9027   private boolean jj_3R_295() {
9028     if (jj_3R_297()) return true;
9029     return false;
9030   }
9031 
9032   private boolean jj_3R_238() {
9033     if (jj_3R_307()) return true;
9034     return false;
9035   }
9036 
9037   private boolean jj_3R_237() {
9038     if (jj_3R_306()) return true;
9039     return false;
9040   }
9041 
9042   private boolean jj_3R_236() {
9043     if (jj_3R_305()) return true;
9044     return false;
9045   }
9046 
9047   private boolean jj_3R_235() {
9048     if (jj_3R_304()) return true;
9049     return false;
9050   }
9051 
9052   private boolean jj_3R_234() {
9053     if (jj_3R_303()) return true;
9054     return false;
9055   }
9056 
9057   private boolean jj_3R_233() {
9058     if (jj_3R_302()) return true;
9059     return false;
9060   }
9061 
9062   private boolean jj_3R_232() {
9063     if (jj_3R_301()) return true;
9064     return false;
9065   }
9066 
9067   private boolean jj_3R_231() {
9068     if (jj_3R_300()) return true;
9069     return false;
9070   }
9071 
9072   private boolean jj_3R_230() {
9073     if (jj_3R_299()) return true;
9074     if (jj_scan_token(SEMICOLON)) return true;
9075     return false;
9076   }
9077 
9078   private boolean jj_3R_229() {
9079     if (jj_3R_298()) return true;
9080     return false;
9081   }
9082 
9083   private boolean jj_3R_228() {
9084     if (jj_3R_297()) return true;
9085     return false;
9086   }
9087 
9088   private boolean jj_3_60() {
9089     if (jj_3R_144()) return true;
9090     return false;
9091   }
9092 
9093   private boolean jj_3R_146() {
9094     Token xsp;
9095     xsp = jj_scanpos;
9096     jj_lookingAhead = true;
9097     jj_semLA = isNextTokenAnAssert();
9098     jj_lookingAhead = false;
9099     if (!jj_semLA || jj_3R_227()) {
9100     jj_scanpos = xsp;
9101     if (jj_3_60()) {
9102     jj_scanpos = xsp;
9103     if (jj_3R_228()) {
9104     jj_scanpos = xsp;
9105     if (jj_3R_229()) {
9106     jj_scanpos = xsp;
9107     if (jj_3R_230()) {
9108     jj_scanpos = xsp;
9109     if (jj_3R_231()) {
9110     jj_scanpos = xsp;
9111     if (jj_3R_232()) {
9112     jj_scanpos = xsp;
9113     if (jj_3R_233()) {
9114     jj_scanpos = xsp;
9115     if (jj_3R_234()) {
9116     jj_scanpos = xsp;
9117     if (jj_3R_235()) {
9118     jj_scanpos = xsp;
9119     if (jj_3R_236()) {
9120     jj_scanpos = xsp;
9121     if (jj_3R_237()) {
9122     jj_scanpos = xsp;
9123     if (jj_3R_238()) {
9124     jj_scanpos = xsp;
9125     if (jj_3R_239()) {
9126     jj_scanpos = xsp;
9127     if (jj_3R_240()) {
9128     jj_scanpos = xsp;
9129     if (jj_3R_241()) return true;
9130     }
9131     }
9132     }
9133     }
9134     }
9135     }
9136     }
9137     }
9138     }
9139     }
9140     }
9141     }
9142     }
9143     }
9144     }
9145     return false;
9146   }
9147 
9148   private boolean jj_3R_227() {
9149     if (jj_3R_260()) return true;
9150     return false;
9151   }
9152 
9153   private boolean jj_3R_350() {
9154     if (jj_3R_97()) return true;
9155     return false;
9156   }
9157 
9158   private boolean jj_3R_294() {
9159     if (jj_3R_101()) return true;
9160     return false;
9161   }
9162 
9163   private boolean jj_3R_358() {
9164     if (jj_3R_160()) return true;
9165     return false;
9166   }
9167 
9168   private boolean jj_3R_296() {
9169     if (jj_scan_token(LBRACKET)) return true;
9170     if (jj_scan_token(RBRACKET)) return true;
9171     return false;
9172   }
9173 
9174   private boolean jj_3_57() {
9175     if (jj_scan_token(LBRACKET)) return true;
9176     if (jj_3R_101()) return true;
9177     if (jj_scan_token(RBRACKET)) return true;
9178     return false;
9179   }
9180 
9181   private boolean jj_3R_225() {
9182     Token xsp;
9183     if (jj_3R_296()) return true;
9184     while (true) {
9185       xsp = jj_scanpos;
9186       if (jj_3R_296()) { jj_scanpos = xsp; break; }
9187     }
9188     if (jj_3R_257()) return true;
9189     return false;
9190   }
9191 
9192   private boolean jj_3_59() {
9193     Token xsp;
9194     if (jj_3_57()) return true;
9195     while (true) {
9196       xsp = jj_scanpos;
9197       if (jj_3_57()) { jj_scanpos = xsp; break; }
9198     }
9199     while (true) {
9200       xsp = jj_scanpos;
9201       if (jj_3_58()) { jj_scanpos = xsp; break; }
9202     }
9203     return false;
9204   }
9205 
9206   private boolean jj_3R_143() {
9207     Token xsp;
9208     xsp = jj_scanpos;
9209     if (jj_3_59()) {
9210     jj_scanpos = xsp;
9211     if (jj_3R_225()) return true;
9212     }
9213     return false;
9214   }
9215 
9216   private boolean jj_3R_352() {
9217     if (jj_3R_96()) return true;
9218     Token xsp;
9219     xsp = jj_scanpos;
9220     if (jj_3R_358()) jj_scanpos = xsp;
9221     return false;
9222   }
9223 
9224   private boolean jj_3R_351() {
9225     if (jj_3R_143()) return true;
9226     return false;
9227   }
9228 
9229   private boolean jj_3R_322() {
9230     if (jj_scan_token(COMMA)) return true;
9231     if (jj_3R_101()) return true;
9232     return false;
9233   }
9234 
9235   private boolean jj_3R_339() {
9236     if (jj_3R_154()) return true;
9237     return false;
9238   }
9239 
9240   private boolean jj_3R_340() {
9241     if (jj_3R_276()) return true;
9242     Token xsp;
9243     xsp = jj_scanpos;
9244     if (jj_3R_350()) jj_scanpos = xsp;
9245     xsp = jj_scanpos;
9246     if (jj_3R_351()) {
9247     jj_scanpos = xsp;
9248     if (jj_3R_352()) return true;
9249     }
9250     return false;
9251   }
9252 
9253   private boolean jj_3R_286() {
9254     if (jj_scan_token(BIT_AND)) return true;
9255     if (jj_3R_98()) return true;
9256     return false;
9257   }
9258 
9259   private boolean jj_3_56() {
9260     if (jj_3R_142()) return true;
9261     if (jj_3R_143()) return true;
9262     return false;
9263   }
9264 
9265   private boolean jj_3R_293() {
9266     if (jj_3R_297()) return true;
9267     return false;
9268   }
9269 
9270   private boolean jj_3R_140() {
9271     if (jj_scan_token(NEW)) return true;
9272     Token xsp;
9273     while (true) {
9274       xsp = jj_scanpos;
9275       if (jj_3R_339()) { jj_scanpos = xsp; break; }
9276     }
9277     xsp = jj_scanpos;
9278     if (jj_3_56()) {
9279     jj_scanpos = xsp;
9280     if (jj_3R_340()) return true;
9281     }
9282     return false;
9283   }
9284 
9285   private boolean jj_3R_131() {
9286     if (jj_scan_token(COMMA)) return true;
9287     if (jj_3R_130()) return true;
9288     return false;
9289   }
9290 
9291   private boolean jj_3R_174() {
9292     if (jj_3R_274()) return true;
9293     return false;
9294   }
9295 
9296   private boolean jj_3R_274() {
9297     if (jj_3R_101()) return true;
9298     Token xsp;
9299     while (true) {
9300       xsp = jj_scanpos;
9301       if (jj_3R_322()) { jj_scanpos = xsp; break; }
9302     }
9303     return false;
9304   }
9305 
9306   private boolean jj_3R_291() {
9307     if (jj_3R_297()) return true;
9308     return false;
9309   }
9310 
9311   private boolean jj_3R_139() {
9312     if (jj_scan_token(COMMA)) return true;
9313     if (jj_3R_130()) return true;
9314     return false;
9315   }
9316 
9317   private boolean jj_3R_133() {
9318     if (jj_scan_token(COMMA)) return true;
9319     if (jj_3R_132()) return true;
9320     return false;
9321   }
9322 
9323   private boolean jj_3R_96() {
9324     if (jj_scan_token(LPAREN)) return true;
9325     Token xsp;
9326     xsp = jj_scanpos;
9327     if (jj_3R_174()) jj_scanpos = xsp;
9328     if (jj_scan_token(RPAREN)) return true;
9329     return false;
9330   }
9331 
9332   private boolean jj_3R_292() {
9333     if (jj_3R_101()) return true;
9334     return false;
9335   }
9336 
9337   private boolean jj_3R_349() {
9338     if (jj_scan_token(NULL)) return true;
9339     return false;
9340   }
9341 
9342   private boolean jj_3R_357() {
9343     if (jj_scan_token(TRUE)) return true;
9344     return false;
9345   }
9346 
9347   private boolean jj_3R_348() {
9348     Token xsp;
9349     xsp = jj_scanpos;
9350     if (jj_3R_357()) {
9351     jj_scanpos = xsp;
9352     if (jj_scan_token(27)) return true;
9353     }
9354     return false;
9355   }
9356 
9357   private boolean jj_3R_290() {
9358     if (jj_3R_101()) return true;
9359     return false;
9360   }
9361 
9362   private boolean jj_3R_338() {
9363     if (jj_3R_349()) return true;
9364     return false;
9365   }
9366 
9367   private boolean jj_3R_337() {
9368     if (jj_3R_348()) return true;
9369     return false;
9370   }
9371 
9372   private boolean jj_3R_336() {
9373     if (jj_scan_token(STRING_LITERAL)) return true;
9374     return false;
9375   }
9376 
9377   private boolean jj_3R_335() {
9378     if (jj_scan_token(CHARACTER_LITERAL)) return true;
9379     return false;
9380   }
9381 
9382   private boolean jj_3R_334() {
9383     if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
9384     return false;
9385   }
9386 
9387   private boolean jj_3R_333() {
9388     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
9389     return false;
9390   }
9391 
9392   private boolean jj_3R_332() {
9393     if (jj_scan_token(INTEGER_LITERAL)) return true;
9394     return false;
9395   }
9396 
9397   private boolean jj_3R_321() {
9398     Token xsp;
9399     xsp = jj_scanpos;
9400     if (jj_3R_332()) {
9401     jj_scanpos = xsp;
9402     if (jj_3R_333()) {
9403     jj_scanpos = xsp;
9404     if (jj_3R_334()) {
9405     jj_scanpos = xsp;
9406     if (jj_3R_335()) {
9407     jj_scanpos = xsp;
9408     if (jj_3R_336()) {
9409     jj_scanpos = xsp;
9410     if (jj_3R_337()) {
9411     jj_scanpos = xsp;
9412     if (jj_3R_338()) return true;
9413     }
9414     }
9415     }
9416     }
9417     }
9418     }
9419     return false;
9420   }
9421 
9422   private boolean jj_3R_213() {
9423     if (jj_scan_token(IDENTIFIER)) return true;
9424     return false;
9425   }
9426 
9427   private boolean jj_3R_205() {
9428     if (jj_3R_96()) return true;
9429     return false;
9430   }
9431 
9432   private boolean jj_3R_204() {
9433     if (jj_scan_token(DOT)) return true;
9434     if (jj_scan_token(IDENTIFIER)) return true;
9435     return false;
9436   }
9437 
9438   private boolean jj_3R_203() {
9439     if (jj_scan_token(LBRACKET)) return true;
9440     if (jj_3R_101()) return true;
9441     if (jj_scan_token(RBRACKET)) return true;
9442     return false;
9443   }
9444 
9445   private boolean jj_3_55() {
9446     if (jj_3R_141()) return true;
9447     return false;
9448   }
9449 
9450   private boolean jj_3R_124() {
9451     if (jj_scan_token(REM)) return true;
9452     return false;
9453   }
9454 
9455   private boolean jj_3_54() {
9456     if (jj_scan_token(DOT)) return true;
9457     if (jj_3R_140()) return true;
9458     return false;
9459   }
9460 
9461   private boolean jj_3R_129() {
9462     Token xsp;
9463     xsp = jj_scanpos;
9464     if (jj_3_52()) {
9465     jj_scanpos = xsp;
9466     if (jj_3_53()) {
9467     jj_scanpos = xsp;
9468     if (jj_3_54()) {
9469     jj_scanpos = xsp;
9470     if (jj_3_55()) {
9471     jj_scanpos = xsp;
9472     if (jj_3R_203()) {
9473     jj_scanpos = xsp;
9474     if (jj_3R_204()) {
9475     jj_scanpos = xsp;
9476     if (jj_3R_205()) return true;
9477     }
9478     }
9479     }
9480     }
9481     }
9482     }
9483     return false;
9484   }
9485 
9486   private boolean jj_3_53() {
9487     if (jj_scan_token(DOT)) return true;
9488     if (jj_scan_token(SUPER)) return true;
9489     return false;
9490   }
9491 
9492   private boolean jj_3_52() {
9493     if (jj_scan_token(DOT)) return true;
9494     if (jj_scan_token(THIS)) return true;
9495     return false;
9496   }
9497 
9498   private boolean jj_3_49() {
9499     if (jj_3R_98()) return true;
9500     if (jj_3R_137()) return true;
9501     return false;
9502   }
9503 
9504   private boolean jj_3_48() {
9505     if (jj_3R_136()) return true;
9506     if (jj_scan_token(METHOD_REF)) return true;
9507     return false;
9508   }
9509 
9510   private boolean jj_3R_362() {
9511     if (jj_scan_token(DECR)) return true;
9512     return false;
9513   }
9514 
9515   private boolean jj_3_47() {
9516     if (jj_3R_135()) return true;
9517     if (jj_scan_token(DOT)) return true;
9518     if (jj_scan_token(CLASS)) return true;
9519     return false;
9520   }
9521 
9522   private boolean jj_3_51() {
9523     if (jj_scan_token(LPAREN)) return true;
9524     if (jj_3R_130()) return true;
9525     Token xsp;
9526     while (true) {
9527       xsp = jj_scanpos;
9528       if (jj_3R_139()) { jj_scanpos = xsp; break; }
9529     }
9530     if (jj_scan_token(RPAREN)) return true;
9531     if (jj_scan_token(LAMBDA)) return true;
9532     xsp = jj_scanpos;
9533     if (jj_3R_294()) {
9534     jj_scanpos = xsp;
9535     if (jj_3R_295()) return true;
9536     }
9537     return false;
9538   }
9539 
9540   private boolean jj_3R_285() {
9541     if (jj_3R_154()) return true;
9542     return false;
9543   }
9544 
9545   private boolean jj_3_50() {
9546     if (jj_3R_138()) return true;
9547     if (jj_scan_token(LAMBDA)) return true;
9548     Token xsp;
9549     xsp = jj_scanpos;
9550     if (jj_3R_292()) {
9551     jj_scanpos = xsp;
9552     if (jj_3R_293()) return true;
9553     }
9554     return false;
9555   }
9556 
9557   private boolean jj_3R_284() {
9558     if (jj_3R_154()) return true;
9559     return false;
9560   }
9561 
9562   private boolean jj_3R_134() {
9563     Token xsp;
9564     xsp = jj_scanpos;
9565     if (jj_3R_210()) {
9566     jj_scanpos = xsp;
9567     if (jj_3_50()) {
9568     jj_scanpos = xsp;
9569     if (jj_3_51()) return true;
9570     }
9571     }
9572     return false;
9573   }
9574 
9575   private boolean jj_3R_210() {
9576     if (jj_3R_130()) return true;
9577     if (jj_scan_token(LAMBDA)) return true;
9578     Token xsp;
9579     xsp = jj_scanpos;
9580     if (jj_3R_290()) {
9581     jj_scanpos = xsp;
9582     if (jj_3R_291()) return true;
9583     }
9584     return false;
9585   }
9586 
9587   private boolean jj_3_45() {
9588     if (jj_3R_134()) return true;
9589     return false;
9590   }
9591 
9592   private boolean jj_3_44() {
9593     if (jj_scan_token(LPAREN)) return true;
9594     if (jj_3R_132()) return true;
9595     if (jj_scan_token(COMMA)) return true;
9596     if (jj_3R_132()) return true;
9597     Token xsp;
9598     xsp = jj_scanpos;
9599     if (jj_3R_133()) jj_scanpos = xsp;
9600     if (jj_scan_token(RPAREN)) return true;
9601     if (jj_scan_token(LAMBDA)) return true;
9602     return false;
9603   }
9604 
9605   private boolean jj_3_43() {
9606     if (jj_scan_token(LPAREN)) return true;
9607     if (jj_3R_130()) return true;
9608     if (jj_scan_token(COMMA)) return true;
9609     if (jj_3R_130()) return true;
9610     Token xsp;
9611     xsp = jj_scanpos;
9612     if (jj_3R_131()) jj_scanpos = xsp;
9613     if (jj_scan_token(RPAREN)) return true;
9614     if (jj_scan_token(LAMBDA)) return true;
9615     return false;
9616   }
9617 
9618   private boolean jj_3_42() {
9619     if (jj_scan_token(IDENTIFIER)) return true;
9620     if (jj_scan_token(LAMBDA)) return true;
9621     return false;
9622   }
9623 
9624   private boolean jj_3R_273() {
9625     if (jj_3R_136()) return true;
9626     return false;
9627   }
9628 
9629   private boolean jj_3R_272() {
9630     if (jj_3R_98()) return true;
9631     if (jj_3R_137()) return true;
9632     return false;
9633   }
9634 
9635   private boolean jj_3R_271() {
9636     if (jj_3R_136()) return true;
9637     return false;
9638   }
9639 
9640   private boolean jj_3R_270() {
9641     if (jj_3R_135()) return true;
9642     if (jj_scan_token(DOT)) return true;
9643     if (jj_scan_token(CLASS)) return true;
9644     return false;
9645   }
9646 
9647   private boolean jj_3R_269() {
9648     if (jj_3R_140()) return true;
9649     return false;
9650   }
9651 
9652   private boolean jj_3_46() {
9653     if (jj_scan_token(LPAREN)) return true;
9654     if (jj_3R_101()) return true;
9655     if (jj_scan_token(RPAREN)) return true;
9656     return false;
9657   }
9658 
9659   private boolean jj_3R_268() {
9660     if (jj_3R_134()) return true;
9661     return false;
9662   }
9663 
9664   private boolean jj_3R_267() {
9665     if (jj_3R_134()) return true;
9666     return false;
9667   }
9668 
9669   private boolean jj_3R_266() {
9670     if (jj_3R_134()) return true;
9671     return false;
9672   }
9673 
9674   private boolean jj_3R_265() {
9675     if (jj_3R_134()) return true;
9676     return false;
9677   }
9678 
9679   private boolean jj_3R_264() {
9680     if (jj_scan_token(SUPER)) return true;
9681     return false;
9682   }
9683 
9684   private boolean jj_3R_263() {
9685     if (jj_scan_token(THIS)) return true;
9686     return false;
9687   }
9688 
9689   private boolean jj_3R_173() {
9690     Token xsp;
9691     xsp = jj_scanpos;
9692     if (jj_3R_262()) {
9693     jj_scanpos = xsp;
9694     if (jj_3R_263()) {
9695     jj_scanpos = xsp;
9696     if (jj_3R_264()) {
9697     jj_scanpos = xsp;
9698     if (jj_3R_265()) {
9699     jj_scanpos = xsp;
9700     if (jj_3R_266()) {
9701     jj_scanpos = xsp;
9702     if (jj_3R_267()) {
9703     jj_scanpos = xsp;
9704     if (jj_3R_268()) {
9705     jj_scanpos = xsp;
9706     if (jj_3_46()) {
9707     jj_scanpos = xsp;
9708     if (jj_3R_269()) {
9709     jj_scanpos = xsp;
9710     if (jj_3R_270()) {
9711     jj_scanpos = xsp;
9712     if (jj_3R_271()) {
9713     jj_scanpos = xsp;
9714     if (jj_3R_272()) {
9715     jj_scanpos = xsp;
9716     if (jj_3R_273()) return true;
9717     }
9718     }
9719     }
9720     }
9721     }
9722     }
9723     }
9724     }
9725     }
9726     }
9727     }
9728     }
9729     return false;
9730   }
9731 
9732   private boolean jj_3R_212() {
9733     if (jj_scan_token(NEW)) return true;
9734     return false;
9735   }
9736 
9737   private boolean jj_3R_262() {
9738     if (jj_3R_321()) return true;
9739     return false;
9740   }
9741 
9742   private boolean jj_3R_120() {
9743     if (jj_scan_token(MINUS)) return true;
9744     return false;
9745   }
9746 
9747   private boolean jj_3_41() {
9748     if (jj_3R_129()) return true;
9749     return false;
9750   }
9751 
9752   private boolean jj_3R_123() {
9753     if (jj_scan_token(SLASH)) return true;
9754     return false;
9755   }
9756 
9757   private boolean jj_3R_137() {
9758     if (jj_scan_token(METHOD_REF)) return true;
9759     Token xsp;
9760     xsp = jj_scanpos;
9761     if (jj_3R_212()) {
9762     jj_scanpos = xsp;
9763     if (jj_3R_213()) return true;
9764     }
9765     return false;
9766   }
9767 
9768   private boolean jj_3R_343() {
9769     if (jj_scan_token(BANG)) return true;
9770     return false;
9771   }
9772 
9773   private boolean jj_3R_216() {
9774     if (jj_3R_137()) return true;
9775     return false;
9776   }
9777 
9778   private boolean jj_3R_361() {
9779     if (jj_scan_token(INCR)) return true;
9780     return false;
9781   }
9782 
9783   private boolean jj_3R_354() {
9784     Token xsp;
9785     xsp = jj_scanpos;
9786     if (jj_3R_361()) {
9787     jj_scanpos = xsp;
9788     if (jj_3R_362()) return true;
9789     }
9790     return false;
9791   }
9792 
9793   private boolean jj_3R_128() {
9794     if (jj_3R_154()) return true;
9795     return false;
9796   }
9797 
9798   private boolean jj_3R_141() {
9799     Token xsp;
9800     xsp = jj_scanpos;
9801     if (jj_3R_215()) {
9802     jj_scanpos = xsp;
9803     if (jj_3R_216()) return true;
9804     }
9805     return false;
9806   }
9807 
9808   private boolean jj_3R_215() {
9809     if (jj_scan_token(DOT)) return true;
9810     if (jj_3R_97()) return true;
9811     if (jj_scan_token(IDENTIFIER)) return true;
9812     return false;
9813   }
9814 
9815   private boolean jj_3R_127() {
9816     if (jj_3R_154()) return true;
9817     return false;
9818   }
9819 
9820   private boolean jj_3_40() {
9821     if (jj_scan_token(LPAREN)) return true;
9822     Token xsp;
9823     while (true) {
9824       xsp = jj_scanpos;
9825       if (jj_3R_128()) { jj_scanpos = xsp; break; }
9826     }
9827     if (jj_3R_90()) return true;
9828     if (jj_scan_token(BIT_AND)) return true;
9829     return false;
9830   }
9831 
9832   private boolean jj_3_39() {
9833     if (jj_scan_token(LPAREN)) return true;
9834     Token xsp;
9835     while (true) {
9836       xsp = jj_scanpos;
9837       if (jj_3R_127()) { jj_scanpos = xsp; break; }
9838     }
9839     if (jj_3R_90()) return true;
9840     if (jj_scan_token(RPAREN)) return true;
9841     return false;
9842   }
9843 
9844   private boolean jj_3R_95() {
9845     if (jj_3R_173()) return true;
9846     Token xsp;
9847     while (true) {
9848       xsp = jj_scanpos;
9849       if (jj_3_41()) { jj_scanpos = xsp; break; }
9850     }
9851     return false;
9852   }
9853 
9854   private boolean jj_3R_287() {
9855     if (jj_3R_154()) return true;
9856     return false;
9857   }
9858 
9859   private boolean jj_3R_202() {
9860     if (jj_scan_token(LPAREN)) return true;
9861     Token xsp;
9862     while (true) {
9863       xsp = jj_scanpos;
9864       if (jj_3R_287()) { jj_scanpos = xsp; break; }
9865     }
9866     if (jj_3R_90()) return true;
9867     if (jj_scan_token(RPAREN)) return true;
9868     if (jj_3R_283()) return true;
9869     return false;
9870   }
9871 
9872   private boolean jj_3R_201() {
9873     if (jj_scan_token(LPAREN)) return true;
9874     Token xsp;
9875     while (true) {
9876       xsp = jj_scanpos;
9877       if (jj_3R_285()) { jj_scanpos = xsp; break; }
9878     }
9879     if (jj_3R_90()) return true;
9880     if (jj_3R_286()) return true;
9881     while (true) {
9882       xsp = jj_scanpos;
9883       if (jj_3R_286()) { jj_scanpos = xsp; break; }
9884     }
9885     if (jj_scan_token(RPAREN)) return true;
9886     if (jj_3R_283()) return true;
9887     return false;
9888   }
9889 
9890   private boolean jj_3R_126() {
9891     Token xsp;
9892     xsp = jj_scanpos;
9893     if (jj_3R_200()) {
9894     jj_scanpos = xsp;
9895     if (jj_3R_201()) {
9896     jj_scanpos = xsp;
9897     if (jj_3R_202()) return true;
9898     }
9899     }
9900     return false;
9901   }
9902 
9903   private boolean jj_3R_200() {
9904     if (jj_scan_token(LPAREN)) return true;
9905     Token xsp;
9906     while (true) {
9907       xsp = jj_scanpos;
9908       if (jj_3R_284()) { jj_scanpos = xsp; break; }
9909     }
9910     if (jj_3R_90()) return true;
9911     if (jj_scan_token(RPAREN)) return true;
9912     if (jj_3R_125()) return true;
9913     return false;
9914   }
9915 
9916   private boolean jj_3_38() {
9917     if (jj_3R_126()) return true;
9918     return false;
9919   }
9920 
9921   private boolean jj_3R_119() {
9922     if (jj_scan_token(PLUS)) return true;
9923     return false;
9924   }
9925 
9926   private boolean jj_3R_280() {
9927     if (jj_scan_token(MINUS)) return true;
9928     return false;
9929   }
9930 
9931   private boolean jj_3R_344() {
9932     if (jj_3R_95()) return true;
9933     Token xsp;
9934     xsp = jj_scanpos;
9935     if (jj_3R_354()) jj_scanpos = xsp;
9936     return false;
9937   }
9938 
9939   private boolean jj_3R_122() {
9940     if (jj_scan_token(STAR)) return true;
9941     return false;
9942   }
9943 
9944   private boolean jj_3R_108() {
9945     if (jj_scan_token(NE)) return true;
9946     return false;
9947   }
9948 
9949   private boolean jj_3R_325() {
9950     if (jj_3R_344()) return true;
9951     return false;
9952   }
9953 
9954   private boolean jj_3R_342() {
9955     if (jj_scan_token(TILDE)) return true;
9956     return false;
9957   }
9958 
9959   private boolean jj_3R_324() {
9960     if (jj_3R_126()) return true;
9961     return false;
9962   }
9963 
9964   private boolean jj_3R_323() {
9965     Token xsp;
9966     xsp = jj_scanpos;
9967     if (jj_3R_342()) {
9968     jj_scanpos = xsp;
9969     if (jj_3R_343()) return true;
9970     }
9971     if (jj_3R_125()) return true;
9972     return false;
9973   }
9974 
9975   private boolean jj_3R_283() {
9976     Token xsp;
9977     xsp = jj_scanpos;
9978     if (jj_3R_323()) {
9979     jj_scanpos = xsp;
9980     if (jj_3R_324()) {
9981     jj_scanpos = xsp;
9982     if (jj_3R_325()) return true;
9983     }
9984     }
9985     return false;
9986   }
9987 
9988   private boolean jj_3_36() {
9989     Token xsp;
9990     xsp = jj_scanpos;
9991     if (jj_3R_119()) {
9992     jj_scanpos = xsp;
9993     if (jj_3R_120()) return true;
9994     }
9995     if (jj_3R_121()) return true;
9996     return false;
9997   }
9998 
9999   private boolean jj_3R_282() {
10000     if (jj_scan_token(DECR)) return true;
10001     if (jj_3R_95()) return true;
10002     return false;
10003   }
10004 
10005   private boolean jj_3_37() {
10006     Token xsp;
10007     xsp = jj_scanpos;
10008     if (jj_3R_122()) {
10009     jj_scanpos = xsp;
10010     if (jj_3R_123()) {
10011     jj_scanpos = xsp;
10012     if (jj_3R_124()) return true;
10013     }
10014     }
10015     if (jj_3R_125()) return true;
10016     return false;
10017   }
10018 
10019   private boolean jj_3R_281() {
10020     if (jj_scan_token(INCR)) return true;
10021     if (jj_3R_95()) return true;
10022     return false;
10023   }
10024 
10025   private boolean jj_3R_199() {
10026     if (jj_3R_283()) return true;
10027     return false;
10028   }
10029 
10030   private boolean jj_3R_198() {
10031     if (jj_3R_282()) return true;
10032     return false;
10033   }
10034 
10035   private boolean jj_3R_197() {
10036     if (jj_3R_281()) return true;
10037     return false;
10038   }
10039 
10040   private boolean jj_3R_279() {
10041     if (jj_scan_token(PLUS)) return true;
10042     return false;
10043   }
10044 
10045   private boolean jj_3R_125() {
10046     Token xsp;
10047     xsp = jj_scanpos;
10048     if (jj_3R_196()) {
10049     jj_scanpos = xsp;
10050     if (jj_3R_197()) {
10051     jj_scanpos = xsp;
10052     if (jj_3R_198()) {
10053     jj_scanpos = xsp;
10054     if (jj_3R_199()) return true;
10055     }
10056     }
10057     }
10058     return false;
10059   }
10060 
10061   private boolean jj_3R_196() {
10062     Token xsp;
10063     xsp = jj_scanpos;
10064     if (jj_3R_279()) {
10065     jj_scanpos = xsp;
10066     if (jj_3R_280()) return true;
10067     }
10068     if (jj_3R_125()) return true;
10069     return false;
10070   }
10071 
10072   private boolean jj_3R_121() {
10073     if (jj_3R_125()) return true;
10074     Token xsp;
10075     while (true) {
10076       xsp = jj_scanpos;
10077       if (jj_3_37()) { jj_scanpos = xsp; break; }
10078     }
10079     return false;
10080   }
10081 
10082   private boolean jj_3R_107() {
10083     if (jj_scan_token(EQ)) return true;
10084     return false;
10085   }
10086 
10087   private boolean jj_3R_116() {
10088     if (jj_3R_121()) return true;
10089     Token xsp;
10090     while (true) {
10091       xsp = jj_scanpos;
10092       if (jj_3_36()) { jj_scanpos = xsp; break; }
10093     }
10094     return false;
10095   }
10096 
10097   private boolean jj_3_35() {
10098     if (jj_3R_118()) return true;
10099     return false;
10100   }
10101 
10102   private boolean jj_3_34() {
10103     if (jj_3R_117()) return true;
10104     return false;
10105   }
10106 
10107   private boolean jj_3_31() {
10108     if (jj_scan_token(INSTANCEOF)) return true;
10109     if (jj_3R_90()) return true;
10110     return false;
10111   }
10112 
10113   private boolean jj_3R_115() {
10114     if (jj_scan_token(LSHIFT)) return true;
10115     return false;
10116   }
10117 
10118   private boolean jj_3_33() {
10119     Token xsp;
10120     xsp = jj_scanpos;
10121     if (jj_3R_115()) {
10122     jj_scanpos = xsp;
10123     if (jj_3_34()) {
10124     jj_scanpos = xsp;
10125     if (jj_3_35()) return true;
10126     }
10127     }
10128     if (jj_3R_116()) return true;
10129     return false;
10130   }
10131 
10132   private boolean jj_3_30() {
10133     Token xsp;
10134     xsp = jj_scanpos;
10135     if (jj_3R_107()) {
10136     jj_scanpos = xsp;
10137     if (jj_3R_108()) return true;
10138     }
10139     if (jj_3R_109()) return true;
10140     return false;
10141   }
10142 
10143   private boolean jj_3R_114() {
10144     if (jj_3R_116()) return true;
10145     Token xsp;
10146     while (true) {
10147       xsp = jj_scanpos;
10148       if (jj_3_33()) { jj_scanpos = xsp; break; }
10149     }
10150     return false;
10151   }
10152 
10153   private boolean jj_3R_113() {
10154     if (jj_scan_token(GE)) return true;
10155     return false;
10156   }
10157 
10158   private boolean jj_3R_112() {
10159     if (jj_scan_token(LE)) return true;
10160     return false;
10161   }
10162 
10163   private boolean jj_3R_111() {
10164     if (jj_scan_token(GT)) return true;
10165     return false;
10166   }
10167 
10168   private boolean jj_3R_110() {
10169     if (jj_scan_token(LT)) return true;
10170     return false;
10171   }
10172 
10173   private boolean jj_3_29() {
10174     if (jj_scan_token(BIT_AND)) return true;
10175     if (jj_3R_106()) return true;
10176     return false;
10177   }
10178 
10179   private boolean jj_3_32() {
10180     Token xsp;
10181     xsp = jj_scanpos;
10182     if (jj_3R_110()) {
10183     jj_scanpos = xsp;
10184     if (jj_3R_111()) {
10185     jj_scanpos = xsp;
10186     if (jj_3R_112()) {
10187     jj_scanpos = xsp;
10188     if (jj_3R_113()) return true;
10189     }
10190     }
10191     }
10192     if (jj_3R_114()) return true;
10193     return false;
10194   }
10195 
10196   private boolean jj_3R_193() {
10197     if (jj_3R_114()) return true;
10198     Token xsp;
10199     while (true) {
10200       xsp = jj_scanpos;
10201       if (jj_3_32()) { jj_scanpos = xsp; break; }
10202     }
10203     return false;
10204   }
10205 
10206   private boolean jj_3_27() {
10207     if (jj_scan_token(BIT_OR)) return true;
10208     if (jj_3R_104()) return true;
10209     return false;
10210   }
10211 
10212   private boolean jj_3_28() {
10213     if (jj_scan_token(XOR)) return true;
10214     if (jj_3R_105()) return true;
10215     return false;
10216   }
10217 
10218   private boolean jj_3R_109() {
10219     if (jj_3R_193()) return true;
10220     Token xsp;
10221     xsp = jj_scanpos;
10222     if (jj_3_31()) jj_scanpos = xsp;
10223     return false;
10224   }
10225 
10226   private boolean jj_3_26() {
10227     if (jj_scan_token(SC_AND)) return true;
10228     if (jj_3R_103()) return true;
10229     return false;
10230   }
10231 
10232   private boolean jj_3R_106() {
10233     if (jj_3R_109()) return true;
10234     Token xsp;
10235     while (true) {
10236       xsp = jj_scanpos;
10237       if (jj_3_30()) { jj_scanpos = xsp; break; }
10238     }
10239     return false;
10240   }
10241 
10242   private boolean jj_3_25() {
10243     if (jj_scan_token(SC_OR)) return true;
10244     if (jj_3R_102()) return true;
10245     return false;
10246   }
10247 
10248   private boolean jj_3R_105() {
10249     if (jj_3R_106()) return true;
10250     Token xsp;
10251     while (true) {
10252       xsp = jj_scanpos;
10253       if (jj_3_29()) { jj_scanpos = xsp; break; }
10254     }
10255     return false;
10256   }
10257 
10258   private boolean jj_3_24() {
10259     if (jj_scan_token(HOOK)) return true;
10260     if (jj_3R_101()) return true;
10261     if (jj_scan_token(COLON)) return true;
10262     if (jj_3R_192()) return true;
10263     return false;
10264   }
10265 
10266   private boolean jj_3R_104() {
10267     if (jj_3R_105()) return true;
10268     Token xsp;
10269     while (true) {
10270       xsp = jj_scanpos;
10271       if (jj_3_28()) { jj_scanpos = xsp; break; }
10272     }
10273     return false;
10274   }
10275 
10276   private boolean jj_3R_103() {
10277     if (jj_3R_104()) return true;
10278     Token xsp;
10279     while (true) {
10280       xsp = jj_scanpos;
10281       if (jj_3_27()) { jj_scanpos = xsp; break; }
10282     }
10283     return false;
10284   }
10285 
10286   private boolean jj_3R_102() {
10287     if (jj_3R_103()) return true;
10288     Token xsp;
10289     while (true) {
10290       xsp = jj_scanpos;
10291       if (jj_3_26()) { jj_scanpos = xsp; break; }
10292     }
10293     return false;
10294   }
10295 
10296   private boolean jj_3R_278() {
10297     if (jj_3R_102()) return true;
10298     Token xsp;
10299     while (true) {
10300       xsp = jj_scanpos;
10301       if (jj_3_25()) { jj_scanpos = xsp; break; }
10302     }
10303     return false;
10304   }
10305 
10306   private boolean jj_3R_192() {
10307     if (jj_3R_278()) return true;
10308     Token xsp;
10309     xsp = jj_scanpos;
10310     if (jj_3_24()) jj_scanpos = xsp;
10311     return false;
10312   }
10313 
10314   private boolean jj_3R_191() {
10315     if (jj_scan_token(ORASSIGN)) return true;
10316     return false;
10317   }
10318 
10319   private boolean jj_3R_190() {
10320     if (jj_scan_token(XORASSIGN)) return true;
10321     return false;
10322   }
10323 
10324   private boolean jj_3R_189() {
10325     if (jj_scan_token(ANDASSIGN)) return true;
10326     return false;
10327   }
10328 
10329   private boolean jj_3R_188() {
10330     if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
10331     return false;
10332   }
10333 
10334   private boolean jj_3R_187() {
10335     if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
10336     return false;
10337   }
10338 
10339   private boolean jj_3R_186() {
10340     if (jj_scan_token(LSHIFTASSIGN)) return true;
10341     return false;
10342   }
10343 
10344   private boolean jj_3R_185() {
10345     if (jj_scan_token(MINUSASSIGN)) return true;
10346     return false;
10347   }
10348 
10349   private boolean jj_3R_184() {
10350     if (jj_scan_token(PLUSASSIGN)) return true;
10351     return false;
10352   }
10353 
10354   private boolean jj_3R_183() {
10355     if (jj_scan_token(REMASSIGN)) return true;
10356     return false;
10357   }
10358 
10359   private boolean jj_3R_182() {
10360     if (jj_scan_token(SLASHASSIGN)) return true;
10361     return false;
10362   }
10363 
10364   private boolean jj_3R_181() {
10365     if (jj_scan_token(STARASSIGN)) return true;
10366     return false;
10367   }
10368 
10369   private boolean jj_3R_100() {
10370     Token xsp;
10371     xsp = jj_scanpos;
10372     if (jj_3R_180()) {
10373     jj_scanpos = xsp;
10374     if (jj_3R_181()) {
10375     jj_scanpos = xsp;
10376     if (jj_3R_182()) {
10377     jj_scanpos = xsp;
10378     if (jj_3R_183()) {
10379     jj_scanpos = xsp;
10380     if (jj_3R_184()) {
10381     jj_scanpos = xsp;
10382     if (jj_3R_185()) {
10383     jj_scanpos = xsp;
10384     if (jj_3R_186()) {
10385     jj_scanpos = xsp;
10386     if (jj_3R_187()) {
10387     jj_scanpos = xsp;
10388     if (jj_3R_188()) {
10389     jj_scanpos = xsp;
10390     if (jj_3R_189()) {
10391     jj_scanpos = xsp;
10392     if (jj_3R_190()) {
10393     jj_scanpos = xsp;
10394     if (jj_3R_191()) return true;
10395     }
10396     }
10397     }
10398     }
10399     }
10400     }
10401     }
10402     }
10403     }
10404     }
10405     }
10406     return false;
10407   }
10408 
10409   private boolean jj_3R_180() {
10410     if (jj_scan_token(ASSIGN)) return true;
10411     return false;
10412   }
10413 
10414   private boolean jj_3_23() {
10415     if (jj_3R_100()) return true;
10416     if (jj_3R_101()) return true;
10417     return false;
10418   }
10419 
10420   private boolean jj_3R_101() {
10421     if (jj_3R_192()) return true;
10422     Token xsp;
10423     xsp = jj_scanpos;
10424     if (jj_3_23()) jj_scanpos = xsp;
10425     return false;
10426   }
10427 
10428   private boolean jj_3R_437() {
10429     if (jj_3R_154()) return true;
10430     return false;
10431   }
10432 
10433   private boolean jj_3R_433() {
10434     if (jj_scan_token(COMMA)) return true;
10435     Token xsp;
10436     while (true) {
10437       xsp = jj_scanpos;
10438       if (jj_3R_437()) { jj_scanpos = xsp; break; }
10439     }
10440     if (jj_3R_136()) return true;
10441     return false;
10442   }
10443 
10444   private boolean jj_3R_432() {
10445     if (jj_3R_154()) return true;
10446     return false;
10447   }
10448 
10449   private boolean jj_3R_426() {
10450     Token xsp;
10451     while (true) {
10452       xsp = jj_scanpos;
10453       if (jj_3R_432()) { jj_scanpos = xsp; break; }
10454     }
10455     if (jj_3R_136()) return true;
10456     while (true) {
10457       xsp = jj_scanpos;
10458       if (jj_3R_433()) { jj_scanpos = xsp; break; }
10459     }
10460     return false;
10461   }
10462 
10463   private boolean jj_3_20() {
10464     if (jj_3R_97()) return true;
10465     return false;
10466   }
10467 
10468   private boolean jj_3_22() {
10469     if (jj_scan_token(DOT)) return true;
10470     if (jj_scan_token(IDENTIFIER)) return true;
10471     return false;
10472   }
10473 
10474   private boolean jj_3R_275() {
10475     if (jj_scan_token(COMMA)) return true;
10476     if (jj_3R_99()) return true;
10477     return false;
10478   }
10479 
10480   private boolean jj_3R_136() {
10481     if (jj_scan_token(IDENTIFIER)) return true;
10482     Token xsp;
10483     while (true) {
10484       xsp = jj_scanpos;
10485       if (jj_3_22()) { jj_scanpos = xsp; break; }
10486     }
10487     return false;
10488   }
10489 
10490   private boolean jj_3R_211() {
10491     if (jj_3R_90()) return true;
10492     return false;
10493   }
10494 
10495   private boolean jj_3R_135() {
10496     Token xsp;
10497     xsp = jj_scanpos;
10498     if (jj_scan_token(59)) {
10499     jj_scanpos = xsp;
10500     if (jj_3R_211()) return true;
10501     }
10502     return false;
10503   }
10504 
10505   private boolean jj_3R_224() {
10506     if (jj_scan_token(DOUBLE)) return true;
10507     return false;
10508   }
10509 
10510   private boolean jj_3R_223() {
10511     if (jj_scan_token(FLOAT)) return true;
10512     return false;
10513   }
10514 
10515   private boolean jj_3R_222() {
10516     if (jj_scan_token(LONG)) return true;
10517     return false;
10518   }
10519 
10520   private boolean jj_3R_366() {
10521     if (jj_3R_154()) return true;
10522     return false;
10523   }
10524 
10525   private boolean jj_3R_365() {
10526     if (jj_3R_154()) return true;
10527     return false;
10528   }
10529 
10530   private boolean jj_3R_221() {
10531     if (jj_scan_token(INT)) return true;
10532     return false;
10533   }
10534 
10535   private boolean jj_3R_220() {
10536     if (jj_scan_token(SHORT)) return true;
10537     return false;
10538   }
10539 
10540   /** Generated Token Manager. */
10541   public JavaParserTokenManager token_source;
10542   /** Current token. */
10543   public Token token;
10544   /** Next token. */
10545   public Token jj_nt;
10546   private Token jj_scanpos, jj_lastpos;
10547   private int jj_la;
10548   /** Whether we are looking ahead. */
10549   private boolean jj_lookingAhead = false;
10550   private boolean jj_semLA;
10551   private int jj_gen;
10552   final private int[] jj_la1 = new int[151];
10553   static private int[] jj_la1_0;
10554   static private int[] jj_la1_1;
10555   static private int[] jj_la1_2;
10556   static private int[] jj_la1_3;
10557   static {
10558       jj_la1_init_0();
10559       jj_la1_init_1();
10560       jj_la1_init_2();
10561       jj_la1_init_3();
10562    }
10563    private static void jj_la1_init_0() {
10564       jj_la1_0 = new int[] {0x0,0x10481000,0x0,0x0,0x0,0x0,0x0,0x10401000,0x10081000,0x10481000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x514cb000,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x514cb000,0x4104a000,0x514cb000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,0x0,0x0,0x4000000,0x4104a000,0x0,0x0,0x4000000,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x4904a000,0x4904a000,0x0,0x4904a000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x5904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x0,0x20000,0x20000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4904a000,0x514cb000,0x10081000,0x4104a000,0x514cb000,0x400000,};
10565    }
10566    private static void jj_la1_init_1() {
10567       jj_la1_1 = new int[] {0x8,0x51127140,0x0,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x591371e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x591371e0,0x80100a0,0x591371e0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,0x0,0x0,0x40000,0x100a0,0x0,0x0,0x40000,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x82240400,0x200,0x0,0x8a2506a0,0x8a2506a0,0x0,0x8a2506a0,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xae7d86a2,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x8a2506a0,0x511371e0,0x40,0x100a0,0x511371e0,0x0,};
10568    }
10569    private static void jj_la1_init_2() {
10570       jj_la1_2 = new int[] {0x0,0x240200,0x0,0x0,0x200000,0x0,0x100000,0x200000,0x200200,0x240200,0x0,0x0,0x0,0x800000,0x0,0x0,0x200000,0x80000,0x200000,0x200000,0x80000,0x200000,0x0,0x200000,0x200000,0x200200,0x80000,0xa44200,0x40000,0x1000,0x4000,0x80000,0x200000,0x0,0x0,0xa44200,0xa00200,0xa40200,0x80000,0x400000,0x10000,0x30053b0,0x30053b0,0x80000,0x800000,0x0,0x44000,0x10000,0x80000,0x200200,0x200000,0x200000,0x0,0x0,0x800000,0x0,0x800000,0x8013b0,0x0,0x0,0x200,0x80000,0x800000,0x200000,0x0,0x4200200,0x200000,0x200000,0x0,0x0,0x200,0x200000,0x80000,0x200000,0x400000,0x90000000,0x60800000,0x0,0x0,0x0,0x0,0x30013b0,0x3000000,0x3000000,0x13b0,0x0,0x0,0x200000,0x200000,0x0,0x200000,0x1000,0x100000,0x200,0x1b0,0x0,0x200,0x30053b0,0x30053b0,0x80000,0x30053b0,0x200,0x111000,0x1b0,0x0,0x30013b0,0x80000,0x200000,0x800000,0x4000,0x11000,0x200,0x10000,0x10000,0x453b0,0x200000,0x200000,0x200000,0x80000,0x400000,0x0,0x13b0,0x0,0x0,0x0,0x2013b0,0x30013b0,0x13b0,0x2413b0,0x13b0,0x80000,0x200,0x200,0x30013b0,0x1000,0x0,0x0,0x200000,0x200000,0x8000000,0x200000,0x200,0x80000,0x32053b0,0x80000,0x32053b0,0x240200,0x0,0x200200,0x240200,0x0,};
10571    }
10572    private static void jj_la1_init_3() {
10573       jj_la1_3 = new int[] {0x0,0x0,0x40000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe000,0x0,0x20000000,0x1000,0x30,0x8c0,0x30,0x3c,0x0,0x0,0x0,0xc,0xc,0x0,0x0,0x100,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x3c,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0xffe000,0xc,0x0,0x0,0x0,0x0,0xc,0x3c,0xc,0xc,0xc,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,};
10574    }
10575   final private JJCalls[] jj_2_rtns = new JJCalls[75];
10576   private boolean jj_rescan = false;
10577   private int jj_gc = 0;
10578 
10579   /** Constructor with user supplied CharStream. */
10580   public JavaParser(CharStream stream) {
10581     token_source = new JavaParserTokenManager(stream);
10582     token = new Token();
10583     token.next = jj_nt = token_source.getNextToken();
10584     jj_gen = 0;
10585     for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10586     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10587   }
10588 
10589   /** Reinitialise. */
10590   public void ReInit(CharStream stream) {
10591     token_source.ReInit(stream);
10592     token = new Token();
10593     token.next = jj_nt = token_source.getNextToken();
10594     jj_lookingAhead = false;
10595     jjtree.reset();
10596     jj_gen = 0;
10597     for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10598     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10599   }
10600 
10601   /** Constructor with generated Token Manager. */
10602   public JavaParser(JavaParserTokenManager tm) {
10603     token_source = tm;
10604     token = new Token();
10605     token.next = jj_nt = token_source.getNextToken();
10606     jj_gen = 0;
10607     for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10608     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10609   }
10610 
10611   /** Reinitialise. */
10612   public void ReInit(JavaParserTokenManager tm) {
10613     token_source = tm;
10614     token = new Token();
10615     token.next = jj_nt = token_source.getNextToken();
10616     jjtree.reset();
10617     jj_gen = 0;
10618     for (int i = 0; i < 151; i++) jj_la1[i] = -1;
10619     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
10620   }
10621 
10622   private Token jj_consume_token(int kind) throws ParseException {
10623     Token oldToken = token;
10624     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
10625     else jj_nt = jj_nt.next = token_source.getNextToken();
10626     if (token.kind == kind) {
10627       jj_gen++;
10628       if (++jj_gc > 100) {
10629         jj_gc = 0;
10630         for (int i = 0; i < jj_2_rtns.length; i++) {
10631           JJCalls c = jj_2_rtns[i];
10632           while (c != null) {
10633             if (c.gen < jj_gen) c.first = null;
10634             c = c.next;
10635           }
10636         }
10637       }
10638       return token;
10639     }
10640     jj_nt = token;
10641     token = oldToken;
10642     jj_kind = kind;
10643     throw generateParseException();
10644   }
10645 
10646   static private final class LookaheadSuccess extends java.lang.Error { }
10647   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
10648   private boolean jj_scan_token(int kind) {
10649     if (jj_scanpos == jj_lastpos) {
10650       jj_la--;
10651       if (jj_scanpos.next == null) {
10652         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
10653       } else {
10654         jj_lastpos = jj_scanpos = jj_scanpos.next;
10655       }
10656     } else {
10657       jj_scanpos = jj_scanpos.next;
10658     }
10659     if (jj_rescan) {
10660       int i = 0; Token tok = token;
10661       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
10662       if (tok != null) jj_add_error_token(kind, i);
10663     }
10664     if (jj_scanpos.kind != kind) return true;
10665     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
10666     return false;
10667   }
10668 
10669 
10670 /** Get the next Token. */
10671   final public Token getNextToken() {
10672     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
10673     else jj_nt = jj_nt.next = token_source.getNextToken();
10674     jj_gen++;
10675     return token;
10676   }
10677 
10678 /** Get the specific Token. */
10679   final public Token getToken(int index) {
10680     Token t = jj_lookingAhead ? jj_scanpos : token;
10681     for (int i = 0; i < index; i++) {
10682       if (t.next != null) t = t.next;
10683       else t = t.next = token_source.getNextToken();
10684     }
10685     return t;
10686   }
10687 
10688   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
10689   private int[] jj_expentry;
10690   private int jj_kind = -1;
10691   private int[] jj_lasttokens = new int[100];
10692   private int jj_endpos;
10693 
10694   private void jj_add_error_token(int kind, int pos) {
10695     if (pos >= 100) return;
10696     if (pos == jj_endpos + 1) {
10697       jj_lasttokens[jj_endpos++] = kind;
10698     } else if (jj_endpos != 0) {
10699       jj_expentry = new int[jj_endpos];
10700       for (int i = 0; i < jj_endpos; i++) {
10701         jj_expentry[i] = jj_lasttokens[i];
10702       }
10703       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
10704         int[] oldentry = (int[])(it.next());
10705         if (oldentry.length == jj_expentry.length) {
10706           for (int i = 0; i < jj_expentry.length; i++) {
10707             if (oldentry[i] != jj_expentry[i]) {
10708               continue jj_entries_loop;
10709             }
10710           }
10711           jj_expentries.add(jj_expentry);
10712           break jj_entries_loop;
10713         }
10714       }
10715       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
10716     }
10717   }
10718 
10719   /** Generate ParseException. */
10720   public ParseException generateParseException() {
10721     jj_expentries.clear();
10722     boolean[] la1tokens = new boolean[128];
10723     if (jj_kind >= 0) {
10724       la1tokens[jj_kind] = true;
10725       jj_kind = -1;
10726     }
10727     for (int i = 0; i < 151; i++) {
10728       if (jj_la1[i] == jj_gen) {
10729         for (int j = 0; j < 32; j++) {
10730           if ((jj_la1_0[i] & (1<<j)) != 0) {
10731             la1tokens[j] = true;
10732           }
10733           if ((jj_la1_1[i] & (1<<j)) != 0) {
10734             la1tokens[32+j] = true;
10735           }
10736           if ((jj_la1_2[i] & (1<<j)) != 0) {
10737             la1tokens[64+j] = true;
10738           }
10739           if ((jj_la1_3[i] & (1<<j)) != 0) {
10740             la1tokens[96+j] = true;
10741           }
10742         }
10743       }
10744     }
10745     for (int i = 0; i < 128; i++) {
10746       if (la1tokens[i]) {
10747         jj_expentry = new int[1];
10748         jj_expentry[0] = i;
10749         jj_expentries.add(jj_expentry);
10750       }
10751     }
10752     jj_endpos = 0;
10753     jj_rescan_token();
10754     jj_add_error_token(0, 0);
10755     int[][] exptokseq = new int[jj_expentries.size()][];
10756     for (int i = 0; i < jj_expentries.size(); i++) {
10757       exptokseq[i] = jj_expentries.get(i);
10758     }
10759     return new ParseException(token, exptokseq, tokenImage);
10760   }
10761 
10762   /** Enable tracing. */
10763   final public void enable_tracing() {
10764   }
10765 
10766   /** Disable tracing. */
10767   final public void disable_tracing() {
10768   }
10769 
10770   private void jj_rescan_token() {
10771     jj_rescan = true;
10772     for (int i = 0; i < 75; i++) {
10773     try {
10774       JJCalls p = jj_2_rtns[i];
10775       do {
10776         if (p.gen > jj_gen) {
10777           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
10778           switch (i) {
10779             case 0: jj_3_1(); break;
10780             case 1: jj_3_2(); break;
10781             case 2: jj_3_3(); break;
10782             case 3: jj_3_4(); break;
10783             case 4: jj_3_5(); break;
10784             case 5: jj_3_6(); break;
10785             case 6: jj_3_7(); break;
10786             case 7: jj_3_8(); break;
10787             case 8: jj_3_9(); break;
10788             case 9: jj_3_10(); break;
10789             case 10: jj_3_11(); break;
10790             case 11: jj_3_12(); break;
10791             case 12: jj_3_13(); break;
10792             case 13: jj_3_14(); break;
10793             case 14: jj_3_15(); break;
10794             case 15: jj_3_16(); break;
10795             case 16: jj_3_17(); break;
10796             case 17: jj_3_18(); break;
10797             case 18: jj_3_19(); break;
10798             case 19: jj_3_20(); break;
10799             case 20: jj_3_21(); break;
10800             case 21: jj_3_22(); break;
10801             case 22: jj_3_23(); break;
10802             case 23: jj_3_24(); break;
10803             case 24: jj_3_25(); break;
10804             case 25: jj_3_26(); break;
10805             case 26: jj_3_27(); break;
10806             case 27: jj_3_28(); break;
10807             case 28: jj_3_29(); break;
10808             case 29: jj_3_30(); break;
10809             case 30: jj_3_31(); break;
10810             case 31: jj_3_32(); break;
10811             case 32: jj_3_33(); break;
10812             case 33: jj_3_34(); break;
10813             case 34: jj_3_35(); break;
10814             case 35: jj_3_36(); break;
10815             case 36: jj_3_37(); break;
10816             case 37: jj_3_38(); break;
10817             case 38: jj_3_39(); break;
10818             case 39: jj_3_40(); break;
10819             case 40: jj_3_41(); break;
10820             case 41: jj_3_42(); break;
10821             case 42: jj_3_43(); break;
10822             case 43: jj_3_44(); break;
10823             case 44: jj_3_45(); break;
10824             case 45: jj_3_46(); break;
10825             case 46: jj_3_47(); break;
10826             case 47: jj_3_48(); break;
10827             case 48: jj_3_49(); break;
10828             case 49: jj_3_50(); break;
10829             case 50: jj_3_51(); break;
10830             case 51: jj_3_52(); break;
10831             case 52: jj_3_53(); break;
10832             case 53: jj_3_54(); break;
10833             case 54: jj_3_55(); break;
10834             case 55: jj_3_56(); break;
10835             case 56: jj_3_57(); break;
10836             case 57: jj_3_58(); break;
10837             case 58: jj_3_59(); break;
10838             case 59: jj_3_60(); break;
10839             case 60: jj_3_61(); break;
10840             case 61: jj_3_62(); break;
10841             case 62: jj_3_63(); break;
10842             case 63: jj_3_64(); break;
10843             case 64: jj_3_65(); break;
10844             case 65: jj_3_66(); break;
10845             case 66: jj_3_67(); break;
10846             case 67: jj_3_68(); break;
10847             case 68: jj_3_69(); break;
10848             case 69: jj_3_70(); break;
10849             case 70: jj_3_71(); break;
10850             case 71: jj_3_72(); break;
10851             case 72: jj_3_73(); break;
10852             case 73: jj_3_74(); break;
10853             case 74: jj_3_75(); break;
10854           }
10855         }
10856         p = p.next;
10857       } while (p != null);
10858       } catch(LookaheadSuccess ls) { }
10859     }
10860     jj_rescan = false;
10861   }
10862 
10863   private void jj_save(int index, int xla) {
10864     JJCalls p = jj_2_rtns[index];
10865     while (p.gen > jj_gen) {
10866       if (p.next == null) { p = p.next = new JJCalls(); break; }
10867       p = p.next;
10868     }
10869     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
10870   }
10871 
10872   static final class JJCalls {
10873     int gen;
10874     Token first;
10875     int arg;
10876     JJCalls next;
10877   }
10878 
10879 }