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