Source code

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