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