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