View Javadoc

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