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