View Javadoc

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