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