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