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