001/*
002 * Cobertura - http://cobertura.sourceforge.net/
003 *
004 * This file was taken from JavaNCSS
005 * http://www.kclee.com/clemens/java/javancss/
006 * Copyright (C) 2000 Chr. Clemens Lee <clemens a.t kclee d.o.t com>
007 *
008 * Cobertura is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License as published
010 * by the Free Software Foundation; either version 2 of the License,
011 * or (at your option) any later version.
012 *
013 * Cobertura is distributed in the hope that it will be useful, but
014 * WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016 * General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with Cobertura; if not, write to the Free Software
020 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
021 * USA
022 */
023
024
025/*
026 *
027 * WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING  
028 *
029 * WARNING TO COBERTURA DEVELOPERS
030 *
031 * DO NOT MODIFY THIS FILE!
032 *
033 * MODIFY THE FILES UNDER THE JAVANCSS DIRECTORY LOCATED AT THE ROOT OF THE COBERTURA PROJECT.
034 *
035 * FOLLOW THE PROCEDURE FOR MERGING THE LATEST JAVANCSS INTO COBERTURA LOCATED AT
036 * javancss/coberturaREADME.txt
037 *
038 * WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
039 */
040/* Generated By:JavaCC: Do not edit this line. JavaParser15Debug.java */
041package net.sourceforge.cobertura.javancss.parser.java15.debug;
042
043import java.io.*;
044
045import net.sourceforge.cobertura.javancss.parser.JavaParserInterface;
046import java.util.*;
047
048import net.sourceforge.cobertura.javancss.FunctionMetric;
049import net.sourceforge.cobertura.javancss.ObjectMetric;
050import net.sourceforge.cobertura.javancss.PackageMetric;
051
052/**
053 * Grammar to parse Java version 1.5
054 * @author Sreenivasa Viswanadha - Simplified and enhanced for 1.5
055 */
056public class JavaParser15Debug implements JavaParserInterface, JavaParser15DebugConstants {
057    private boolean _bReturn         = false;
058    private int     _ncss            = 0;     // general counter
059    private int     _loc             = 0;
060    private int     _cyc             = 1;
061    private int     _localCases      = 0;
062    private String  _sName           = "";    // name of last token
063    private String  _sParameter      = "";
064    private String  _sPackage        = "";
065    private String  _sClass          = "";
066    private String  _sFunction       = "";
067    private int     _functions       = 0;     // number of functions in this class
068    //private int     _topLevelClasses = 0;
069    private int     _classes         = 0;
070    private int     _classLevel      = 0;
071    private int     _anonClassCount  = 1;
072
073    private int     _jvdcLines = 0;           // added by SMS
074    private int     _jvdc      = 0;
075    private boolean _bPrivate  = true;//false;        // added by SMS
076    private boolean _bPublic   = true;        // added by SMS
077
078    /**
079     * For each class the number of formal
080     * comments in toplevel methods, constructors, inner
081     * classes, and for the class itself are counted.
082     * The top level comment has to be directly before
083     * the class definition, not before the package or
084     * import statement as it is often seen in source code
085     * examples (at the beginning of your source files you
086     * should instead put your copyright notice).
087     */
088    private int    _javadocs   = 0;              // global javadocs
089    private List/*<FunctionMetric>*/ _vFunctions = new ArrayList();   // holds the statistics for each method
090
091    /** 
092     * Metrics for each class/interface are stored in this
093     * vector.
094     */
095    private List/*<ObjectMetric>*/ _vClasses = new ArrayList();
096    private List _vImports = new ArrayList();
097    private Object[] _aoPackage = null;
098    private Map/*<String,PackageMetric>*/ _htPackage = new HashMap();
099    private PackageMetric _pPackageMetric;
100
101    private Token _tmpToken = null;
102    /** Argh, too much of a state machine. */
103    private Token _tmpResultToken = null;
104
105    private String _formatPackage(String sPackage_) {
106        if (sPackage_.equals("")) {
107            return ".";
108        }
109
110        return sPackage_.substring(0, sPackage_.length() - 1);
111    }
112
113
114    public void parse() throws Exception {
115      CompilationUnit();
116    }
117
118    public void parseImportUnit() throws Exception {
119      ImportUnit();
120    }
121
122    public int getNcss() {
123        return _ncss;
124    }
125
126    public int getLOC() {
127        return _loc;
128    }
129
130    // added by SMS
131    public int getJvdc() {
132        return _jvdc;
133    }
134
135    /*public int getTopLevelClasses() {
136      return _topLevelClasses;
137      }*/
138
139    public List/*<FunctionMetric>*/ getFunction() {
140        return _vFunctions;
141    }
142
143    /**
144     * @return Top level classes in sorted order
145     */
146    public List/*<ObjectMetric>*/ getObject() {
147        Collections.sort(_vClasses);
148        return _vClasses;
149    }
150
151    /**
152     * @return The empty package consists of the name ".".
153     */
154    public Map/*<String,PackageMetric>*/ getPackage() {
155        return _htPackage;
156    }
157
158    public List getImports() {
159        return _vImports;
160    }
161
162    /**
163     * name, beginLine, ...
164     */
165    public Object[] getPackageObjects() {
166        return _aoPackage;
167    }
168
169    /**
170     * if javancss is used with cat *.java a long
171     * input stream might get generated, so line
172     * number information in case of an parse exception
173     * is not very useful.
174     */
175    public String getLastFunction() {
176        return _sPackage + _sClass + _sFunction;
177    }
178   /**
179    * Class to hold modifiers.
180    */
181   static public final class ModifierSet
182   {
183     /* Definitions of the bits in the modifiers field.  */
184     public static final int PUBLIC = 0x0001;
185     public static final int PROTECTED = 0x0002;
186     public static final int PRIVATE = 0x0004;
187     public static final int ABSTRACT = 0x0008;
188     public static final int STATIC = 0x0010;
189     public static final int FINAL = 0x0020;
190     public static final int SYNCHRONIZED = 0x0040;
191     public static final int NATIVE = 0x0080;
192     public static final int TRANSIENT = 0x0100;
193     public static final int VOLATILE = 0x0200;
194     public static final int STRICTFP = 0x1000;
195
196     /** A set of accessors that indicate whether the specified modifier
197         is in the set. */
198
199     public boolean isPublic(int modifiers)
200     {
201       return (modifiers & PUBLIC) != 0;
202     }
203
204     public boolean isProtected(int modifiers)
205     {
206       return (modifiers & PROTECTED) != 0;
207     }
208
209     public boolean isPrivate(int modifiers)
210     {
211       return (modifiers & PRIVATE) != 0;
212     }
213
214     public boolean isStatic(int modifiers)
215     {
216       return (modifiers & STATIC) != 0;
217     }
218
219     public boolean isAbstract(int modifiers)
220     {
221       return (modifiers & ABSTRACT) != 0;
222     }
223
224     public boolean isFinal(int modifiers)
225     {
226       return (modifiers & FINAL) != 0;
227     }
228
229     public boolean isNative(int modifiers)
230     {
231       return (modifiers & NATIVE) != 0;
232     }
233
234     public boolean isStrictfp(int modifiers)
235     {
236       return (modifiers & STRICTFP) != 0;
237     }
238
239     public boolean isSynchronized(int modifiers)
240     {
241       return (modifiers & SYNCHRONIZED) != 0;
242     }
243
244     public boolean isTransient(int modifiers)
245      {
246       return (modifiers & TRANSIENT) != 0;
247     }
248
249     public boolean isVolatile(int modifiers)
250     {
251       return (modifiers & VOLATILE) != 0;
252     }
253
254     /**
255      * Removes the given modifier.
256      */
257     static int removeModifier(int modifiers, int mod)
258     {
259        return modifiers & ~mod;
260     }
261   }
262
263   public JavaParser15Debug(String fileName)
264   {
265      this(System.in);
266      try { ReInit(new FileInputStream(new File(fileName))); }
267      catch(Exception e) { e.printStackTrace(); }
268   }
269
270  public static void main(String args[]) {
271    JavaParser15Debug parser;
272    if (args.length == 0) {
273      System.out.println("Java Parser Version 1.5:  Reading from standard input . . .");
274      parser = new JavaParser15Debug(System.in);
275    } else if (args.length == 1) {
276      System.out.println("Java Parser Version 1.5:  Reading from file " + args[0] + " . . .");
277      try {
278        parser = new JavaParser15Debug(new java.io.FileInputStream(args[0]));
279      } catch (java.io.FileNotFoundException e) {
280        System.out.println("Java Parser Version 1.5:  File " + args[0] + " not found.");
281        return;
282      }
283    } else {
284      System.out.println("Java Parser Version 1.5:  Usage is one of:");
285      System.out.println("         java javancss.parser.java15.debug.JavaParser15Debug < inputfile");
286      System.out.println("OR");
287      System.out.println("         java javancss.parser.java15.debug.JavaParser15Debug inputfile");
288      return;
289    }
290    try {
291      parser.CompilationUnit();
292      System.out.println("Java Parser Version 1.1:  Java program parsed successfully.");
293    } catch (ParseException e) {
294      System.out.println(e.getMessage());
295      System.out.println("Java Parser Version 1.1:  Encountered errors during parse.");
296    }
297  }
298
299/*****************************************
300 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
301 *****************************************/
302
303/*
304 * Program structuring syntax follows.
305 */
306  final public void CompilationUnit() throws ParseException {
307    trace_call("CompilationUnit");
308    try {
309      if (jj_2_1(2147483647)) {
310        PackageDeclaration();
311      } else {
312        ;
313      }
314      label_1:
315      while (true) {
316        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
317        case IMPORT:
318          ;
319          break;
320        default:
321          break label_1;
322        }
323        ImportDeclaration();
324      }
325      label_2:
326      while (true) {
327        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
328        case ABSTRACT:
329        case CLASS:
330        case ENUM:
331        case FINAL:
332        case INTERFACE:
333        case NATIVE:
334        case PRIVATE:
335        case PROTECTED:
336        case PUBLIC:
337        case STATIC:
338        case STRICTFP:
339        case SYNCHRONIZED:
340        case TRANSIENT:
341        case VOLATILE:
342        case SEMICOLON:
343        case AT:
344          ;
345          break;
346        default:
347          break label_2;
348        }
349        TypeDeclaration();
350      }
351      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
352      case 127:
353        jj_consume_token(127);
354        break;
355      default:
356        ;
357      }
358      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
359      case STUFF_TO_IGNORE:
360        jj_consume_token(STUFF_TO_IGNORE);
361        break;
362      default:
363        ;
364      }
365      jj_consume_token(0);
366    } finally {
367      trace_return("CompilationUnit");
368    }
369  }
370
371  final public void PackageDeclaration() throws ParseException {
372    trace_call("PackageDeclaration");
373    try {
374      Modifiers();
375      jj_consume_token(PACKAGE);
376      Name();
377      jj_consume_token(SEMICOLON);
378    } finally {
379      trace_return("PackageDeclaration");
380    }
381  }
382
383  final public void ImportUnit() throws ParseException {
384    trace_call("ImportUnit");
385    try {
386      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
387      case ABSTRACT:
388      case FINAL:
389      case NATIVE:
390      case PACKAGE:
391      case PRIVATE:
392      case PROTECTED:
393      case PUBLIC:
394      case STATIC:
395      case STRICTFP:
396      case SYNCHRONIZED:
397      case TRANSIENT:
398      case VOLATILE:
399      case AT:
400        PackageDeclaration();
401        break;
402      default:
403        ;
404      }
405      label_3:
406      while (true) {
407        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
408        case IMPORT:
409          ;
410          break;
411        default:
412          break label_3;
413        }
414        ImportDeclaration();
415      }
416      label_4:
417      while (true) {
418        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
419        case ABSTRACT:
420        case FINAL:
421        case PUBLIC:
422        case STRICTFP:
423        case SYNCHRONIZED:
424          ;
425          break;
426        default:
427          break label_4;
428        }
429        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
430        case ABSTRACT:
431          jj_consume_token(ABSTRACT);
432          break;
433        case FINAL:
434          jj_consume_token(FINAL);
435          break;
436        case PUBLIC:
437          jj_consume_token(PUBLIC);
438          break;
439        case SYNCHRONIZED:
440          jj_consume_token(SYNCHRONIZED);
441          break;
442        case STRICTFP:
443          jj_consume_token(STRICTFP);
444          break;
445        default:
446          jj_consume_token(-1);
447          throw new ParseException();
448        }
449      }
450      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
451      case CLASS:
452        jj_consume_token(CLASS);
453        break;
454      case INTERFACE:
455        jj_consume_token(INTERFACE);
456        break;
457      default:
458        jj_consume_token(-1);
459        throw new ParseException();
460      }
461    } finally {
462      trace_return("ImportUnit");
463    }
464  }
465
466  final public void ImportDeclaration() throws ParseException {
467    trace_call("ImportDeclaration");
468    try {
469      jj_consume_token(IMPORT);
470      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
471      case STATIC:
472        jj_consume_token(STATIC);
473        break;
474      default:
475        ;
476      }
477      Name();
478      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
479      case DOT:
480        jj_consume_token(DOT);
481        jj_consume_token(STAR);
482        break;
483      default:
484        ;
485      }
486      jj_consume_token(SEMICOLON);
487    } finally {
488      trace_return("ImportDeclaration");
489    }
490  }
491
492/*
493 * Modifiers. We match all modifiers in a single rule to reduce the chances of
494 * syntax errors for simple modifier mistakes. It will also enable us to give
495 * better error messages.
496 */
497  final public int Modifiers() throws ParseException {
498    trace_call("Modifiers");
499    try {
500   int modifiers = 0;
501      label_5:
502      while (true) {
503        if (jj_2_2(2)) {
504          ;
505        } else {
506          break label_5;
507        }
508        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
509        case PUBLIC:
510          jj_consume_token(PUBLIC);
511              modifiers |= ModifierSet.PUBLIC;
512          break;
513        case STATIC:
514          jj_consume_token(STATIC);
515              modifiers |= ModifierSet.STATIC;
516          break;
517        case PROTECTED:
518          jj_consume_token(PROTECTED);
519                 modifiers |= ModifierSet.PROTECTED;
520          break;
521        case PRIVATE:
522          jj_consume_token(PRIVATE);
523               modifiers |= ModifierSet.PRIVATE;
524          break;
525        case FINAL:
526          jj_consume_token(FINAL);
527             modifiers |= ModifierSet.FINAL;
528          break;
529        case ABSTRACT:
530          jj_consume_token(ABSTRACT);
531                modifiers |= ModifierSet.ABSTRACT;
532          break;
533        case SYNCHRONIZED:
534          jj_consume_token(SYNCHRONIZED);
535                    modifiers |= ModifierSet.SYNCHRONIZED;
536          break;
537        case NATIVE:
538          jj_consume_token(NATIVE);
539              modifiers |= ModifierSet.NATIVE;
540          break;
541        case TRANSIENT:
542          jj_consume_token(TRANSIENT);
543                 modifiers |= ModifierSet.TRANSIENT;
544          break;
545        case VOLATILE:
546          jj_consume_token(VOLATILE);
547                modifiers |= ModifierSet.VOLATILE;
548          break;
549        case STRICTFP:
550          jj_consume_token(STRICTFP);
551                modifiers |= ModifierSet.STRICTFP;
552          break;
553        case AT:
554          Annotation();
555          break;
556        default:
557          jj_consume_token(-1);
558          throw new ParseException();
559        }
560      }
561    {if (true) return modifiers;}
562    throw new Error("Missing return statement in function");
563    } finally {
564      trace_return("Modifiers");
565    }
566  }
567
568/*
569 * Declaration syntax follows.
570 */
571  final public void TypeDeclaration() throws ParseException {
572    trace_call("TypeDeclaration");
573    try {
574   int modifiers;
575      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
576      case SEMICOLON:
577        jj_consume_token(SEMICOLON);
578        break;
579      case ABSTRACT:
580      case CLASS:
581      case ENUM:
582      case FINAL:
583      case INTERFACE:
584      case NATIVE:
585      case PRIVATE:
586      case PROTECTED:
587      case PUBLIC:
588      case STATIC:
589      case STRICTFP:
590      case SYNCHRONIZED:
591      case TRANSIENT:
592      case VOLATILE:
593      case AT:
594        modifiers = Modifiers();
595        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
596        case CLASS:
597        case INTERFACE:
598          ClassOrInterfaceDeclaration(modifiers);
599          break;
600        case ENUM:
601          EnumDeclaration(modifiers);
602          break;
603        case AT:
604          AnnotationTypeDeclaration(modifiers);
605          break;
606        default:
607          jj_consume_token(-1);
608          throw new ParseException();
609        }
610        break;
611      default:
612        jj_consume_token(-1);
613        throw new ParseException();
614      }
615    } finally {
616      trace_return("TypeDeclaration");
617    }
618  }
619
620  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
621    trace_call("ClassOrInterfaceDeclaration");
622    try {
623   boolean isInterface = false;
624      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
625      case CLASS:
626        jj_consume_token(CLASS);
627        break;
628      case INTERFACE:
629        jj_consume_token(INTERFACE);
630                            isInterface = true;
631        break;
632      default:
633        jj_consume_token(-1);
634        throw new ParseException();
635      }
636      jj_consume_token(IDENTIFIER);
637      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
638      case LT:
639        TypeParameters();
640        break;
641      default:
642        ;
643      }
644      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
645      case EXTENDS:
646        ExtendsList(isInterface);
647        break;
648      default:
649        ;
650      }
651      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
652      case IMPLEMENTS:
653        ImplementsList(isInterface);
654        break;
655      default:
656        ;
657      }
658      ClassOrInterfaceBody(isInterface);
659    } finally {
660      trace_return("ClassOrInterfaceDeclaration");
661    }
662  }
663
664  final public void ExtendsList(boolean isInterface) throws ParseException {
665    trace_call("ExtendsList");
666    try {
667   boolean extendsMoreThanOne = false;
668      jj_consume_token(EXTENDS);
669      ClassOrInterfaceType();
670      label_6:
671      while (true) {
672        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
673        case COMMA:
674          ;
675          break;
676        default:
677          break label_6;
678        }
679        jj_consume_token(COMMA);
680        ClassOrInterfaceType();
681                                  extendsMoreThanOne = true;
682      }
683      if (extendsMoreThanOne && !isInterface)
684         {if (true) throw new ParseException("A class cannot extend more than one other class");}
685    } finally {
686      trace_return("ExtendsList");
687    }
688  }
689
690  final public void ImplementsList(boolean isInterface) throws ParseException {
691    trace_call("ImplementsList");
692    try {
693      jj_consume_token(IMPLEMENTS);
694      ClassOrInterfaceType();
695      label_7:
696      while (true) {
697        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
698        case COMMA:
699          ;
700          break;
701        default:
702          break label_7;
703        }
704        jj_consume_token(COMMA);
705        ClassOrInterfaceType();
706      }
707      if (isInterface)
708         {if (true) throw new ParseException("An interface cannot implement other interfaces");}
709    } finally {
710      trace_return("ImplementsList");
711    }
712  }
713
714  final public void EnumDeclaration(int modifiers) throws ParseException {
715    trace_call("EnumDeclaration");
716    try {
717      jj_consume_token(ENUM);
718      jj_consume_token(IDENTIFIER);
719      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
720      case IMPLEMENTS:
721        ImplementsList(false);
722        break;
723      default:
724        ;
725      }
726      EnumBody();
727    } finally {
728      trace_return("EnumDeclaration");
729    }
730  }
731
732  final public void EnumBody() throws ParseException {
733    trace_call("EnumBody");
734    try {
735      jj_consume_token(LBRACE);
736      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
737      case ABSTRACT:
738      case FINAL:
739      case NATIVE:
740      case PRIVATE:
741      case PROTECTED:
742      case PUBLIC:
743      case STATIC:
744      case STRICTFP:
745      case SYNCHRONIZED:
746      case TRANSIENT:
747      case VOLATILE:
748      case IDENTIFIER:
749      case AT:
750        EnumConstant();
751        label_8:
752        while (true) {
753          if (jj_2_3(2)) {
754            ;
755          } else {
756            break label_8;
757          }
758          jj_consume_token(COMMA);
759          EnumConstant();
760        }
761        break;
762      default:
763        ;
764      }
765      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
766      case COMMA:
767        jj_consume_token(COMMA);
768        break;
769      default:
770        ;
771      }
772      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
773      case SEMICOLON:
774        jj_consume_token(SEMICOLON);
775        label_9:
776        while (true) {
777          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
778          case ABSTRACT:
779          case BOOLEAN:
780          case BYTE:
781          case CHAR:
782          case CLASS:
783          case DOUBLE:
784          case ENUM:
785          case FINAL:
786          case FLOAT:
787          case INT:
788          case INTERFACE:
789          case LONG:
790          case NATIVE:
791          case PRIVATE:
792          case PROTECTED:
793          case PUBLIC:
794          case SHORT:
795          case STATIC:
796          case STRICTFP:
797          case SYNCHRONIZED:
798          case TRANSIENT:
799          case VOID:
800          case VOLATILE:
801          case IDENTIFIER:
802          case LBRACE:
803          case SEMICOLON:
804          case AT:
805          case LT:
806            ;
807            break;
808          default:
809            break label_9;
810          }
811          ClassOrInterfaceBodyDeclaration(false);
812        }
813        break;
814      default:
815        ;
816      }
817      jj_consume_token(RBRACE);
818    } finally {
819      trace_return("EnumBody");
820    }
821  }
822
823  final public void EnumConstant() throws ParseException {
824    trace_call("EnumConstant");
825    try {
826      Modifiers();
827      jj_consume_token(IDENTIFIER);
828      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
829      case LPAREN:
830        Arguments();
831        break;
832      default:
833        ;
834      }
835      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
836      case LBRACE:
837        ClassOrInterfaceBody(false);
838        break;
839      default:
840        ;
841      }
842    } finally {
843      trace_return("EnumConstant");
844    }
845  }
846
847  final public void TypeParameters() throws ParseException {
848    trace_call("TypeParameters");
849    try {
850      jj_consume_token(LT);
851      TypeParameter();
852      label_10:
853      while (true) {
854        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
855        case COMMA:
856          ;
857          break;
858        default:
859          break label_10;
860        }
861        jj_consume_token(COMMA);
862        TypeParameter();
863      }
864      jj_consume_token(GT);
865    } finally {
866      trace_return("TypeParameters");
867    }
868  }
869
870  final public void TypeParameter() throws ParseException {
871    trace_call("TypeParameter");
872    try {
873      jj_consume_token(IDENTIFIER);
874      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
875      case EXTENDS:
876        TypeBound();
877        break;
878      default:
879        ;
880      }
881    } finally {
882      trace_return("TypeParameter");
883    }
884  }
885
886  final public void TypeBound() throws ParseException {
887    trace_call("TypeBound");
888    try {
889      jj_consume_token(EXTENDS);
890      ClassOrInterfaceType();
891      label_11:
892      while (true) {
893        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
894        case BIT_AND:
895          ;
896          break;
897        default:
898          break label_11;
899        }
900        jj_consume_token(BIT_AND);
901        ClassOrInterfaceType();
902      }
903    } finally {
904      trace_return("TypeBound");
905    }
906  }
907
908  final public void ClassOrInterfaceBody(boolean isInterface) throws ParseException {
909    trace_call("ClassOrInterfaceBody");
910    try {
911      jj_consume_token(LBRACE);
912      label_12:
913      while (true) {
914        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
915        case ABSTRACT:
916        case BOOLEAN:
917        case BYTE:
918        case CHAR:
919        case CLASS:
920        case DOUBLE:
921        case ENUM:
922        case FINAL:
923        case FLOAT:
924        case INT:
925        case INTERFACE:
926        case LONG:
927        case NATIVE:
928        case PRIVATE:
929        case PROTECTED:
930        case PUBLIC:
931        case SHORT:
932        case STATIC:
933        case STRICTFP:
934        case SYNCHRONIZED:
935        case TRANSIENT:
936        case VOID:
937        case VOLATILE:
938        case IDENTIFIER:
939        case LBRACE:
940        case SEMICOLON:
941        case AT:
942        case LT:
943          ;
944          break;
945        default:
946          break label_12;
947        }
948        ClassOrInterfaceBodyDeclaration(isInterface);
949      }
950      jj_consume_token(RBRACE);
951    } finally {
952      trace_return("ClassOrInterfaceBody");
953    }
954  }
955
956  final public void ClassOrInterfaceBodyDeclaration(boolean isInterface) throws ParseException {
957    trace_call("ClassOrInterfaceBodyDeclaration");
958    try {
959   boolean isNestedInterface = false;
960   int modifiers;
961      if (jj_2_6(2)) {
962        Initializer();
963     if (isInterface)
964        {if (true) throw new ParseException("An interface cannot have initializers");}
965      } else {
966        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
967        case ABSTRACT:
968        case BOOLEAN:
969        case BYTE:
970        case CHAR:
971        case CLASS:
972        case DOUBLE:
973        case ENUM:
974        case FINAL:
975        case FLOAT:
976        case INT:
977        case INTERFACE:
978        case LONG:
979        case NATIVE:
980        case PRIVATE:
981        case PROTECTED:
982        case PUBLIC:
983        case SHORT:
984        case STATIC:
985        case STRICTFP:
986        case SYNCHRONIZED:
987        case TRANSIENT:
988        case VOID:
989        case VOLATILE:
990        case IDENTIFIER:
991        case AT:
992        case LT:
993          modifiers = Modifiers();
994          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
995          case CLASS:
996          case INTERFACE:
997            ClassOrInterfaceDeclaration(modifiers);
998            break;
999          case ENUM:
1000            EnumDeclaration(modifiers);
1001            break;
1002          default:
1003            if (jj_2_4(2147483647)) {
1004              ConstructorDeclaration();
1005            } else if (jj_2_5(2147483647)) {
1006              FieldDeclaration(modifiers);
1007            } else {
1008              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1009              case BOOLEAN:
1010              case BYTE:
1011              case CHAR:
1012              case DOUBLE:
1013              case FLOAT:
1014              case INT:
1015              case LONG:
1016              case SHORT:
1017              case VOID:
1018              case IDENTIFIER:
1019              case LT:
1020                MethodDeclaration(modifiers);
1021                break;
1022              default:
1023                jj_consume_token(-1);
1024                throw new ParseException();
1025              }
1026            }
1027          }
1028          break;
1029        case SEMICOLON:
1030          jj_consume_token(SEMICOLON);
1031          break;
1032        default:
1033          jj_consume_token(-1);
1034          throw new ParseException();
1035        }
1036      }
1037    } finally {
1038      trace_return("ClassOrInterfaceBodyDeclaration");
1039    }
1040  }
1041
1042  final public void FieldDeclaration(int modifiers) throws ParseException {
1043    trace_call("FieldDeclaration");
1044    try {
1045      Type();
1046      VariableDeclarator();
1047      label_13:
1048      while (true) {
1049        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1050        case COMMA:
1051          ;
1052          break;
1053        default:
1054          break label_13;
1055        }
1056        jj_consume_token(COMMA);
1057        VariableDeclarator();
1058      }
1059      jj_consume_token(SEMICOLON);
1060    } finally {
1061      trace_return("FieldDeclaration");
1062    }
1063  }
1064
1065  final public void VariableDeclarator() throws ParseException {
1066    trace_call("VariableDeclarator");
1067    try {
1068      VariableDeclaratorId();
1069      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1070      case ASSIGN:
1071        jj_consume_token(ASSIGN);
1072        VariableInitializer();
1073        break;
1074      default:
1075        ;
1076      }
1077    } finally {
1078      trace_return("VariableDeclarator");
1079    }
1080  }
1081
1082  final public void VariableDeclaratorId() throws ParseException {
1083    trace_call("VariableDeclaratorId");
1084    try {
1085      jj_consume_token(IDENTIFIER);
1086      label_14:
1087      while (true) {
1088        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1089        case LBRACKET:
1090          ;
1091          break;
1092        default:
1093          break label_14;
1094        }
1095        jj_consume_token(LBRACKET);
1096        jj_consume_token(RBRACKET);
1097      }
1098    } finally {
1099      trace_return("VariableDeclaratorId");
1100    }
1101  }
1102
1103  final public void VariableInitializer() throws ParseException {
1104    trace_call("VariableInitializer");
1105    try {
1106      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1107      case LBRACE:
1108        ArrayInitializer();
1109        break;
1110      case BOOLEAN:
1111      case BYTE:
1112      case CHAR:
1113      case DOUBLE:
1114      case FALSE:
1115      case FLOAT:
1116      case INT:
1117      case LONG:
1118      case NEW:
1119      case NULL:
1120      case SHORT:
1121      case SUPER:
1122      case THIS:
1123      case TRUE:
1124      case VOID:
1125      case INTEGER_LITERAL:
1126      case FLOATING_POINT_LITERAL:
1127      case CHARACTER_LITERAL:
1128      case STRING_LITERAL:
1129      case IDENTIFIER:
1130      case LPAREN:
1131      case BANG:
1132      case TILDE:
1133      case INCR:
1134      case DECR:
1135      case PLUS:
1136      case MINUS:
1137        Expression();
1138        break;
1139      default:
1140        jj_consume_token(-1);
1141        throw new ParseException();
1142      }
1143    } finally {
1144      trace_return("VariableInitializer");
1145    }
1146  }
1147
1148  final public void ArrayInitializer() throws ParseException {
1149    trace_call("ArrayInitializer");
1150    try {
1151      jj_consume_token(LBRACE);
1152      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1153      case BOOLEAN:
1154      case BYTE:
1155      case CHAR:
1156      case DOUBLE:
1157      case FALSE:
1158      case FLOAT:
1159      case INT:
1160      case LONG:
1161      case NEW:
1162      case NULL:
1163      case SHORT:
1164      case SUPER:
1165      case THIS:
1166      case TRUE:
1167      case VOID:
1168      case INTEGER_LITERAL:
1169      case FLOATING_POINT_LITERAL:
1170      case CHARACTER_LITERAL:
1171      case STRING_LITERAL:
1172      case IDENTIFIER:
1173      case LPAREN:
1174      case LBRACE:
1175      case BANG:
1176      case TILDE:
1177      case INCR:
1178      case DECR:
1179      case PLUS:
1180      case MINUS:
1181        VariableInitializer();
1182        label_15:
1183        while (true) {
1184          if (jj_2_7(2)) {
1185            ;
1186          } else {
1187            break label_15;
1188          }
1189          jj_consume_token(COMMA);
1190          VariableInitializer();
1191        }
1192        break;
1193      default:
1194        ;
1195      }
1196      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1197      case COMMA:
1198        jj_consume_token(COMMA);
1199        break;
1200      default:
1201        ;
1202      }
1203      jj_consume_token(RBRACE);
1204    } finally {
1205      trace_return("ArrayInitializer");
1206    }
1207  }
1208
1209  final public void MethodDeclaration(int modifiers) throws ParseException {
1210    trace_call("MethodDeclaration");
1211    try {
1212      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1213      case LT:
1214        TypeParameters();
1215        break;
1216      default:
1217        ;
1218      }
1219      ResultType();
1220      MethodDeclarator();
1221      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1222      case THROWS:
1223        jj_consume_token(THROWS);
1224        NameList();
1225        break;
1226      default:
1227        ;
1228      }
1229      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1230      case LBRACE:
1231        Block();
1232        break;
1233      case SEMICOLON:
1234        jj_consume_token(SEMICOLON);
1235        break;
1236      default:
1237        jj_consume_token(-1);
1238        throw new ParseException();
1239      }
1240    } finally {
1241      trace_return("MethodDeclaration");
1242    }
1243  }
1244
1245  final public void MethodDeclarator() throws ParseException {
1246    trace_call("MethodDeclarator");
1247    try {
1248      jj_consume_token(IDENTIFIER);
1249      FormalParameters();
1250      label_16:
1251      while (true) {
1252        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1253        case LBRACKET:
1254          ;
1255          break;
1256        default:
1257          break label_16;
1258        }
1259        jj_consume_token(LBRACKET);
1260        jj_consume_token(RBRACKET);
1261      }
1262    } finally {
1263      trace_return("MethodDeclarator");
1264    }
1265  }
1266
1267  final public void FormalParameters() throws ParseException {
1268    trace_call("FormalParameters");
1269    try {
1270      jj_consume_token(LPAREN);
1271      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1272      case ABSTRACT:
1273      case BOOLEAN:
1274      case BYTE:
1275      case CHAR:
1276      case DOUBLE:
1277      case FINAL:
1278      case FLOAT:
1279      case INT:
1280      case LONG:
1281      case NATIVE:
1282      case PRIVATE:
1283      case PROTECTED:
1284      case PUBLIC:
1285      case SHORT:
1286      case STATIC:
1287      case STRICTFP:
1288      case SYNCHRONIZED:
1289      case TRANSIENT:
1290      case VOLATILE:
1291      case IDENTIFIER:
1292      case AT:
1293        FormalParameter();
1294        label_17:
1295        while (true) {
1296          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1297          case COMMA:
1298            ;
1299            break;
1300          default:
1301            break label_17;
1302          }
1303          jj_consume_token(COMMA);
1304          FormalParameter();
1305        }
1306        break;
1307      default:
1308        ;
1309      }
1310      jj_consume_token(RPAREN);
1311    } finally {
1312      trace_return("FormalParameters");
1313    }
1314  }
1315
1316  final public void FormalParameter() throws ParseException {
1317    trace_call("FormalParameter");
1318    try {
1319      Modifiers();
1320      Type();
1321      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1322      case ELLIPSIS:
1323        jj_consume_token(ELLIPSIS);
1324        break;
1325      default:
1326        ;
1327      }
1328      VariableDeclaratorId();
1329    } finally {
1330      trace_return("FormalParameter");
1331    }
1332  }
1333
1334  final public void ConstructorDeclaration() throws ParseException {
1335    trace_call("ConstructorDeclaration");
1336    try {
1337      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1338      case LT:
1339        TypeParameters();
1340        break;
1341      default:
1342        ;
1343      }
1344      jj_consume_token(IDENTIFIER);
1345      FormalParameters();
1346      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1347      case THROWS:
1348        jj_consume_token(THROWS);
1349        NameList();
1350        break;
1351      default:
1352        ;
1353      }
1354      jj_consume_token(LBRACE);
1355      if (jj_2_8(2147483647)) {
1356        ExplicitConstructorInvocation();
1357      } else {
1358        ;
1359      }
1360      label_18:
1361      while (true) {
1362        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1363        case ABSTRACT:
1364        case ASSERT:
1365        case BOOLEAN:
1366        case BREAK:
1367        case BYTE:
1368        case CHAR:
1369        case CLASS:
1370        case CONTINUE:
1371        case DO:
1372        case DOUBLE:
1373        case FALSE:
1374        case FINAL:
1375        case FLOAT:
1376        case FOR:
1377        case IF:
1378        case INT:
1379        case INTERFACE:
1380        case LONG:
1381        case NATIVE:
1382        case NEW:
1383        case NULL:
1384        case PRIVATE:
1385        case PROTECTED:
1386        case PUBLIC:
1387        case RETURN:
1388        case SHORT:
1389        case STATIC:
1390        case STRICTFP:
1391        case SUPER:
1392        case SWITCH:
1393        case SYNCHRONIZED:
1394        case THIS:
1395        case THROW:
1396        case TRANSIENT:
1397        case TRUE:
1398        case TRY:
1399        case VOID:
1400        case VOLATILE:
1401        case WHILE:
1402        case INTEGER_LITERAL:
1403        case FLOATING_POINT_LITERAL:
1404        case CHARACTER_LITERAL:
1405        case STRING_LITERAL:
1406        case IDENTIFIER:
1407        case LPAREN:
1408        case LBRACE:
1409        case SEMICOLON:
1410        case AT:
1411        case INCR:
1412        case DECR:
1413          ;
1414          break;
1415        default:
1416          break label_18;
1417        }
1418        BlockStatement();
1419      }
1420      jj_consume_token(RBRACE);
1421    } finally {
1422      trace_return("ConstructorDeclaration");
1423    }
1424  }
1425
1426  final public void ExplicitConstructorInvocation() throws ParseException {
1427    trace_call("ExplicitConstructorInvocation");
1428    try {
1429      label_19:
1430      while (true) {
1431        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1432        case IDENTIFIER:
1433          ;
1434          break;
1435        default:
1436          break label_19;
1437        }
1438        jj_consume_token(IDENTIFIER);
1439        jj_consume_token(DOT);
1440      }
1441      if (jj_2_9(2)) {
1442        jj_consume_token(THIS);
1443        jj_consume_token(DOT);
1444      } else {
1445        ;
1446      }
1447      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1448      case LT:
1449        TypeArguments();
1450        break;
1451      default:
1452        ;
1453      }
1454      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1455      case THIS:
1456        jj_consume_token(THIS);
1457        break;
1458      case SUPER:
1459        jj_consume_token(SUPER);
1460        break;
1461      default:
1462        jj_consume_token(-1);
1463        throw new ParseException();
1464      }
1465      Arguments();
1466      jj_consume_token(SEMICOLON);
1467    } finally {
1468      trace_return("ExplicitConstructorInvocation");
1469    }
1470  }
1471
1472  final public void Initializer() throws ParseException {
1473    trace_call("Initializer");
1474    try {
1475      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1476      case STATIC:
1477        jj_consume_token(STATIC);
1478        break;
1479      default:
1480        ;
1481      }
1482      Block();
1483    } finally {
1484      trace_return("Initializer");
1485    }
1486  }
1487
1488/*
1489 * Type, name and expression syntax follows.
1490 */
1491  final public void Type() throws ParseException {
1492    trace_call("Type");
1493    try {
1494      if (jj_2_10(2)) {
1495        ReferenceType();
1496      } else {
1497        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1498        case BOOLEAN:
1499        case BYTE:
1500        case CHAR:
1501        case DOUBLE:
1502        case FLOAT:
1503        case INT:
1504        case LONG:
1505        case SHORT:
1506          PrimitiveType();
1507          break;
1508        default:
1509          jj_consume_token(-1);
1510          throw new ParseException();
1511        }
1512      }
1513    } finally {
1514      trace_return("Type");
1515    }
1516  }
1517
1518  final public void ReferenceType() throws ParseException {
1519    trace_call("ReferenceType");
1520    try {
1521      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1522      case BOOLEAN:
1523      case BYTE:
1524      case CHAR:
1525      case DOUBLE:
1526      case FLOAT:
1527      case INT:
1528      case LONG:
1529      case SHORT:
1530        PrimitiveType();
1531        label_20:
1532        while (true) {
1533          jj_consume_token(LBRACKET);
1534          jj_consume_token(RBRACKET);
1535          if (jj_2_11(2)) {
1536            ;
1537          } else {
1538            break label_20;
1539          }
1540        }
1541        break;
1542      case IDENTIFIER:
1543        ClassOrInterfaceType();
1544        label_21:
1545        while (true) {
1546          if (jj_2_12(2)) {
1547            ;
1548          } else {
1549            break label_21;
1550          }
1551          jj_consume_token(LBRACKET);
1552          jj_consume_token(RBRACKET);
1553        }
1554        break;
1555      default:
1556        jj_consume_token(-1);
1557        throw new ParseException();
1558      }
1559    } finally {
1560      trace_return("ReferenceType");
1561    }
1562  }
1563
1564  final public void ClassOrInterfaceType() throws ParseException {
1565    trace_call("ClassOrInterfaceType");
1566    try {
1567      jj_consume_token(IDENTIFIER);
1568      if (jj_2_13(2)) {
1569        TypeArguments();
1570      } else {
1571        ;
1572      }
1573      label_22:
1574      while (true) {
1575        if (jj_2_14(2)) {
1576          ;
1577        } else {
1578          break label_22;
1579        }
1580        jj_consume_token(DOT);
1581        jj_consume_token(IDENTIFIER);
1582        if (jj_2_15(2)) {
1583          TypeArguments();
1584        } else {
1585          ;
1586        }
1587      }
1588    } finally {
1589      trace_return("ClassOrInterfaceType");
1590    }
1591  }
1592
1593  final public void TypeArguments() throws ParseException {
1594    trace_call("TypeArguments");
1595    try {
1596      jj_consume_token(LT);
1597      TypeArgument();
1598      label_23:
1599      while (true) {
1600        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1601        case COMMA:
1602          ;
1603          break;
1604        default:
1605          break label_23;
1606        }
1607        jj_consume_token(COMMA);
1608        TypeArgument();
1609      }
1610      jj_consume_token(GT);
1611    } finally {
1612      trace_return("TypeArguments");
1613    }
1614  }
1615
1616  final public void TypeArgument() throws ParseException {
1617    trace_call("TypeArgument");
1618    try {
1619      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1620      case BOOLEAN:
1621      case BYTE:
1622      case CHAR:
1623      case DOUBLE:
1624      case FLOAT:
1625      case INT:
1626      case LONG:
1627      case SHORT:
1628      case IDENTIFIER:
1629        ReferenceType();
1630        break;
1631      case HOOK:
1632        jj_consume_token(HOOK);
1633        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1634        case EXTENDS:
1635        case SUPER:
1636          WildcardBounds();
1637          break;
1638        default:
1639          ;
1640        }
1641        break;
1642      default:
1643        jj_consume_token(-1);
1644        throw new ParseException();
1645      }
1646    } finally {
1647      trace_return("TypeArgument");
1648    }
1649  }
1650
1651  final public void WildcardBounds() throws ParseException {
1652    trace_call("WildcardBounds");
1653    try {
1654      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1655      case EXTENDS:
1656        jj_consume_token(EXTENDS);
1657        ReferenceType();
1658        break;
1659      case SUPER:
1660        jj_consume_token(SUPER);
1661        ReferenceType();
1662        break;
1663      default:
1664        jj_consume_token(-1);
1665        throw new ParseException();
1666      }
1667    } finally {
1668      trace_return("WildcardBounds");
1669    }
1670  }
1671
1672  final public void PrimitiveType() throws ParseException {
1673    trace_call("PrimitiveType");
1674    try {
1675      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1676      case BOOLEAN:
1677        jj_consume_token(BOOLEAN);
1678        break;
1679      case CHAR:
1680        jj_consume_token(CHAR);
1681        break;
1682      case BYTE:
1683        jj_consume_token(BYTE);
1684        break;
1685      case SHORT:
1686        jj_consume_token(SHORT);
1687        break;
1688      case INT:
1689        jj_consume_token(INT);
1690        break;
1691      case LONG:
1692        jj_consume_token(LONG);
1693        break;
1694      case FLOAT:
1695        jj_consume_token(FLOAT);
1696        break;
1697      case DOUBLE:
1698        jj_consume_token(DOUBLE);
1699        break;
1700      default:
1701        jj_consume_token(-1);
1702        throw new ParseException();
1703      }
1704    } finally {
1705      trace_return("PrimitiveType");
1706    }
1707  }
1708
1709  final public void ResultType() throws ParseException {
1710    trace_call("ResultType");
1711    try {
1712      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1713      case VOID:
1714        jj_consume_token(VOID);
1715        break;
1716      case BOOLEAN:
1717      case BYTE:
1718      case CHAR:
1719      case DOUBLE:
1720      case FLOAT:
1721      case INT:
1722      case LONG:
1723      case SHORT:
1724      case IDENTIFIER:
1725        Type();
1726        break;
1727      default:
1728        jj_consume_token(-1);
1729        throw new ParseException();
1730      }
1731    } finally {
1732      trace_return("ResultType");
1733    }
1734  }
1735
1736  final public void Name() throws ParseException {
1737    trace_call("Name");
1738    try {
1739      jj_consume_token(IDENTIFIER);
1740      label_24:
1741      while (true) {
1742        if (jj_2_16(2)) {
1743          ;
1744        } else {
1745          break label_24;
1746        }
1747        jj_consume_token(DOT);
1748        jj_consume_token(IDENTIFIER);
1749      }
1750    } finally {
1751      trace_return("Name");
1752    }
1753  }
1754
1755  final public void NameList() throws ParseException {
1756    trace_call("NameList");
1757    try {
1758      Name();
1759      label_25:
1760      while (true) {
1761        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1762        case COMMA:
1763          ;
1764          break;
1765        default:
1766          break label_25;
1767        }
1768        jj_consume_token(COMMA);
1769        Name();
1770      }
1771    } finally {
1772      trace_return("NameList");
1773    }
1774  }
1775
1776/*
1777 * Expression syntax follows.
1778 */
1779  final public void Expression() throws ParseException {
1780    trace_call("Expression");
1781    try {
1782      ConditionalExpression();
1783      if (jj_2_17(2)) {
1784        AssignmentOperator();
1785        Expression();
1786      } else {
1787        ;
1788      }
1789    } finally {
1790      trace_return("Expression");
1791    }
1792  }
1793
1794  final public void AssignmentOperator() throws ParseException {
1795    trace_call("AssignmentOperator");
1796    try {
1797      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1798      case ASSIGN:
1799        jj_consume_token(ASSIGN);
1800        break;
1801      case STARASSIGN:
1802        jj_consume_token(STARASSIGN);
1803        break;
1804      case SLASHASSIGN:
1805        jj_consume_token(SLASHASSIGN);
1806        break;
1807      case REMASSIGN:
1808        jj_consume_token(REMASSIGN);
1809        break;
1810      case PLUSASSIGN:
1811        jj_consume_token(PLUSASSIGN);
1812        break;
1813      case MINUSASSIGN:
1814        jj_consume_token(MINUSASSIGN);
1815        break;
1816      case LSHIFTASSIGN:
1817        jj_consume_token(LSHIFTASSIGN);
1818        break;
1819      case RSIGNEDSHIFTASSIGN:
1820        jj_consume_token(RSIGNEDSHIFTASSIGN);
1821        break;
1822      case RUNSIGNEDSHIFTASSIGN:
1823        jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1824        break;
1825      case ANDASSIGN:
1826        jj_consume_token(ANDASSIGN);
1827        break;
1828      case XORASSIGN:
1829        jj_consume_token(XORASSIGN);
1830        break;
1831      case ORASSIGN:
1832        jj_consume_token(ORASSIGN);
1833        break;
1834      default:
1835        jj_consume_token(-1);
1836        throw new ParseException();
1837      }
1838    } finally {
1839      trace_return("AssignmentOperator");
1840    }
1841  }
1842
1843  final public void ConditionalExpression() throws ParseException {
1844    trace_call("ConditionalExpression");
1845    try {
1846      ConditionalOrExpression();
1847      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1848      case HOOK:
1849        jj_consume_token(HOOK);
1850        Expression();
1851        jj_consume_token(COLON);
1852        Expression();
1853        break;
1854      default:
1855        ;
1856      }
1857    } finally {
1858      trace_return("ConditionalExpression");
1859    }
1860  }
1861
1862  final public void ConditionalOrExpression() throws ParseException {
1863    trace_call("ConditionalOrExpression");
1864    try {
1865      ConditionalAndExpression();
1866      label_26:
1867      while (true) {
1868        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1869        case SC_OR:
1870          ;
1871          break;
1872        default:
1873          break label_26;
1874        }
1875        jj_consume_token(SC_OR);
1876        ConditionalAndExpression();
1877      }
1878    } finally {
1879      trace_return("ConditionalOrExpression");
1880    }
1881  }
1882
1883  final public void ConditionalAndExpression() throws ParseException {
1884    trace_call("ConditionalAndExpression");
1885    try {
1886      InclusiveOrExpression();
1887      label_27:
1888      while (true) {
1889        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1890        case SC_AND:
1891          ;
1892          break;
1893        default:
1894          break label_27;
1895        }
1896        jj_consume_token(SC_AND);
1897        InclusiveOrExpression();
1898      }
1899    } finally {
1900      trace_return("ConditionalAndExpression");
1901    }
1902  }
1903
1904  final public void InclusiveOrExpression() throws ParseException {
1905    trace_call("InclusiveOrExpression");
1906    try {
1907      ExclusiveOrExpression();
1908      label_28:
1909      while (true) {
1910        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1911        case BIT_OR:
1912          ;
1913          break;
1914        default:
1915          break label_28;
1916        }
1917        jj_consume_token(BIT_OR);
1918        ExclusiveOrExpression();
1919      }
1920    } finally {
1921      trace_return("InclusiveOrExpression");
1922    }
1923  }
1924
1925  final public void ExclusiveOrExpression() throws ParseException {
1926    trace_call("ExclusiveOrExpression");
1927    try {
1928      AndExpression();
1929      label_29:
1930      while (true) {
1931        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1932        case XOR:
1933          ;
1934          break;
1935        default:
1936          break label_29;
1937        }
1938        jj_consume_token(XOR);
1939        AndExpression();
1940      }
1941    } finally {
1942      trace_return("ExclusiveOrExpression");
1943    }
1944  }
1945
1946  final public void AndExpression() throws ParseException {
1947    trace_call("AndExpression");
1948    try {
1949      EqualityExpression();
1950      label_30:
1951      while (true) {
1952        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1953        case BIT_AND:
1954          ;
1955          break;
1956        default:
1957          break label_30;
1958        }
1959        jj_consume_token(BIT_AND);
1960        EqualityExpression();
1961      }
1962    } finally {
1963      trace_return("AndExpression");
1964    }
1965  }
1966
1967  final public void EqualityExpression() throws ParseException {
1968    trace_call("EqualityExpression");
1969    try {
1970      InstanceOfExpression();
1971      label_31:
1972      while (true) {
1973        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1974        case EQ:
1975        case NE:
1976          ;
1977          break;
1978        default:
1979          break label_31;
1980        }
1981        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1982        case EQ:
1983          jj_consume_token(EQ);
1984          break;
1985        case NE:
1986          jj_consume_token(NE);
1987          break;
1988        default:
1989          jj_consume_token(-1);
1990          throw new ParseException();
1991        }
1992        InstanceOfExpression();
1993      }
1994    } finally {
1995      trace_return("EqualityExpression");
1996    }
1997  }
1998
1999  final public void InstanceOfExpression() throws ParseException {
2000    trace_call("InstanceOfExpression");
2001    try {
2002      RelationalExpression();
2003      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2004      case INSTANCEOF:
2005        jj_consume_token(INSTANCEOF);
2006        Type();
2007        break;
2008      default:
2009        ;
2010      }
2011    } finally {
2012      trace_return("InstanceOfExpression");
2013    }
2014  }
2015
2016  final public void RelationalExpression() throws ParseException {
2017    trace_call("RelationalExpression");
2018    try {
2019      ShiftExpression();
2020      label_32:
2021      while (true) {
2022        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2023        case LT:
2024        case LE:
2025        case GE:
2026        case GT:
2027          ;
2028          break;
2029        default:
2030          break label_32;
2031        }
2032        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2033        case LT:
2034          jj_consume_token(LT);
2035          break;
2036        case GT:
2037          jj_consume_token(GT);
2038          break;
2039        case LE:
2040          jj_consume_token(LE);
2041          break;
2042        case GE:
2043          jj_consume_token(GE);
2044          break;
2045        default:
2046          jj_consume_token(-1);
2047          throw new ParseException();
2048        }
2049        ShiftExpression();
2050      }
2051    } finally {
2052      trace_return("RelationalExpression");
2053    }
2054  }
2055
2056  final public void ShiftExpression() throws ParseException {
2057    trace_call("ShiftExpression");
2058    try {
2059      AdditiveExpression();
2060      label_33:
2061      while (true) {
2062        if (jj_2_18(1)) {
2063          ;
2064        } else {
2065          break label_33;
2066        }
2067        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2068        case LSHIFT:
2069          jj_consume_token(LSHIFT);
2070          break;
2071        default:
2072          if (jj_2_19(1)) {
2073            RSIGNEDSHIFT();
2074          } else if (jj_2_20(1)) {
2075            RUNSIGNEDSHIFT();
2076          } else {
2077            jj_consume_token(-1);
2078            throw new ParseException();
2079          }
2080        }
2081        AdditiveExpression();
2082      }
2083    } finally {
2084      trace_return("ShiftExpression");
2085    }
2086  }
2087
2088  final public void AdditiveExpression() throws ParseException {
2089    trace_call("AdditiveExpression");
2090    try {
2091      MultiplicativeExpression();
2092      label_34:
2093      while (true) {
2094        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2095        case PLUS:
2096        case MINUS:
2097          ;
2098          break;
2099        default:
2100          break label_34;
2101        }
2102        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2103        case PLUS:
2104          jj_consume_token(PLUS);
2105          break;
2106        case MINUS:
2107          jj_consume_token(MINUS);
2108          break;
2109        default:
2110          jj_consume_token(-1);
2111          throw new ParseException();
2112        }
2113        MultiplicativeExpression();
2114      }
2115    } finally {
2116      trace_return("AdditiveExpression");
2117    }
2118  }
2119
2120  final public void MultiplicativeExpression() throws ParseException {
2121    trace_call("MultiplicativeExpression");
2122    try {
2123      UnaryExpression();
2124      label_35:
2125      while (true) {
2126        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2127        case STAR:
2128        case SLASH:
2129        case REM:
2130          ;
2131          break;
2132        default:
2133          break label_35;
2134        }
2135        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2136        case STAR:
2137          jj_consume_token(STAR);
2138          break;
2139        case SLASH:
2140          jj_consume_token(SLASH);
2141          break;
2142        case REM:
2143          jj_consume_token(REM);
2144          break;
2145        default:
2146          jj_consume_token(-1);
2147          throw new ParseException();
2148        }
2149        UnaryExpression();
2150      }
2151    } finally {
2152      trace_return("MultiplicativeExpression");
2153    }
2154  }
2155
2156  final public void UnaryExpression() throws ParseException {
2157    trace_call("UnaryExpression");
2158    try {
2159      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2160      case PLUS:
2161      case MINUS:
2162        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2163        case PLUS:
2164          jj_consume_token(PLUS);
2165          break;
2166        case MINUS:
2167          jj_consume_token(MINUS);
2168          break;
2169        default:
2170          jj_consume_token(-1);
2171          throw new ParseException();
2172        }
2173        UnaryExpression();
2174        break;
2175      case INCR:
2176        PreIncrementExpression();
2177        break;
2178      case DECR:
2179        PreDecrementExpression();
2180        break;
2181      case BOOLEAN:
2182      case BYTE:
2183      case CHAR:
2184      case DOUBLE:
2185      case FALSE:
2186      case FLOAT:
2187      case INT:
2188      case LONG:
2189      case NEW:
2190      case NULL:
2191      case SHORT:
2192      case SUPER:
2193      case THIS:
2194      case TRUE:
2195      case VOID:
2196      case INTEGER_LITERAL:
2197      case FLOATING_POINT_LITERAL:
2198      case CHARACTER_LITERAL:
2199      case STRING_LITERAL:
2200      case IDENTIFIER:
2201      case LPAREN:
2202      case BANG:
2203      case TILDE:
2204        UnaryExpressionNotPlusMinus();
2205        break;
2206      default:
2207        jj_consume_token(-1);
2208        throw new ParseException();
2209      }
2210    } finally {
2211      trace_return("UnaryExpression");
2212    }
2213  }
2214
2215  final public void PreIncrementExpression() throws ParseException {
2216    trace_call("PreIncrementExpression");
2217    try {
2218      jj_consume_token(INCR);
2219      PrimaryExpression();
2220    } finally {
2221      trace_return("PreIncrementExpression");
2222    }
2223  }
2224
2225  final public void PreDecrementExpression() throws ParseException {
2226    trace_call("PreDecrementExpression");
2227    try {
2228      jj_consume_token(DECR);
2229      PrimaryExpression();
2230    } finally {
2231      trace_return("PreDecrementExpression");
2232    }
2233  }
2234
2235  final public void UnaryExpressionNotPlusMinus() throws ParseException {
2236    trace_call("UnaryExpressionNotPlusMinus");
2237    try {
2238      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2239      case BANG:
2240      case TILDE:
2241        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2242        case TILDE:
2243          jj_consume_token(TILDE);
2244          break;
2245        case BANG:
2246          jj_consume_token(BANG);
2247          break;
2248        default:
2249          jj_consume_token(-1);
2250          throw new ParseException();
2251        }
2252        UnaryExpression();
2253        break;
2254      default:
2255        if (jj_2_21(2147483647)) {
2256          CastExpression();
2257        } else {
2258          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2259          case BOOLEAN:
2260          case BYTE:
2261          case CHAR:
2262          case DOUBLE:
2263          case FALSE:
2264          case FLOAT:
2265          case INT:
2266          case LONG:
2267          case NEW:
2268          case NULL:
2269          case SHORT:
2270          case SUPER:
2271          case THIS:
2272          case TRUE:
2273          case VOID:
2274          case INTEGER_LITERAL:
2275          case FLOATING_POINT_LITERAL:
2276          case CHARACTER_LITERAL:
2277          case STRING_LITERAL:
2278          case IDENTIFIER:
2279          case LPAREN:
2280            PostfixExpression();
2281            break;
2282          default:
2283            jj_consume_token(-1);
2284            throw new ParseException();
2285          }
2286        }
2287      }
2288    } finally {
2289      trace_return("UnaryExpressionNotPlusMinus");
2290    }
2291  }
2292
2293// This production is to determine lookahead only.  The LOOKAHEAD specifications
2294// below are not used, but they are there just to indicate that we know about
2295// this.
2296  final public void CastLookahead() throws ParseException {
2297    trace_call("CastLookahead");
2298    try {
2299      if (jj_2_22(2)) {
2300        jj_consume_token(LPAREN);
2301        PrimitiveType();
2302      } else if (jj_2_23(2147483647)) {
2303        jj_consume_token(LPAREN);
2304        Type();
2305        jj_consume_token(LBRACKET);
2306        jj_consume_token(RBRACKET);
2307      } else {
2308        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2309        case LPAREN:
2310          jj_consume_token(LPAREN);
2311          Type();
2312          jj_consume_token(RPAREN);
2313          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2314          case TILDE:
2315            jj_consume_token(TILDE);
2316            break;
2317          case BANG:
2318            jj_consume_token(BANG);
2319            break;
2320          case LPAREN:
2321            jj_consume_token(LPAREN);
2322            break;
2323          case IDENTIFIER:
2324            jj_consume_token(IDENTIFIER);
2325            break;
2326          case THIS:
2327            jj_consume_token(THIS);
2328            break;
2329          case SUPER:
2330            jj_consume_token(SUPER);
2331            break;
2332          case NEW:
2333            jj_consume_token(NEW);
2334            break;
2335          case FALSE:
2336          case NULL:
2337          case TRUE:
2338          case INTEGER_LITERAL:
2339          case FLOATING_POINT_LITERAL:
2340          case CHARACTER_LITERAL:
2341          case STRING_LITERAL:
2342            Literal();
2343            break;
2344          default:
2345            jj_consume_token(-1);
2346            throw new ParseException();
2347          }
2348          break;
2349        default:
2350          jj_consume_token(-1);
2351          throw new ParseException();
2352        }
2353      }
2354    } finally {
2355      trace_return("CastLookahead");
2356    }
2357  }
2358
2359  final public void PostfixExpression() throws ParseException {
2360    trace_call("PostfixExpression");
2361    try {
2362      PrimaryExpression();
2363      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2364      case INCR:
2365      case DECR:
2366        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2367        case INCR:
2368          jj_consume_token(INCR);
2369          break;
2370        case DECR:
2371          jj_consume_token(DECR);
2372          break;
2373        default:
2374          jj_consume_token(-1);
2375          throw new ParseException();
2376        }
2377        break;
2378      default:
2379        ;
2380      }
2381    } finally {
2382      trace_return("PostfixExpression");
2383    }
2384  }
2385
2386  final public void CastExpression() throws ParseException {
2387    trace_call("CastExpression");
2388    try {
2389      if (jj_2_24(2147483647)) {
2390        jj_consume_token(LPAREN);
2391        Type();
2392        jj_consume_token(RPAREN);
2393        UnaryExpression();
2394      } else {
2395        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2396        case LPAREN:
2397          jj_consume_token(LPAREN);
2398          Type();
2399          jj_consume_token(RPAREN);
2400          UnaryExpressionNotPlusMinus();
2401          break;
2402        default:
2403          jj_consume_token(-1);
2404          throw new ParseException();
2405        }
2406      }
2407    } finally {
2408      trace_return("CastExpression");
2409    }
2410  }
2411
2412  final public void PrimaryExpression() throws ParseException {
2413    trace_call("PrimaryExpression");
2414    try {
2415      PrimaryPrefix();
2416      label_36:
2417      while (true) {
2418        if (jj_2_25(2)) {
2419          ;
2420        } else {
2421          break label_36;
2422        }
2423        PrimarySuffix();
2424      }
2425    } finally {
2426      trace_return("PrimaryExpression");
2427    }
2428  }
2429
2430  final public void MemberSelector() throws ParseException {
2431    trace_call("MemberSelector");
2432    try {
2433      jj_consume_token(DOT);
2434      TypeArguments();
2435      jj_consume_token(IDENTIFIER);
2436    } finally {
2437      trace_return("MemberSelector");
2438    }
2439  }
2440
2441  final public void PrimaryPrefix() throws ParseException {
2442    trace_call("PrimaryPrefix");
2443    try {
2444      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2445      case FALSE:
2446      case NULL:
2447      case TRUE:
2448      case INTEGER_LITERAL:
2449      case FLOATING_POINT_LITERAL:
2450      case CHARACTER_LITERAL:
2451      case STRING_LITERAL:
2452        Literal();
2453        break;
2454      default:
2455        if (jj_2_26(2147483647)) {
2456          label_37:
2457          while (true) {
2458            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2459            case IDENTIFIER:
2460              ;
2461              break;
2462            default:
2463              break label_37;
2464            }
2465            jj_consume_token(IDENTIFIER);
2466            jj_consume_token(DOT);
2467          }
2468          jj_consume_token(THIS);
2469        } else {
2470          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2471          case SUPER:
2472            jj_consume_token(SUPER);
2473            jj_consume_token(DOT);
2474            jj_consume_token(IDENTIFIER);
2475            break;
2476          case LPAREN:
2477            jj_consume_token(LPAREN);
2478            Expression();
2479            jj_consume_token(RPAREN);
2480            break;
2481          case NEW:
2482            AllocationExpression();
2483            break;
2484          default:
2485            if (jj_2_27(2147483647)) {
2486              ResultType();
2487              jj_consume_token(DOT);
2488              jj_consume_token(CLASS);
2489            } else {
2490              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2491              case IDENTIFIER:
2492                Name();
2493                break;
2494              default:
2495                jj_consume_token(-1);
2496                throw new ParseException();
2497              }
2498            }
2499          }
2500        }
2501      }
2502    } finally {
2503      trace_return("PrimaryPrefix");
2504    }
2505  }
2506
2507  final public void PrimarySuffix() throws ParseException {
2508    trace_call("PrimarySuffix");
2509    try {
2510      if (jj_2_28(2147483647)) {
2511        jj_consume_token(DOT);
2512        jj_consume_token(SUPER);
2513      } else if (jj_2_29(2147483647)) {
2514        jj_consume_token(DOT);
2515        jj_consume_token(THIS);
2516      } else if (jj_2_30(2)) {
2517        jj_consume_token(DOT);
2518        AllocationExpression();
2519      } else if (jj_2_31(3)) {
2520        MemberSelector();
2521      } else {
2522        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2523        case LBRACKET:
2524          jj_consume_token(LBRACKET);
2525          Expression();
2526          jj_consume_token(RBRACKET);
2527          break;
2528        case DOT:
2529          jj_consume_token(DOT);
2530          jj_consume_token(IDENTIFIER);
2531          break;
2532        case LPAREN:
2533          Arguments();
2534          break;
2535        default:
2536          jj_consume_token(-1);
2537          throw new ParseException();
2538        }
2539      }
2540    } finally {
2541      trace_return("PrimarySuffix");
2542    }
2543  }
2544
2545  final public void Literal() throws ParseException {
2546    trace_call("Literal");
2547    try {
2548      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2549      case INTEGER_LITERAL:
2550        jj_consume_token(INTEGER_LITERAL);
2551        break;
2552      case FLOATING_POINT_LITERAL:
2553        jj_consume_token(FLOATING_POINT_LITERAL);
2554        break;
2555      case CHARACTER_LITERAL:
2556        jj_consume_token(CHARACTER_LITERAL);
2557        break;
2558      case STRING_LITERAL:
2559        jj_consume_token(STRING_LITERAL);
2560        break;
2561      case FALSE:
2562      case TRUE:
2563        BooleanLiteral();
2564        break;
2565      case NULL:
2566        NullLiteral();
2567        break;
2568      default:
2569        jj_consume_token(-1);
2570        throw new ParseException();
2571      }
2572    } finally {
2573      trace_return("Literal");
2574    }
2575  }
2576
2577  final public void BooleanLiteral() throws ParseException {
2578    trace_call("BooleanLiteral");
2579    try {
2580      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2581      case TRUE:
2582        jj_consume_token(TRUE);
2583        break;
2584      case FALSE:
2585        jj_consume_token(FALSE);
2586        break;
2587      default:
2588        jj_consume_token(-1);
2589        throw new ParseException();
2590      }
2591    } finally {
2592      trace_return("BooleanLiteral");
2593    }
2594  }
2595
2596  final public void NullLiteral() throws ParseException {
2597    trace_call("NullLiteral");
2598    try {
2599      jj_consume_token(NULL);
2600    } finally {
2601      trace_return("NullLiteral");
2602    }
2603  }
2604
2605  final public void Arguments() throws ParseException {
2606    trace_call("Arguments");
2607    try {
2608      jj_consume_token(LPAREN);
2609      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2610      case BOOLEAN:
2611      case BYTE:
2612      case CHAR:
2613      case DOUBLE:
2614      case FALSE:
2615      case FLOAT:
2616      case INT:
2617      case LONG:
2618      case NEW:
2619      case NULL:
2620      case SHORT:
2621      case SUPER:
2622      case THIS:
2623      case TRUE:
2624      case VOID:
2625      case INTEGER_LITERAL:
2626      case FLOATING_POINT_LITERAL:
2627      case CHARACTER_LITERAL:
2628      case STRING_LITERAL:
2629      case IDENTIFIER:
2630      case LPAREN:
2631      case BANG:
2632      case TILDE:
2633      case INCR:
2634      case DECR:
2635      case PLUS:
2636      case MINUS:
2637        ArgumentList();
2638        break;
2639      default:
2640        ;
2641      }
2642      jj_consume_token(RPAREN);
2643    } finally {
2644      trace_return("Arguments");
2645    }
2646  }
2647
2648  final public void ArgumentList() throws ParseException {
2649    trace_call("ArgumentList");
2650    try {
2651      Expression();
2652      label_38:
2653      while (true) {
2654        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2655        case COMMA:
2656          ;
2657          break;
2658        default:
2659          break label_38;
2660        }
2661        jj_consume_token(COMMA);
2662        Expression();
2663      }
2664    } finally {
2665      trace_return("ArgumentList");
2666    }
2667  }
2668
2669  final public void AllocationExpression() throws ParseException {
2670    trace_call("AllocationExpression");
2671    try {
2672      if (jj_2_32(2)) {
2673        jj_consume_token(NEW);
2674        PrimitiveType();
2675        ArrayDimsAndInits();
2676      } else {
2677        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2678        case NEW:
2679          jj_consume_token(NEW);
2680          ClassOrInterfaceType();
2681          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2682          case LT:
2683            TypeArguments();
2684            break;
2685          default:
2686            ;
2687          }
2688          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2689          case LBRACKET:
2690            ArrayDimsAndInits();
2691            break;
2692          case LPAREN:
2693            Arguments();
2694            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2695            case LBRACE:
2696              ClassOrInterfaceBody(false);
2697              break;
2698            default:
2699              ;
2700            }
2701            break;
2702          default:
2703            jj_consume_token(-1);
2704            throw new ParseException();
2705          }
2706          break;
2707        default:
2708          jj_consume_token(-1);
2709          throw new ParseException();
2710        }
2711      }
2712    } finally {
2713      trace_return("AllocationExpression");
2714    }
2715  }
2716
2717/*
2718 * The third LOOKAHEAD specification below is to parse to PrimarySuffix
2719 * if there is an expression between the "[...]".
2720 */
2721  final public void ArrayDimsAndInits() throws ParseException {
2722    trace_call("ArrayDimsAndInits");
2723    try {
2724      if (jj_2_35(2)) {
2725        label_39:
2726        while (true) {
2727          jj_consume_token(LBRACKET);
2728          Expression();
2729          jj_consume_token(RBRACKET);
2730          if (jj_2_33(2)) {
2731            ;
2732          } else {
2733            break label_39;
2734          }
2735        }
2736        label_40:
2737        while (true) {
2738          if (jj_2_34(2)) {
2739            ;
2740          } else {
2741            break label_40;
2742          }
2743          jj_consume_token(LBRACKET);
2744          jj_consume_token(RBRACKET);
2745        }
2746      } else {
2747        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2748        case LBRACKET:
2749          label_41:
2750          while (true) {
2751            jj_consume_token(LBRACKET);
2752            jj_consume_token(RBRACKET);
2753            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2754            case LBRACKET:
2755              ;
2756              break;
2757            default:
2758              break label_41;
2759            }
2760          }
2761          ArrayInitializer();
2762          break;
2763        default:
2764          jj_consume_token(-1);
2765          throw new ParseException();
2766        }
2767      }
2768    } finally {
2769      trace_return("ArrayDimsAndInits");
2770    }
2771  }
2772
2773/*
2774 * Statement syntax follows.
2775 */
2776  final public void Statement() throws ParseException {
2777    trace_call("Statement");
2778    try {
2779      if (jj_2_36(2)) {
2780        LabeledStatement();
2781      } else {
2782        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2783        case ASSERT:
2784          AssertStatement();
2785          break;
2786        case LBRACE:
2787          Block();
2788          break;
2789        case SEMICOLON:
2790          EmptyStatement();
2791          break;
2792        case BOOLEAN:
2793        case BYTE:
2794        case CHAR:
2795        case DOUBLE:
2796        case FALSE:
2797        case FLOAT:
2798        case INT:
2799        case LONG:
2800        case NEW:
2801        case NULL:
2802        case SHORT:
2803        case SUPER:
2804        case THIS:
2805        case TRUE:
2806        case VOID:
2807        case INTEGER_LITERAL:
2808        case FLOATING_POINT_LITERAL:
2809        case CHARACTER_LITERAL:
2810        case STRING_LITERAL:
2811        case IDENTIFIER:
2812        case LPAREN:
2813        case INCR:
2814        case DECR:
2815          StatementExpression();
2816          jj_consume_token(SEMICOLON);
2817          break;
2818        case SWITCH:
2819          SwitchStatement();
2820          break;
2821        case IF:
2822          IfStatement();
2823          break;
2824        case WHILE:
2825          WhileStatement();
2826          break;
2827        case DO:
2828          DoStatement();
2829          break;
2830        case FOR:
2831          ForStatement();
2832          break;
2833        case BREAK:
2834          BreakStatement();
2835          break;
2836        case CONTINUE:
2837          ContinueStatement();
2838          break;
2839        case RETURN:
2840          ReturnStatement();
2841          break;
2842        case THROW:
2843          ThrowStatement();
2844          break;
2845        case SYNCHRONIZED:
2846          SynchronizedStatement();
2847          break;
2848        case TRY:
2849          TryStatement();
2850          break;
2851        default:
2852          jj_consume_token(-1);
2853          throw new ParseException();
2854        }
2855      }
2856    } finally {
2857      trace_return("Statement");
2858    }
2859  }
2860
2861  final public void AssertStatement() throws ParseException {
2862    trace_call("AssertStatement");
2863    try {
2864      jj_consume_token(ASSERT);
2865      Expression();
2866      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2867      case COLON:
2868        jj_consume_token(COLON);
2869        Expression();
2870        break;
2871      default:
2872        ;
2873      }
2874      jj_consume_token(SEMICOLON);
2875    } finally {
2876      trace_return("AssertStatement");
2877    }
2878  }
2879
2880  final public void LabeledStatement() throws ParseException {
2881    trace_call("LabeledStatement");
2882    try {
2883      jj_consume_token(IDENTIFIER);
2884      jj_consume_token(COLON);
2885      Statement();
2886    } finally {
2887      trace_return("LabeledStatement");
2888    }
2889  }
2890
2891  final public void Block() throws ParseException {
2892    trace_call("Block");
2893    try {
2894      jj_consume_token(LBRACE);
2895      label_42:
2896      while (true) {
2897        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2898        case ABSTRACT:
2899        case ASSERT:
2900        case BOOLEAN:
2901        case BREAK:
2902        case BYTE:
2903        case CHAR:
2904        case CLASS:
2905        case CONTINUE:
2906        case DO:
2907        case DOUBLE:
2908        case FALSE:
2909        case FINAL:
2910        case FLOAT:
2911        case FOR:
2912        case IF:
2913        case INT:
2914        case INTERFACE:
2915        case LONG:
2916        case NATIVE:
2917        case NEW:
2918        case NULL:
2919        case PRIVATE:
2920        case PROTECTED:
2921        case PUBLIC:
2922        case RETURN:
2923        case SHORT:
2924        case STATIC:
2925        case STRICTFP:
2926        case SUPER:
2927        case SWITCH:
2928        case SYNCHRONIZED:
2929        case THIS:
2930        case THROW:
2931        case TRANSIENT:
2932        case TRUE:
2933        case TRY:
2934        case VOID:
2935        case VOLATILE:
2936        case WHILE:
2937        case INTEGER_LITERAL:
2938        case FLOATING_POINT_LITERAL:
2939        case CHARACTER_LITERAL:
2940        case STRING_LITERAL:
2941        case IDENTIFIER:
2942        case LPAREN:
2943        case LBRACE:
2944        case SEMICOLON:
2945        case AT:
2946        case INCR:
2947        case DECR:
2948          ;
2949          break;
2950        default:
2951          break label_42;
2952        }
2953        BlockStatement();
2954      }
2955      jj_consume_token(RBRACE);
2956    } finally {
2957      trace_return("Block");
2958    }
2959  }
2960
2961  final public void BlockStatement() throws ParseException {
2962    trace_call("BlockStatement");
2963    try {
2964      if (jj_2_37(2147483647)) {
2965        LocalVariableDeclaration();
2966        jj_consume_token(SEMICOLON);
2967      } else {
2968        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2969        case ASSERT:
2970        case BOOLEAN:
2971        case BREAK:
2972        case BYTE:
2973        case CHAR:
2974        case CONTINUE:
2975        case DO:
2976        case DOUBLE:
2977        case FALSE:
2978        case FLOAT:
2979        case FOR:
2980        case IF:
2981        case INT:
2982        case LONG:
2983        case NEW:
2984        case NULL:
2985        case RETURN:
2986        case SHORT:
2987        case SUPER:
2988        case SWITCH:
2989        case SYNCHRONIZED:
2990        case THIS:
2991        case THROW:
2992        case TRUE:
2993        case TRY:
2994        case VOID:
2995        case WHILE:
2996        case INTEGER_LITERAL:
2997        case FLOATING_POINT_LITERAL:
2998        case CHARACTER_LITERAL:
2999        case STRING_LITERAL:
3000        case IDENTIFIER:
3001        case LPAREN:
3002        case LBRACE:
3003        case SEMICOLON:
3004        case INCR:
3005        case DECR:
3006          Statement();
3007          break;
3008        case CLASS:
3009        case INTERFACE:
3010          ClassOrInterfaceDeclaration(0);
3011          break;
3012        default:
3013          jj_consume_token(-1);
3014          throw new ParseException();
3015        }
3016      }
3017    } finally {
3018      trace_return("BlockStatement");
3019    }
3020  }
3021
3022  final public void LocalVariableDeclaration() throws ParseException {
3023    trace_call("LocalVariableDeclaration");
3024    try {
3025      Modifiers();
3026      Type();
3027      VariableDeclarator();
3028      label_43:
3029      while (true) {
3030        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3031        case COMMA:
3032          ;
3033          break;
3034        default:
3035          break label_43;
3036        }
3037        jj_consume_token(COMMA);
3038        VariableDeclarator();
3039      }
3040    } finally {
3041      trace_return("LocalVariableDeclaration");
3042    }
3043  }
3044
3045  final public void EmptyStatement() throws ParseException {
3046    trace_call("EmptyStatement");
3047    try {
3048      jj_consume_token(SEMICOLON);
3049    } finally {
3050      trace_return("EmptyStatement");
3051    }
3052  }
3053
3054  final public void StatementExpression() throws ParseException {
3055    trace_call("StatementExpression");
3056    try {
3057      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3058      case INCR:
3059        PreIncrementExpression();
3060        break;
3061      case DECR:
3062        PreDecrementExpression();
3063        break;
3064      case BOOLEAN:
3065      case BYTE:
3066      case CHAR:
3067      case DOUBLE:
3068      case FALSE:
3069      case FLOAT:
3070      case INT:
3071      case LONG:
3072      case NEW:
3073      case NULL:
3074      case SHORT:
3075      case SUPER:
3076      case THIS:
3077      case TRUE:
3078      case VOID:
3079      case INTEGER_LITERAL:
3080      case FLOATING_POINT_LITERAL:
3081      case CHARACTER_LITERAL:
3082      case STRING_LITERAL:
3083      case IDENTIFIER:
3084      case LPAREN:
3085        PrimaryExpression();
3086        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3087        case ASSIGN:
3088        case INCR:
3089        case DECR:
3090        case PLUSASSIGN:
3091        case MINUSASSIGN:
3092        case STARASSIGN:
3093        case SLASHASSIGN:
3094        case ANDASSIGN:
3095        case ORASSIGN:
3096        case XORASSIGN:
3097        case REMASSIGN:
3098        case LSHIFTASSIGN:
3099        case RSIGNEDSHIFTASSIGN:
3100        case RUNSIGNEDSHIFTASSIGN:
3101          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3102          case INCR:
3103            jj_consume_token(INCR);
3104            break;
3105          case DECR:
3106            jj_consume_token(DECR);
3107            break;
3108          case ASSIGN:
3109          case PLUSASSIGN:
3110          case MINUSASSIGN:
3111          case STARASSIGN:
3112          case SLASHASSIGN:
3113          case ANDASSIGN:
3114          case ORASSIGN:
3115          case XORASSIGN:
3116          case REMASSIGN:
3117          case LSHIFTASSIGN:
3118          case RSIGNEDSHIFTASSIGN:
3119          case RUNSIGNEDSHIFTASSIGN:
3120            AssignmentOperator();
3121            Expression();
3122            break;
3123          default:
3124            jj_consume_token(-1);
3125            throw new ParseException();
3126          }
3127          break;
3128        default:
3129          ;
3130        }
3131        break;
3132      default:
3133        jj_consume_token(-1);
3134        throw new ParseException();
3135      }
3136    } finally {
3137      trace_return("StatementExpression");
3138    }
3139  }
3140
3141  final public void SwitchStatement() throws ParseException {
3142    trace_call("SwitchStatement");
3143    try {
3144      jj_consume_token(SWITCH);
3145      jj_consume_token(LPAREN);
3146      Expression();
3147      jj_consume_token(RPAREN);
3148      jj_consume_token(LBRACE);
3149      label_44:
3150      while (true) {
3151        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3152        case CASE:
3153        case _DEFAULT:
3154          ;
3155          break;
3156        default:
3157          break label_44;
3158        }
3159        SwitchLabel();
3160        label_45:
3161        while (true) {
3162          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3163          case ABSTRACT:
3164          case ASSERT:
3165          case BOOLEAN:
3166          case BREAK:
3167          case BYTE:
3168          case CHAR:
3169          case CLASS:
3170          case CONTINUE:
3171          case DO:
3172          case DOUBLE:
3173          case FALSE:
3174          case FINAL:
3175          case FLOAT:
3176          case FOR:
3177          case IF:
3178          case INT:
3179          case INTERFACE:
3180          case LONG:
3181          case NATIVE:
3182          case NEW:
3183          case NULL:
3184          case PRIVATE:
3185          case PROTECTED:
3186          case PUBLIC:
3187          case RETURN:
3188          case SHORT:
3189          case STATIC:
3190          case STRICTFP:
3191          case SUPER:
3192          case SWITCH:
3193          case SYNCHRONIZED:
3194          case THIS:
3195          case THROW:
3196          case TRANSIENT:
3197          case TRUE:
3198          case TRY:
3199          case VOID:
3200          case VOLATILE:
3201          case WHILE:
3202          case INTEGER_LITERAL:
3203          case FLOATING_POINT_LITERAL:
3204          case CHARACTER_LITERAL:
3205          case STRING_LITERAL:
3206          case IDENTIFIER:
3207          case LPAREN:
3208          case LBRACE:
3209          case SEMICOLON:
3210          case AT:
3211          case INCR:
3212          case DECR:
3213            ;
3214            break;
3215          default:
3216            break label_45;
3217          }
3218          BlockStatement();
3219        }
3220      }
3221      jj_consume_token(RBRACE);
3222    } finally {
3223      trace_return("SwitchStatement");
3224    }
3225  }
3226
3227  final public void SwitchLabel() throws ParseException {
3228    trace_call("SwitchLabel");
3229    try {
3230      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3231      case CASE:
3232        jj_consume_token(CASE);
3233        Expression();
3234        jj_consume_token(COLON);
3235        break;
3236      case _DEFAULT:
3237        jj_consume_token(_DEFAULT);
3238        jj_consume_token(COLON);
3239        break;
3240      default:
3241        jj_consume_token(-1);
3242        throw new ParseException();
3243      }
3244    } finally {
3245      trace_return("SwitchLabel");
3246    }
3247  }
3248
3249  final public void IfStatement() throws ParseException {
3250    trace_call("IfStatement");
3251    try {
3252      jj_consume_token(IF);
3253      jj_consume_token(LPAREN);
3254      Expression();
3255      jj_consume_token(RPAREN);
3256      Statement();
3257      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3258      case ELSE:
3259        jj_consume_token(ELSE);
3260        Statement();
3261        break;
3262      default:
3263        ;
3264      }
3265    } finally {
3266      trace_return("IfStatement");
3267    }
3268  }
3269
3270  final public void WhileStatement() throws ParseException {
3271    trace_call("WhileStatement");
3272    try {
3273      jj_consume_token(WHILE);
3274      jj_consume_token(LPAREN);
3275      Expression();
3276      jj_consume_token(RPAREN);
3277      Statement();
3278    } finally {
3279      trace_return("WhileStatement");
3280    }
3281  }
3282
3283  final public void DoStatement() throws ParseException {
3284    trace_call("DoStatement");
3285    try {
3286      jj_consume_token(DO);
3287      Statement();
3288      jj_consume_token(WHILE);
3289      jj_consume_token(LPAREN);
3290      Expression();
3291      jj_consume_token(RPAREN);
3292      jj_consume_token(SEMICOLON);
3293    } finally {
3294      trace_return("DoStatement");
3295    }
3296  }
3297
3298  final public void ForStatement() throws ParseException {
3299    trace_call("ForStatement");
3300    try {
3301      jj_consume_token(FOR);
3302      jj_consume_token(LPAREN);
3303      if (jj_2_38(2147483647)) {
3304        Modifiers();
3305        Type();
3306        jj_consume_token(IDENTIFIER);
3307        jj_consume_token(COLON);
3308        Expression();
3309      } else {
3310        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3311        case ABSTRACT:
3312        case BOOLEAN:
3313        case BYTE:
3314        case CHAR:
3315        case DOUBLE:
3316        case FALSE:
3317        case FINAL:
3318        case FLOAT:
3319        case INT:
3320        case LONG:
3321        case NATIVE:
3322        case NEW:
3323        case NULL:
3324        case PRIVATE:
3325        case PROTECTED:
3326        case PUBLIC:
3327        case SHORT:
3328        case STATIC:
3329        case STRICTFP:
3330        case SUPER:
3331        case SYNCHRONIZED:
3332        case THIS:
3333        case TRANSIENT:
3334        case TRUE:
3335        case VOID:
3336        case VOLATILE:
3337        case INTEGER_LITERAL:
3338        case FLOATING_POINT_LITERAL:
3339        case CHARACTER_LITERAL:
3340        case STRING_LITERAL:
3341        case IDENTIFIER:
3342        case LPAREN:
3343        case SEMICOLON:
3344        case AT:
3345        case INCR:
3346        case DECR:
3347          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3348          case ABSTRACT:
3349          case BOOLEAN:
3350          case BYTE:
3351          case CHAR:
3352          case DOUBLE:
3353          case FALSE:
3354          case FINAL:
3355          case FLOAT:
3356          case INT:
3357          case LONG:
3358          case NATIVE:
3359          case NEW:
3360          case NULL:
3361          case PRIVATE:
3362          case PROTECTED:
3363          case PUBLIC:
3364          case SHORT:
3365          case STATIC:
3366          case STRICTFP:
3367          case SUPER:
3368          case SYNCHRONIZED:
3369          case THIS:
3370          case TRANSIENT:
3371          case TRUE:
3372          case VOID:
3373          case VOLATILE:
3374          case INTEGER_LITERAL:
3375          case FLOATING_POINT_LITERAL:
3376          case CHARACTER_LITERAL:
3377          case STRING_LITERAL:
3378          case IDENTIFIER:
3379          case LPAREN:
3380          case AT:
3381          case INCR:
3382          case DECR:
3383            ForInit();
3384            break;
3385          default:
3386            ;
3387          }
3388          jj_consume_token(SEMICOLON);
3389          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3390          case BOOLEAN:
3391          case BYTE:
3392          case CHAR:
3393          case DOUBLE:
3394          case FALSE:
3395          case FLOAT:
3396          case INT:
3397          case LONG:
3398          case NEW:
3399          case NULL:
3400          case SHORT:
3401          case SUPER:
3402          case THIS:
3403          case TRUE:
3404          case VOID:
3405          case INTEGER_LITERAL:
3406          case FLOATING_POINT_LITERAL:
3407          case CHARACTER_LITERAL:
3408          case STRING_LITERAL:
3409          case IDENTIFIER:
3410          case LPAREN:
3411          case BANG:
3412          case TILDE:
3413          case INCR:
3414          case DECR:
3415          case PLUS:
3416          case MINUS:
3417            Expression();
3418            break;
3419          default:
3420            ;
3421          }
3422          jj_consume_token(SEMICOLON);
3423          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3424          case BOOLEAN:
3425          case BYTE:
3426          case CHAR:
3427          case DOUBLE:
3428          case FALSE:
3429          case FLOAT:
3430          case INT:
3431          case LONG:
3432          case NEW:
3433          case NULL:
3434          case SHORT:
3435          case SUPER:
3436          case THIS:
3437          case TRUE:
3438          case VOID:
3439          case INTEGER_LITERAL:
3440          case FLOATING_POINT_LITERAL:
3441          case CHARACTER_LITERAL:
3442          case STRING_LITERAL:
3443          case IDENTIFIER:
3444          case LPAREN:
3445          case INCR:
3446          case DECR:
3447            ForUpdate();
3448            break;
3449          default:
3450            ;
3451          }
3452          break;
3453        default:
3454          jj_consume_token(-1);
3455          throw new ParseException();
3456        }
3457      }
3458      jj_consume_token(RPAREN);
3459      Statement();
3460    } finally {
3461      trace_return("ForStatement");
3462    }
3463  }
3464
3465  final public void ForInit() throws ParseException {
3466    trace_call("ForInit");
3467    try {
3468      if (jj_2_39(2147483647)) {
3469        LocalVariableDeclaration();
3470      } else {
3471        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3472        case BOOLEAN:
3473        case BYTE:
3474        case CHAR:
3475        case DOUBLE:
3476        case FALSE:
3477        case FLOAT:
3478        case INT:
3479        case LONG:
3480        case NEW:
3481        case NULL:
3482        case SHORT:
3483        case SUPER:
3484        case THIS:
3485        case TRUE:
3486        case VOID:
3487        case INTEGER_LITERAL:
3488        case FLOATING_POINT_LITERAL:
3489        case CHARACTER_LITERAL:
3490        case STRING_LITERAL:
3491        case IDENTIFIER:
3492        case LPAREN:
3493        case INCR:
3494        case DECR:
3495          StatementExpressionList();
3496          break;
3497        default:
3498          jj_consume_token(-1);
3499          throw new ParseException();
3500        }
3501      }
3502    } finally {
3503      trace_return("ForInit");
3504    }
3505  }
3506
3507  final public void StatementExpressionList() throws ParseException {
3508    trace_call("StatementExpressionList");
3509    try {
3510      StatementExpression();
3511      label_46:
3512      while (true) {
3513        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3514        case COMMA:
3515          ;
3516          break;
3517        default:
3518          break label_46;
3519        }
3520        jj_consume_token(COMMA);
3521        StatementExpression();
3522      }
3523    } finally {
3524      trace_return("StatementExpressionList");
3525    }
3526  }
3527
3528  final public void ForUpdate() throws ParseException {
3529    trace_call("ForUpdate");
3530    try {
3531      StatementExpressionList();
3532    } finally {
3533      trace_return("ForUpdate");
3534    }
3535  }
3536
3537  final public void BreakStatement() throws ParseException {
3538    trace_call("BreakStatement");
3539    try {
3540      jj_consume_token(BREAK);
3541      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3542      case IDENTIFIER:
3543        jj_consume_token(IDENTIFIER);
3544        break;
3545      default:
3546        ;
3547      }
3548      jj_consume_token(SEMICOLON);
3549    } finally {
3550      trace_return("BreakStatement");
3551    }
3552  }
3553
3554  final public void ContinueStatement() throws ParseException {
3555    trace_call("ContinueStatement");
3556    try {
3557      jj_consume_token(CONTINUE);
3558      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3559      case IDENTIFIER:
3560        jj_consume_token(IDENTIFIER);
3561        break;
3562      default:
3563        ;
3564      }
3565      jj_consume_token(SEMICOLON);
3566    } finally {
3567      trace_return("ContinueStatement");
3568    }
3569  }
3570
3571  final public void ReturnStatement() throws ParseException {
3572    trace_call("ReturnStatement");
3573    try {
3574      jj_consume_token(RETURN);
3575      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3576      case BOOLEAN:
3577      case BYTE:
3578      case CHAR:
3579      case DOUBLE:
3580      case FALSE:
3581      case FLOAT:
3582      case INT:
3583      case LONG:
3584      case NEW:
3585      case NULL:
3586      case SHORT:
3587      case SUPER:
3588      case THIS:
3589      case TRUE:
3590      case VOID:
3591      case INTEGER_LITERAL:
3592      case FLOATING_POINT_LITERAL:
3593      case CHARACTER_LITERAL:
3594      case STRING_LITERAL:
3595      case IDENTIFIER:
3596      case LPAREN:
3597      case BANG:
3598      case TILDE:
3599      case INCR:
3600      case DECR:
3601      case PLUS:
3602      case MINUS:
3603        Expression();
3604        break;
3605      default:
3606        ;
3607      }
3608      jj_consume_token(SEMICOLON);
3609    } finally {
3610      trace_return("ReturnStatement");
3611    }
3612  }
3613
3614  final public void ThrowStatement() throws ParseException {
3615    trace_call("ThrowStatement");
3616    try {
3617      jj_consume_token(THROW);
3618      Expression();
3619      jj_consume_token(SEMICOLON);
3620    } finally {
3621      trace_return("ThrowStatement");
3622    }
3623  }
3624
3625  final public void SynchronizedStatement() throws ParseException {
3626    trace_call("SynchronizedStatement");
3627    try {
3628      jj_consume_token(SYNCHRONIZED);
3629      jj_consume_token(LPAREN);
3630      Expression();
3631      jj_consume_token(RPAREN);
3632      Block();
3633    } finally {
3634      trace_return("SynchronizedStatement");
3635    }
3636  }
3637
3638  final public void TryStatement() throws ParseException {
3639    trace_call("TryStatement");
3640    try {
3641      jj_consume_token(TRY);
3642      Block();
3643      label_47:
3644      while (true) {
3645        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3646        case CATCH:
3647          ;
3648          break;
3649        default:
3650          break label_47;
3651        }
3652        jj_consume_token(CATCH);
3653        jj_consume_token(LPAREN);
3654        FormalParameter();
3655        jj_consume_token(RPAREN);
3656        Block();
3657      }
3658      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3659      case FINALLY:
3660        jj_consume_token(FINALLY);
3661        Block();
3662        break;
3663      default:
3664        ;
3665      }
3666    } finally {
3667      trace_return("TryStatement");
3668    }
3669  }
3670
3671/* We use productions to match >>>, >> and > so that we can keep the
3672 * type declaration syntax with generics clean
3673 */
3674  final public void RUNSIGNEDSHIFT() throws ParseException {
3675    trace_call("RUNSIGNEDSHIFT");
3676    try {
3677      if (getToken(1).kind == GT &&
3678                      ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
3679
3680      } else {
3681        jj_consume_token(-1);
3682        throw new ParseException();
3683      }
3684      jj_consume_token(GT);
3685      jj_consume_token(GT);
3686      jj_consume_token(GT);
3687    } finally {
3688      trace_return("RUNSIGNEDSHIFT");
3689    }
3690  }
3691
3692  final public void RSIGNEDSHIFT() throws ParseException {
3693    trace_call("RSIGNEDSHIFT");
3694    try {
3695      if (getToken(1).kind == GT &&
3696                      ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
3697
3698      } else {
3699        jj_consume_token(-1);
3700        throw new ParseException();
3701      }
3702      jj_consume_token(GT);
3703      jj_consume_token(GT);
3704    } finally {
3705      trace_return("RSIGNEDSHIFT");
3706    }
3707  }
3708
3709/* Annotation syntax follows. */
3710  final public void Annotation() throws ParseException {
3711    trace_call("Annotation");
3712    try {
3713      if (jj_2_40(2147483647)) {
3714        NormalAnnotation();
3715      } else if (jj_2_41(2147483647)) {
3716        SingleMemberAnnotation();
3717      } else {
3718        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3719        case AT:
3720          MarkerAnnotation();
3721          break;
3722        default:
3723          jj_consume_token(-1);
3724          throw new ParseException();
3725        }
3726      }
3727    } finally {
3728      trace_return("Annotation");
3729    }
3730  }
3731
3732  final public void NormalAnnotation() throws ParseException {
3733    trace_call("NormalAnnotation");
3734    try {
3735      jj_consume_token(AT);
3736      Name();
3737      jj_consume_token(LPAREN);
3738      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3739      case IDENTIFIER:
3740        MemberValuePairs();
3741        break;
3742      default:
3743        ;
3744      }
3745      jj_consume_token(RPAREN);
3746    } finally {
3747      trace_return("NormalAnnotation");
3748    }
3749  }
3750
3751  final public void MarkerAnnotation() throws ParseException {
3752    trace_call("MarkerAnnotation");
3753    try {
3754      jj_consume_token(AT);
3755      Name();
3756    } finally {
3757      trace_return("MarkerAnnotation");
3758    }
3759  }
3760
3761  final public void SingleMemberAnnotation() throws ParseException {
3762    trace_call("SingleMemberAnnotation");
3763    try {
3764      jj_consume_token(AT);
3765      Name();
3766      jj_consume_token(LPAREN);
3767      MemberValue();
3768      jj_consume_token(RPAREN);
3769    } finally {
3770      trace_return("SingleMemberAnnotation");
3771    }
3772  }
3773
3774  final public void MemberValuePairs() throws ParseException {
3775    trace_call("MemberValuePairs");
3776    try {
3777      MemberValuePair();
3778      label_48:
3779      while (true) {
3780        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3781        case COMMA:
3782          ;
3783          break;
3784        default:
3785          break label_48;
3786        }
3787        jj_consume_token(COMMA);
3788        MemberValuePair();
3789      }
3790    } finally {
3791      trace_return("MemberValuePairs");
3792    }
3793  }
3794
3795  final public void MemberValuePair() throws ParseException {
3796    trace_call("MemberValuePair");
3797    try {
3798      jj_consume_token(IDENTIFIER);
3799      jj_consume_token(ASSIGN);
3800      MemberValue();
3801    } finally {
3802      trace_return("MemberValuePair");
3803    }
3804  }
3805
3806  final public void MemberValue() throws ParseException {
3807    trace_call("MemberValue");
3808    try {
3809      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3810      case AT:
3811        Annotation();
3812        break;
3813      case LBRACE:
3814        MemberValueArrayInitializer();
3815        break;
3816      case BOOLEAN:
3817      case BYTE:
3818      case CHAR:
3819      case DOUBLE:
3820      case FALSE:
3821      case FLOAT:
3822      case INT:
3823      case LONG:
3824      case NEW:
3825      case NULL:
3826      case SHORT:
3827      case SUPER:
3828      case THIS:
3829      case TRUE:
3830      case VOID:
3831      case INTEGER_LITERAL:
3832      case FLOATING_POINT_LITERAL:
3833      case CHARACTER_LITERAL:
3834      case STRING_LITERAL:
3835      case IDENTIFIER:
3836      case LPAREN:
3837      case BANG:
3838      case TILDE:
3839      case INCR:
3840      case DECR:
3841      case PLUS:
3842      case MINUS:
3843        ConditionalExpression();
3844        break;
3845      default:
3846        jj_consume_token(-1);
3847        throw new ParseException();
3848      }
3849    } finally {
3850      trace_return("MemberValue");
3851    }
3852  }
3853
3854  final public void MemberValueArrayInitializer() throws ParseException {
3855    trace_call("MemberValueArrayInitializer");
3856    try {
3857      jj_consume_token(LBRACE);
3858      MemberValue();
3859      label_49:
3860      while (true) {
3861        if (jj_2_42(2)) {
3862          ;
3863        } else {
3864          break label_49;
3865        }
3866        jj_consume_token(COMMA);
3867        MemberValue();
3868      }
3869      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3870      case COMMA:
3871        jj_consume_token(COMMA);
3872        break;
3873      default:
3874        ;
3875      }
3876      jj_consume_token(RBRACE);
3877    } finally {
3878      trace_return("MemberValueArrayInitializer");
3879    }
3880  }
3881
3882/* Annotation Types. */
3883  final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
3884    trace_call("AnnotationTypeDeclaration");
3885    try {
3886      jj_consume_token(AT);
3887      jj_consume_token(INTERFACE);
3888      jj_consume_token(IDENTIFIER);
3889      AnnotationTypeBody();
3890    } finally {
3891      trace_return("AnnotationTypeDeclaration");
3892    }
3893  }
3894
3895  final public void AnnotationTypeBody() throws ParseException {
3896    trace_call("AnnotationTypeBody");
3897    try {
3898      jj_consume_token(LBRACE);
3899      label_50:
3900      while (true) {
3901        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3902        case ABSTRACT:
3903        case BOOLEAN:
3904        case BYTE:
3905        case CHAR:
3906        case CLASS:
3907        case DOUBLE:
3908        case ENUM:
3909        case FINAL:
3910        case FLOAT:
3911        case INT:
3912        case INTERFACE:
3913        case LONG:
3914        case NATIVE:
3915        case PRIVATE:
3916        case PROTECTED:
3917        case PUBLIC:
3918        case SHORT:
3919        case STATIC:
3920        case STRICTFP:
3921        case SYNCHRONIZED:
3922        case TRANSIENT:
3923        case VOLATILE:
3924        case IDENTIFIER:
3925        case SEMICOLON:
3926        case AT:
3927          ;
3928          break;
3929        default:
3930          break label_50;
3931        }
3932        AnnotationTypeMemberDeclaration();
3933      }
3934      jj_consume_token(RBRACE);
3935    } finally {
3936      trace_return("AnnotationTypeBody");
3937    }
3938  }
3939
3940  final public void AnnotationTypeMemberDeclaration() throws ParseException {
3941    trace_call("AnnotationTypeMemberDeclaration");
3942    try {
3943   int modifiers;
3944      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3945      case ABSTRACT:
3946      case BOOLEAN:
3947      case BYTE:
3948      case CHAR:
3949      case CLASS:
3950      case DOUBLE:
3951      case ENUM:
3952      case FINAL:
3953      case FLOAT:
3954      case INT:
3955      case INTERFACE:
3956      case LONG:
3957      case NATIVE:
3958      case PRIVATE:
3959      case PROTECTED:
3960      case PUBLIC:
3961      case SHORT:
3962      case STATIC:
3963      case STRICTFP:
3964      case SYNCHRONIZED:
3965      case TRANSIENT:
3966      case VOLATILE:
3967      case IDENTIFIER:
3968      case AT:
3969        modifiers = Modifiers();
3970        if (jj_2_43(2147483647)) {
3971          Type();
3972          jj_consume_token(IDENTIFIER);
3973          jj_consume_token(LPAREN);
3974          jj_consume_token(RPAREN);
3975          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3976          case _DEFAULT:
3977            DefaultValue();
3978            break;
3979          default:
3980            ;
3981          }
3982          jj_consume_token(SEMICOLON);
3983        } else {
3984          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3985          case CLASS:
3986          case INTERFACE:
3987            ClassOrInterfaceDeclaration(modifiers);
3988            break;
3989          case ENUM:
3990            EnumDeclaration(modifiers);
3991            break;
3992          case AT:
3993            AnnotationTypeDeclaration(modifiers);
3994            break;
3995          case BOOLEAN:
3996          case BYTE:
3997          case CHAR:
3998          case DOUBLE:
3999          case FLOAT:
4000          case INT:
4001          case LONG:
4002          case SHORT:
4003          case IDENTIFIER:
4004            FieldDeclaration(modifiers);
4005            break;
4006          default:
4007            jj_consume_token(-1);
4008            throw new ParseException();
4009          }
4010        }
4011        break;
4012      case SEMICOLON:
4013        jj_consume_token(SEMICOLON);
4014        break;
4015      default:
4016        jj_consume_token(-1);
4017        throw new ParseException();
4018      }
4019    } finally {
4020      trace_return("AnnotationTypeMemberDeclaration");
4021    }
4022  }
4023
4024  final public void DefaultValue() throws ParseException {
4025    trace_call("DefaultValue");
4026    try {
4027      jj_consume_token(_DEFAULT);
4028      MemberValue();
4029    } finally {
4030      trace_return("DefaultValue");
4031    }
4032  }
4033
4034  private boolean jj_2_1(int xla) {
4035    jj_la = xla; jj_lastpos = jj_scanpos = token;
4036    try { return !jj_3_1(); }
4037    catch(LookaheadSuccess ls) { return true; }
4038  }
4039
4040  private boolean jj_2_2(int xla) {
4041    jj_la = xla; jj_lastpos = jj_scanpos = token;
4042    try { return !jj_3_2(); }
4043    catch(LookaheadSuccess ls) { return true; }
4044  }
4045
4046  private boolean jj_2_3(int xla) {
4047    jj_la = xla; jj_lastpos = jj_scanpos = token;
4048    try { return !jj_3_3(); }
4049    catch(LookaheadSuccess ls) { return true; }
4050  }
4051
4052  private boolean jj_2_4(int xla) {
4053    jj_la = xla; jj_lastpos = jj_scanpos = token;
4054    try { return !jj_3_4(); }
4055    catch(LookaheadSuccess ls) { return true; }
4056  }
4057
4058  private boolean jj_2_5(int xla) {
4059    jj_la = xla; jj_lastpos = jj_scanpos = token;
4060    try { return !jj_3_5(); }
4061    catch(LookaheadSuccess ls) { return true; }
4062  }
4063
4064  private boolean jj_2_6(int xla) {
4065    jj_la = xla; jj_lastpos = jj_scanpos = token;
4066    try { return !jj_3_6(); }
4067    catch(LookaheadSuccess ls) { return true; }
4068  }
4069
4070  private boolean jj_2_7(int xla) {
4071    jj_la = xla; jj_lastpos = jj_scanpos = token;
4072    try { return !jj_3_7(); }
4073    catch(LookaheadSuccess ls) { return true; }
4074  }
4075
4076  private boolean jj_2_8(int xla) {
4077    jj_la = xla; jj_lastpos = jj_scanpos = token;
4078    try { return !jj_3_8(); }
4079    catch(LookaheadSuccess ls) { return true; }
4080  }
4081
4082  private boolean jj_2_9(int xla) {
4083    jj_la = xla; jj_lastpos = jj_scanpos = token;
4084    try { return !jj_3_9(); }
4085    catch(LookaheadSuccess ls) { return true; }
4086  }
4087
4088  private boolean jj_2_10(int xla) {
4089    jj_la = xla; jj_lastpos = jj_scanpos = token;
4090    try { return !jj_3_10(); }
4091    catch(LookaheadSuccess ls) { return true; }
4092  }
4093
4094  private boolean jj_2_11(int xla) {
4095    jj_la = xla; jj_lastpos = jj_scanpos = token;
4096    try { return !jj_3_11(); }
4097    catch(LookaheadSuccess ls) { return true; }
4098  }
4099
4100  private boolean jj_2_12(int xla) {
4101    jj_la = xla; jj_lastpos = jj_scanpos = token;
4102    try { return !jj_3_12(); }
4103    catch(LookaheadSuccess ls) { return true; }
4104  }
4105
4106  private boolean jj_2_13(int xla) {
4107    jj_la = xla; jj_lastpos = jj_scanpos = token;
4108    try { return !jj_3_13(); }
4109    catch(LookaheadSuccess ls) { return true; }
4110  }
4111
4112  private boolean jj_2_14(int xla) {
4113    jj_la = xla; jj_lastpos = jj_scanpos = token;
4114    try { return !jj_3_14(); }
4115    catch(LookaheadSuccess ls) { return true; }
4116  }
4117
4118  private boolean jj_2_15(int xla) {
4119    jj_la = xla; jj_lastpos = jj_scanpos = token;
4120    try { return !jj_3_15(); }
4121    catch(LookaheadSuccess ls) { return true; }
4122  }
4123
4124  private boolean jj_2_16(int xla) {
4125    jj_la = xla; jj_lastpos = jj_scanpos = token;
4126    try { return !jj_3_16(); }
4127    catch(LookaheadSuccess ls) { return true; }
4128  }
4129
4130  private boolean jj_2_17(int xla) {
4131    jj_la = xla; jj_lastpos = jj_scanpos = token;
4132    try { return !jj_3_17(); }
4133    catch(LookaheadSuccess ls) { return true; }
4134  }
4135
4136  private boolean jj_2_18(int xla) {
4137    jj_la = xla; jj_lastpos = jj_scanpos = token;
4138    try { return !jj_3_18(); }
4139    catch(LookaheadSuccess ls) { return true; }
4140  }
4141
4142  private boolean jj_2_19(int xla) {
4143    jj_la = xla; jj_lastpos = jj_scanpos = token;
4144    try { return !jj_3_19(); }
4145    catch(LookaheadSuccess ls) { return true; }
4146  }
4147
4148  private boolean jj_2_20(int xla) {
4149    jj_la = xla; jj_lastpos = jj_scanpos = token;
4150    try { return !jj_3_20(); }
4151    catch(LookaheadSuccess ls) { return true; }
4152  }
4153
4154  private boolean jj_2_21(int xla) {
4155    jj_la = xla; jj_lastpos = jj_scanpos = token;
4156    try { return !jj_3_21(); }
4157    catch(LookaheadSuccess ls) { return true; }
4158  }
4159
4160  private boolean jj_2_22(int xla) {
4161    jj_la = xla; jj_lastpos = jj_scanpos = token;
4162    try { return !jj_3_22(); }
4163    catch(LookaheadSuccess ls) { return true; }
4164  }
4165
4166  private boolean jj_2_23(int xla) {
4167    jj_la = xla; jj_lastpos = jj_scanpos = token;
4168    try { return !jj_3_23(); }
4169    catch(LookaheadSuccess ls) { return true; }
4170  }
4171
4172  private boolean jj_2_24(int xla) {
4173    jj_la = xla; jj_lastpos = jj_scanpos = token;
4174    try { return !jj_3_24(); }
4175    catch(LookaheadSuccess ls) { return true; }
4176  }
4177
4178  private boolean jj_2_25(int xla) {
4179    jj_la = xla; jj_lastpos = jj_scanpos = token;
4180    try { return !jj_3_25(); }
4181    catch(LookaheadSuccess ls) { return true; }
4182  }
4183
4184  private boolean jj_2_26(int xla) {
4185    jj_la = xla; jj_lastpos = jj_scanpos = token;
4186    try { return !jj_3_26(); }
4187    catch(LookaheadSuccess ls) { return true; }
4188  }
4189
4190  private boolean jj_2_27(int xla) {
4191    jj_la = xla; jj_lastpos = jj_scanpos = token;
4192    try { return !jj_3_27(); }
4193    catch(LookaheadSuccess ls) { return true; }
4194  }
4195
4196  private boolean jj_2_28(int xla) {
4197    jj_la = xla; jj_lastpos = jj_scanpos = token;
4198    try { return !jj_3_28(); }
4199    catch(LookaheadSuccess ls) { return true; }
4200  }
4201
4202  private boolean jj_2_29(int xla) {
4203    jj_la = xla; jj_lastpos = jj_scanpos = token;
4204    try { return !jj_3_29(); }
4205    catch(LookaheadSuccess ls) { return true; }
4206  }
4207
4208  private boolean jj_2_30(int xla) {
4209    jj_la = xla; jj_lastpos = jj_scanpos = token;
4210    try { return !jj_3_30(); }
4211    catch(LookaheadSuccess ls) { return true; }
4212  }
4213
4214  private boolean jj_2_31(int xla) {
4215    jj_la = xla; jj_lastpos = jj_scanpos = token;
4216    try { return !jj_3_31(); }
4217    catch(LookaheadSuccess ls) { return true; }
4218  }
4219
4220  private boolean jj_2_32(int xla) {
4221    jj_la = xla; jj_lastpos = jj_scanpos = token;
4222    try { return !jj_3_32(); }
4223    catch(LookaheadSuccess ls) { return true; }
4224  }
4225
4226  private boolean jj_2_33(int xla) {
4227    jj_la = xla; jj_lastpos = jj_scanpos = token;
4228    try { return !jj_3_33(); }
4229    catch(LookaheadSuccess ls) { return true; }
4230  }
4231
4232  private boolean jj_2_34(int xla) {
4233    jj_la = xla; jj_lastpos = jj_scanpos = token;
4234    try { return !jj_3_34(); }
4235    catch(LookaheadSuccess ls) { return true; }
4236  }
4237
4238  private boolean jj_2_35(int xla) {
4239    jj_la = xla; jj_lastpos = jj_scanpos = token;
4240    try { return !jj_3_35(); }
4241    catch(LookaheadSuccess ls) { return true; }
4242  }
4243
4244  private boolean jj_2_36(int xla) {
4245    jj_la = xla; jj_lastpos = jj_scanpos = token;
4246    try { return !jj_3_36(); }
4247    catch(LookaheadSuccess ls) { return true; }
4248  }
4249
4250  private boolean jj_2_37(int xla) {
4251    jj_la = xla; jj_lastpos = jj_scanpos = token;
4252    try { return !jj_3_37(); }
4253    catch(LookaheadSuccess ls) { return true; }
4254  }
4255
4256  private boolean jj_2_38(int xla) {
4257    jj_la = xla; jj_lastpos = jj_scanpos = token;
4258    try { return !jj_3_38(); }
4259    catch(LookaheadSuccess ls) { return true; }
4260  }
4261
4262  private boolean jj_2_39(int xla) {
4263    jj_la = xla; jj_lastpos = jj_scanpos = token;
4264    try { return !jj_3_39(); }
4265    catch(LookaheadSuccess ls) { return true; }
4266  }
4267
4268  private boolean jj_2_40(int xla) {
4269    jj_la = xla; jj_lastpos = jj_scanpos = token;
4270    try { return !jj_3_40(); }
4271    catch(LookaheadSuccess ls) { return true; }
4272  }
4273
4274  private boolean jj_2_41(int xla) {
4275    jj_la = xla; jj_lastpos = jj_scanpos = token;
4276    try { return !jj_3_41(); }
4277    catch(LookaheadSuccess ls) { return true; }
4278  }
4279
4280  private boolean jj_2_42(int xla) {
4281    jj_la = xla; jj_lastpos = jj_scanpos = token;
4282    try { return !jj_3_42(); }
4283    catch(LookaheadSuccess ls) { return true; }
4284  }
4285
4286  private boolean jj_2_43(int xla) {
4287    jj_la = xla; jj_lastpos = jj_scanpos = token;
4288    try { return !jj_3_43(); }
4289    catch(LookaheadSuccess ls) { return true; }
4290  }
4291
4292  private boolean jj_3R_124() {
4293    if (jj_scan_token(IDENTIFIER)) return true;
4294    Token xsp;
4295    xsp = jj_scanpos;
4296    if (jj_3_13()) jj_scanpos = xsp;
4297    while (true) {
4298      xsp = jj_scanpos;
4299      if (jj_3_14()) { jj_scanpos = xsp; break; }
4300    }
4301    return false;
4302  }
4303
4304  private boolean jj_3R_99() {
4305    if (jj_3R_124()) return true;
4306    Token xsp;
4307    while (true) {
4308      xsp = jj_scanpos;
4309      if (jj_3_12()) { jj_scanpos = xsp; break; }
4310    }
4311    return false;
4312  }
4313
4314  private boolean jj_3R_98() {
4315    if (jj_3R_78()) return true;
4316    Token xsp;
4317    if (jj_3_11()) return true;
4318    while (true) {
4319      xsp = jj_scanpos;
4320      if (jj_3_11()) { jj_scanpos = xsp; break; }
4321    }
4322    return false;
4323  }
4324
4325  private boolean jj_3R_71() {
4326    Token xsp;
4327    xsp = jj_scanpos;
4328    if (jj_3R_98()) {
4329    jj_scanpos = xsp;
4330    if (jj_3R_99()) return true;
4331    }
4332    return false;
4333  }
4334
4335  private boolean jj_3_9() {
4336    if (jj_scan_token(THIS)) return true;
4337    if (jj_scan_token(DOT)) return true;
4338    return false;
4339  }
4340
4341  private boolean jj_3R_263() {
4342    if (jj_scan_token(THROWS)) return true;
4343    if (jj_3R_277()) return true;
4344    return false;
4345  }
4346
4347  private boolean jj_3R_91() {
4348    if (jj_3R_78()) return true;
4349    return false;
4350  }
4351
4352  private boolean jj_3_10() {
4353    if (jj_3R_71()) return true;
4354    return false;
4355  }
4356
4357  private boolean jj_3R_66() {
4358    Token xsp;
4359    xsp = jj_scanpos;
4360    if (jj_3_10()) {
4361    jj_scanpos = xsp;
4362    if (jj_3R_91()) return true;
4363    }
4364    return false;
4365  }
4366
4367  private boolean jj_3R_68() {
4368    Token xsp;
4369    xsp = jj_scanpos;
4370    if (jj_scan_token(51)) jj_scanpos = xsp;
4371    if (jj_3R_92()) return true;
4372    return false;
4373  }
4374
4375  private boolean jj_3_8() {
4376    if (jj_3R_70()) return true;
4377    return false;
4378  }
4379
4380  private boolean jj_3R_96() {
4381    if (jj_3R_72()) return true;
4382    return false;
4383  }
4384
4385  private boolean jj_3R_280() {
4386    if (jj_scan_token(LBRACKET)) return true;
4387    if (jj_scan_token(RBRACKET)) return true;
4388    return false;
4389  }
4390
4391  private boolean jj_3R_95() {
4392    if (jj_scan_token(IDENTIFIER)) return true;
4393    if (jj_scan_token(DOT)) return true;
4394    return false;
4395  }
4396
4397  private boolean jj_3R_285() {
4398    if (jj_scan_token(COMMA)) return true;
4399    if (jj_3R_284()) return true;
4400    return false;
4401  }
4402
4403  private boolean jj_3R_70() {
4404    Token xsp;
4405    while (true) {
4406      xsp = jj_scanpos;
4407      if (jj_3R_95()) { jj_scanpos = xsp; break; }
4408    }
4409    xsp = jj_scanpos;
4410    if (jj_3_9()) jj_scanpos = xsp;
4411    xsp = jj_scanpos;
4412    if (jj_3R_96()) jj_scanpos = xsp;
4413    xsp = jj_scanpos;
4414    if (jj_scan_token(56)) {
4415    jj_scanpos = xsp;
4416    if (jj_scan_token(53)) return true;
4417    }
4418    if (jj_3R_97()) return true;
4419    if (jj_scan_token(SEMICOLON)) return true;
4420    return false;
4421  }
4422
4423  private boolean jj_3R_265() {
4424    if (jj_3R_134()) return true;
4425    return false;
4426  }
4427
4428  private boolean jj_3R_264() {
4429    if (jj_3R_70()) return true;
4430    return false;
4431  }
4432
4433  private boolean jj_3R_261() {
4434    if (jj_3R_90()) return true;
4435    return false;
4436  }
4437
4438  private boolean jj_3R_253() {
4439    Token xsp;
4440    xsp = jj_scanpos;
4441    if (jj_3R_261()) jj_scanpos = xsp;
4442    if (jj_scan_token(IDENTIFIER)) return true;
4443    if (jj_3R_262()) return true;
4444    xsp = jj_scanpos;
4445    if (jj_3R_263()) jj_scanpos = xsp;
4446    if (jj_scan_token(LBRACE)) return true;
4447    xsp = jj_scanpos;
4448    if (jj_3R_264()) jj_scanpos = xsp;
4449    while (true) {
4450      xsp = jj_scanpos;
4451      if (jj_3R_265()) { jj_scanpos = xsp; break; }
4452    }
4453    if (jj_scan_token(RBRACE)) return true;
4454    return false;
4455  }
4456
4457  private boolean jj_3R_270() {
4458    if (jj_scan_token(THROWS)) return true;
4459    if (jj_3R_277()) return true;
4460    return false;
4461  }
4462
4463  private boolean jj_3_7() {
4464    if (jj_scan_token(COMMA)) return true;
4465    if (jj_3R_69()) return true;
4466    return false;
4467  }
4468
4469  private boolean jj_3R_284() {
4470    if (jj_3R_85()) return true;
4471    if (jj_3R_66()) return true;
4472    Token xsp;
4473    xsp = jj_scanpos;
4474    if (jj_scan_token(123)) jj_scanpos = xsp;
4475    if (jj_3R_278()) return true;
4476    return false;
4477  }
4478
4479  private boolean jj_3R_276() {
4480    if (jj_3R_284()) return true;
4481    Token xsp;
4482    while (true) {
4483      xsp = jj_scanpos;
4484      if (jj_3R_285()) { jj_scanpos = xsp; break; }
4485    }
4486    return false;
4487  }
4488
4489  private boolean jj_3R_262() {
4490    if (jj_scan_token(LPAREN)) return true;
4491    Token xsp;
4492    xsp = jj_scanpos;
4493    if (jj_3R_276()) jj_scanpos = xsp;
4494    if (jj_scan_token(RPAREN)) return true;
4495    return false;
4496  }
4497
4498  private boolean jj_3R_269() {
4499    if (jj_scan_token(IDENTIFIER)) return true;
4500    if (jj_3R_262()) return true;
4501    Token xsp;
4502    while (true) {
4503      xsp = jj_scanpos;
4504      if (jj_3R_280()) { jj_scanpos = xsp; break; }
4505    }
4506    return false;
4507  }
4508
4509  private boolean jj_3_43() {
4510    if (jj_3R_66()) return true;
4511    if (jj_scan_token(IDENTIFIER)) return true;
4512    if (jj_scan_token(LPAREN)) return true;
4513    return false;
4514  }
4515
4516  private boolean jj_3R_271() {
4517    if (jj_3R_92()) return true;
4518    return false;
4519  }
4520
4521  private boolean jj_3R_268() {
4522    if (jj_3R_90()) return true;
4523    return false;
4524  }
4525
4526  private boolean jj_3R_255() {
4527    Token xsp;
4528    xsp = jj_scanpos;
4529    if (jj_3R_268()) jj_scanpos = xsp;
4530    if (jj_3R_81()) return true;
4531    if (jj_3R_269()) return true;
4532    xsp = jj_scanpos;
4533    if (jj_3R_270()) jj_scanpos = xsp;
4534    xsp = jj_scanpos;
4535    if (jj_3R_271()) {
4536    jj_scanpos = xsp;
4537    if (jj_scan_token(85)) return true;
4538    }
4539    return false;
4540  }
4541
4542  private boolean jj_3R_243() {
4543    if (jj_3R_69()) return true;
4544    Token xsp;
4545    while (true) {
4546      xsp = jj_scanpos;
4547      if (jj_3_7()) { jj_scanpos = xsp; break; }
4548    }
4549    return false;
4550  }
4551
4552  private boolean jj_3R_279() {
4553    if (jj_scan_token(ASSIGN)) return true;
4554    if (jj_3R_69()) return true;
4555    return false;
4556  }
4557
4558  private boolean jj_3R_267() {
4559    if (jj_scan_token(COMMA)) return true;
4560    if (jj_3R_266()) return true;
4561    return false;
4562  }
4563
4564  private boolean jj_3R_287() {
4565    if (jj_scan_token(LBRACKET)) return true;
4566    if (jj_scan_token(RBRACKET)) return true;
4567    return false;
4568  }
4569
4570  private boolean jj_3R_122() {
4571    if (jj_scan_token(LBRACE)) return true;
4572    Token xsp;
4573    xsp = jj_scanpos;
4574    if (jj_3R_243()) jj_scanpos = xsp;
4575    xsp = jj_scanpos;
4576    if (jj_scan_token(86)) jj_scanpos = xsp;
4577    if (jj_scan_token(RBRACE)) return true;
4578    return false;
4579  }
4580
4581  private boolean jj_3_42() {
4582    if (jj_scan_token(COMMA)) return true;
4583    if (jj_3R_88()) return true;
4584    return false;
4585  }
4586
4587  private boolean jj_3R_67() {
4588    if (jj_scan_token(LBRACKET)) return true;
4589    if (jj_scan_token(RBRACKET)) return true;
4590    return false;
4591  }
4592
4593  private boolean jj_3R_94() {
4594    if (jj_3R_74()) return true;
4595    return false;
4596  }
4597
4598  private boolean jj_3R_93() {
4599    if (jj_3R_122()) return true;
4600    return false;
4601  }
4602
4603  private boolean jj_3R_69() {
4604    Token xsp;
4605    xsp = jj_scanpos;
4606    if (jj_3R_93()) {
4607    jj_scanpos = xsp;
4608    if (jj_3R_94()) return true;
4609    }
4610    return false;
4611  }
4612
4613  private boolean jj_3R_278() {
4614    if (jj_scan_token(IDENTIFIER)) return true;
4615    Token xsp;
4616    while (true) {
4617      xsp = jj_scanpos;
4618      if (jj_3R_287()) { jj_scanpos = xsp; break; }
4619    }
4620    return false;
4621  }
4622
4623  private boolean jj_3R_266() {
4624    if (jj_3R_278()) return true;
4625    Token xsp;
4626    xsp = jj_scanpos;
4627    if (jj_3R_279()) jj_scanpos = xsp;
4628    return false;
4629  }
4630
4631  private boolean jj_3R_129() {
4632    if (jj_scan_token(LBRACE)) return true;
4633    if (jj_3R_88()) return true;
4634    Token xsp;
4635    while (true) {
4636      xsp = jj_scanpos;
4637      if (jj_3_42()) { jj_scanpos = xsp; break; }
4638    }
4639    xsp = jj_scanpos;
4640    if (jj_scan_token(86)) jj_scanpos = xsp;
4641    if (jj_scan_token(RBRACE)) return true;
4642    return false;
4643  }
4644
4645  private boolean jj_3R_156() {
4646    if (jj_scan_token(COMMA)) return true;
4647    if (jj_3R_155()) return true;
4648    return false;
4649  }
4650
4651  private boolean jj_3_5() {
4652    if (jj_3R_66()) return true;
4653    if (jj_scan_token(IDENTIFIER)) return true;
4654    Token xsp;
4655    while (true) {
4656      xsp = jj_scanpos;
4657      if (jj_3R_67()) { jj_scanpos = xsp; break; }
4658    }
4659    xsp = jj_scanpos;
4660    if (jj_scan_token(86)) {
4661    jj_scanpos = xsp;
4662    if (jj_scan_token(89)) {
4663    jj_scanpos = xsp;
4664    if (jj_scan_token(85)) return true;
4665    }
4666    }
4667    return false;
4668  }
4669
4670  private boolean jj_3R_65() {
4671    if (jj_3R_90()) return true;
4672    return false;
4673  }
4674
4675  private boolean jj_3R_115() {
4676    if (jj_3R_101()) return true;
4677    return false;
4678  }
4679
4680  private boolean jj_3R_254() {
4681    if (jj_3R_66()) return true;
4682    if (jj_3R_266()) return true;
4683    Token xsp;
4684    while (true) {
4685      xsp = jj_scanpos;
4686      if (jj_3R_267()) { jj_scanpos = xsp; break; }
4687    }
4688    if (jj_scan_token(SEMICOLON)) return true;
4689    return false;
4690  }
4691
4692  private boolean jj_3_4() {
4693    Token xsp;
4694    xsp = jj_scanpos;
4695    if (jj_3R_65()) jj_scanpos = xsp;
4696    if (jj_scan_token(IDENTIFIER)) return true;
4697    if (jj_scan_token(LPAREN)) return true;
4698    return false;
4699  }
4700
4701  private boolean jj_3R_114() {
4702    if (jj_3R_129()) return true;
4703    return false;
4704  }
4705
4706  private boolean jj_3R_113() {
4707    if (jj_3R_89()) return true;
4708    return false;
4709  }
4710
4711  private boolean jj_3R_88() {
4712    Token xsp;
4713    xsp = jj_scanpos;
4714    if (jj_3R_113()) {
4715    jj_scanpos = xsp;
4716    if (jj_3R_114()) {
4717    jj_scanpos = xsp;
4718    if (jj_3R_115()) return true;
4719    }
4720    }
4721    return false;
4722  }
4723
4724  private boolean jj_3R_251() {
4725    if (jj_3R_255()) return true;
4726    return false;
4727  }
4728
4729  private boolean jj_3R_155() {
4730    if (jj_scan_token(IDENTIFIER)) return true;
4731    if (jj_scan_token(ASSIGN)) return true;
4732    if (jj_3R_88()) return true;
4733    return false;
4734  }
4735
4736  private boolean jj_3R_148() {
4737    if (jj_scan_token(BIT_AND)) return true;
4738    if (jj_3R_124()) return true;
4739    return false;
4740  }
4741
4742  private boolean jj_3R_250() {
4743    if (jj_3R_254()) return true;
4744    return false;
4745  }
4746
4747  private boolean jj_3R_249() {
4748    if (jj_3R_253()) return true;
4749    return false;
4750  }
4751
4752  private boolean jj_3R_248() {
4753    if (jj_3R_252()) return true;
4754    return false;
4755  }
4756
4757  private boolean jj_3R_147() {
4758    if (jj_3R_155()) return true;
4759    Token xsp;
4760    while (true) {
4761      xsp = jj_scanpos;
4762      if (jj_3R_156()) { jj_scanpos = xsp; break; }
4763    }
4764    return false;
4765  }
4766
4767  private boolean jj_3R_247() {
4768    if (jj_3R_151()) return true;
4769    return false;
4770  }
4771
4772  private boolean jj_3R_139() {
4773    if (jj_3R_147()) return true;
4774    return false;
4775  }
4776
4777  private boolean jj_3R_87() {
4778    if (jj_scan_token(IDENTIFIER)) return true;
4779    if (jj_scan_token(ASSIGN)) return true;
4780    return false;
4781  }
4782
4783  private boolean jj_3R_289() {
4784    if (jj_3R_242()) return true;
4785    return false;
4786  }
4787
4788  private boolean jj_3R_131() {
4789    if (jj_scan_token(AT)) return true;
4790    if (jj_3R_86()) return true;
4791    if (jj_scan_token(LPAREN)) return true;
4792    if (jj_3R_88()) return true;
4793    if (jj_scan_token(RPAREN)) return true;
4794    return false;
4795  }
4796
4797  private boolean jj_3R_246() {
4798    if (jj_3R_85()) return true;
4799    Token xsp;
4800    xsp = jj_scanpos;
4801    if (jj_3R_247()) {
4802    jj_scanpos = xsp;
4803    if (jj_3R_248()) {
4804    jj_scanpos = xsp;
4805    if (jj_3R_249()) {
4806    jj_scanpos = xsp;
4807    if (jj_3R_250()) {
4808    jj_scanpos = xsp;
4809    if (jj_3R_251()) return true;
4810    }
4811    }
4812    }
4813    }
4814    return false;
4815  }
4816
4817  private boolean jj_3R_132() {
4818    if (jj_scan_token(AT)) return true;
4819    if (jj_3R_86()) return true;
4820    return false;
4821  }
4822
4823  private boolean jj_3_6() {
4824    if (jj_3R_68()) return true;
4825    return false;
4826  }
4827
4828  private boolean jj_3R_245() {
4829    Token xsp;
4830    xsp = jj_scanpos;
4831    if (jj_3_6()) {
4832    jj_scanpos = xsp;
4833    if (jj_3R_246()) {
4834    jj_scanpos = xsp;
4835    if (jj_scan_token(85)) return true;
4836    }
4837    }
4838    return false;
4839  }
4840
4841  private boolean jj_3_41() {
4842    if (jj_scan_token(AT)) return true;
4843    if (jj_3R_86()) return true;
4844    if (jj_scan_token(LPAREN)) return true;
4845    return false;
4846  }
4847
4848  private boolean jj_3R_244() {
4849    if (jj_3R_245()) return true;
4850    return false;
4851  }
4852
4853  private boolean jj_3R_130() {
4854    if (jj_scan_token(AT)) return true;
4855    if (jj_3R_86()) return true;
4856    if (jj_scan_token(LPAREN)) return true;
4857    Token xsp;
4858    xsp = jj_scanpos;
4859    if (jj_3R_139()) jj_scanpos = xsp;
4860    if (jj_scan_token(RPAREN)) return true;
4861    return false;
4862  }
4863
4864  private boolean jj_3R_120() {
4865    if (jj_scan_token(COMMA)) return true;
4866    if (jj_3R_119()) return true;
4867    return false;
4868  }
4869
4870  private boolean jj_3_40() {
4871    if (jj_scan_token(AT)) return true;
4872    if (jj_3R_86()) return true;
4873    if (jj_scan_token(LPAREN)) return true;
4874    Token xsp;
4875    xsp = jj_scanpos;
4876    if (jj_3R_87()) {
4877    jj_scanpos = xsp;
4878    if (jj_scan_token(80)) return true;
4879    }
4880    return false;
4881  }
4882
4883  private boolean jj_3R_133() {
4884    if (jj_3R_140()) return true;
4885    return false;
4886  }
4887
4888  private boolean jj_3R_288() {
4889    if (jj_3R_97()) return true;
4890    return false;
4891  }
4892
4893  private boolean jj_3R_242() {
4894    if (jj_scan_token(LBRACE)) return true;
4895    Token xsp;
4896    while (true) {
4897      xsp = jj_scanpos;
4898      if (jj_3R_244()) { jj_scanpos = xsp; break; }
4899    }
4900    if (jj_scan_token(RBRACE)) return true;
4901    return false;
4902  }
4903
4904  private boolean jj_3R_118() {
4905    if (jj_3R_132()) return true;
4906    return false;
4907  }
4908
4909  private boolean jj_3R_117() {
4910    if (jj_3R_131()) return true;
4911    return false;
4912  }
4913
4914  private boolean jj_3R_140() {
4915    if (jj_scan_token(EXTENDS)) return true;
4916    if (jj_3R_124()) return true;
4917    Token xsp;
4918    while (true) {
4919      xsp = jj_scanpos;
4920      if (jj_3R_148()) { jj_scanpos = xsp; break; }
4921    }
4922    return false;
4923  }
4924
4925  private boolean jj_3R_116() {
4926    if (jj_3R_130()) return true;
4927    return false;
4928  }
4929
4930  private boolean jj_3R_102() {
4931    return false;
4932  }
4933
4934  private boolean jj_3R_89() {
4935    Token xsp;
4936    xsp = jj_scanpos;
4937    if (jj_3R_116()) {
4938    jj_scanpos = xsp;
4939    if (jj_3R_117()) {
4940    jj_scanpos = xsp;
4941    if (jj_3R_118()) return true;
4942    }
4943    }
4944    return false;
4945  }
4946
4947  private boolean jj_3R_119() {
4948    if (jj_scan_token(IDENTIFIER)) return true;
4949    Token xsp;
4950    xsp = jj_scanpos;
4951    if (jj_3R_133()) jj_scanpos = xsp;
4952    return false;
4953  }
4954
4955  private boolean jj_3_3() {
4956    if (jj_scan_token(COMMA)) return true;
4957    if (jj_3R_64()) return true;
4958    return false;
4959  }
4960
4961  private boolean jj_3R_103() {
4962    return false;
4963  }
4964
4965  private boolean jj_3R_90() {
4966    if (jj_scan_token(LT)) return true;
4967    if (jj_3R_119()) return true;
4968    Token xsp;
4969    while (true) {
4970      xsp = jj_scanpos;
4971      if (jj_3R_120()) { jj_scanpos = xsp; break; }
4972    }
4973    if (jj_scan_token(GT)) return true;
4974    return false;
4975  }
4976
4977  private boolean jj_3R_75() {
4978    jj_lookingAhead = true;
4979    jj_semLA = getToken(1).kind == GT &&
4980                ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
4981    jj_lookingAhead = false;
4982    if (!jj_semLA || jj_3R_102()) return true;
4983    if (jj_scan_token(GT)) return true;
4984    if (jj_scan_token(GT)) return true;
4985    return false;
4986  }
4987
4988  private boolean jj_3R_283() {
4989    if (jj_3R_245()) return true;
4990    return false;
4991  }
4992
4993  private boolean jj_3R_64() {
4994    if (jj_3R_85()) return true;
4995    if (jj_scan_token(IDENTIFIER)) return true;
4996    Token xsp;
4997    xsp = jj_scanpos;
4998    if (jj_3R_288()) jj_scanpos = xsp;
4999    xsp = jj_scanpos;
5000    if (jj_3R_289()) jj_scanpos = xsp;
5001    return false;
5002  }
5003
5004  private boolean jj_3R_76() {
5005    jj_lookingAhead = true;
5006    jj_semLA = getToken(1).kind == GT &&
5007                ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
5008    jj_lookingAhead = false;
5009    if (!jj_semLA || jj_3R_103()) return true;
5010    if (jj_scan_token(GT)) return true;
5011    if (jj_scan_token(GT)) return true;
5012    if (jj_scan_token(GT)) return true;
5013    return false;
5014  }
5015
5016  private boolean jj_3R_275() {
5017    if (jj_scan_token(SEMICOLON)) return true;
5018    Token xsp;
5019    while (true) {
5020      xsp = jj_scanpos;
5021      if (jj_3R_283()) { jj_scanpos = xsp; break; }
5022    }
5023    return false;
5024  }
5025
5026  private boolean jj_3R_274() {
5027    if (jj_3R_64()) return true;
5028    Token xsp;
5029    while (true) {
5030      xsp = jj_scanpos;
5031      if (jj_3_3()) { jj_scanpos = xsp; break; }
5032    }
5033    return false;
5034  }
5035
5036  private boolean jj_3R_260() {
5037    if (jj_scan_token(LBRACE)) return true;
5038    Token xsp;
5039    xsp = jj_scanpos;
5040    if (jj_3R_274()) jj_scanpos = xsp;
5041    xsp = jj_scanpos;
5042    if (jj_scan_token(86)) jj_scanpos = xsp;
5043    xsp = jj_scanpos;
5044    if (jj_3R_275()) jj_scanpos = xsp;
5045    if (jj_scan_token(RBRACE)) return true;
5046    return false;
5047  }
5048
5049  private boolean jj_3R_298() {
5050    if (jj_scan_token(FINALLY)) return true;
5051    if (jj_3R_92()) return true;
5052    return false;
5053  }
5054
5055  private boolean jj_3R_297() {
5056    if (jj_scan_token(CATCH)) return true;
5057    if (jj_scan_token(LPAREN)) return true;
5058    if (jj_3R_284()) return true;
5059    if (jj_scan_token(RPAREN)) return true;
5060    if (jj_3R_92()) return true;
5061    return false;
5062  }
5063
5064  private boolean jj_3R_259() {
5065    if (jj_3R_273()) return true;
5066    return false;
5067  }
5068
5069  private boolean jj_3R_187() {
5070    if (jj_scan_token(TRY)) return true;
5071    if (jj_3R_92()) return true;
5072    Token xsp;
5073    while (true) {
5074      xsp = jj_scanpos;
5075      if (jj_3R_297()) { jj_scanpos = xsp; break; }
5076    }
5077    xsp = jj_scanpos;
5078    if (jj_3R_298()) jj_scanpos = xsp;
5079    return false;
5080  }
5081
5082  private boolean jj_3R_252() {
5083    if (jj_scan_token(ENUM)) return true;
5084    if (jj_scan_token(IDENTIFIER)) return true;
5085    Token xsp;
5086    xsp = jj_scanpos;
5087    if (jj_3R_259()) jj_scanpos = xsp;
5088    if (jj_3R_260()) return true;
5089    return false;
5090  }
5091
5092  private boolean jj_3R_282() {
5093    if (jj_scan_token(COMMA)) return true;
5094    if (jj_3R_124()) return true;
5095    return false;
5096  }
5097
5098  private boolean jj_3R_186() {
5099    if (jj_scan_token(SYNCHRONIZED)) return true;
5100    if (jj_scan_token(LPAREN)) return true;
5101    if (jj_3R_74()) return true;
5102    if (jj_scan_token(RPAREN)) return true;
5103    if (jj_3R_92()) return true;
5104    return false;
5105  }
5106
5107  private boolean jj_3R_296() {
5108    if (jj_3R_74()) return true;
5109    return false;
5110  }
5111
5112  private boolean jj_3R_273() {
5113    if (jj_scan_token(IMPLEMENTS)) return true;
5114    if (jj_3R_124()) return true;
5115    Token xsp;
5116    while (true) {
5117      xsp = jj_scanpos;
5118      if (jj_3R_282()) { jj_scanpos = xsp; break; }
5119    }
5120    return false;
5121  }
5122
5123  private boolean jj_3R_185() {
5124    if (jj_scan_token(THROW)) return true;
5125    if (jj_3R_74()) return true;
5126    if (jj_scan_token(SEMICOLON)) return true;
5127    return false;
5128  }
5129
5130  private boolean jj_3R_304() {
5131    if (jj_3R_309()) return true;
5132    return false;
5133  }
5134
5135  private boolean jj_3R_281() {
5136    if (jj_scan_token(COMMA)) return true;
5137    if (jj_3R_124()) return true;
5138    return false;
5139  }
5140
5141  private boolean jj_3R_313() {
5142    if (jj_scan_token(COMMA)) return true;
5143    if (jj_3R_176()) return true;
5144    return false;
5145  }
5146
5147  private boolean jj_3R_184() {
5148    if (jj_scan_token(RETURN)) return true;
5149    Token xsp;
5150    xsp = jj_scanpos;
5151    if (jj_3R_296()) jj_scanpos = xsp;
5152    if (jj_scan_token(SEMICOLON)) return true;
5153    return false;
5154  }
5155
5156  private boolean jj_3R_272() {
5157    if (jj_scan_token(EXTENDS)) return true;
5158    if (jj_3R_124()) return true;
5159    Token xsp;
5160    while (true) {
5161      xsp = jj_scanpos;
5162      if (jj_3R_281()) { jj_scanpos = xsp; break; }
5163    }
5164    return false;
5165  }
5166
5167  private boolean jj_3R_171() {
5168    if (jj_scan_token(INTERFACE)) return true;
5169    return false;
5170  }
5171
5172  private boolean jj_3R_183() {
5173    if (jj_scan_token(CONTINUE)) return true;
5174    Token xsp;
5175    xsp = jj_scanpos;
5176    if (jj_scan_token(76)) jj_scanpos = xsp;
5177    if (jj_scan_token(SEMICOLON)) return true;
5178    return false;
5179  }
5180
5181  private boolean jj_3R_258() {
5182    if (jj_3R_273()) return true;
5183    return false;
5184  }
5185
5186  private boolean jj_3R_257() {
5187    if (jj_3R_272()) return true;
5188    return false;
5189  }
5190
5191  private boolean jj_3R_256() {
5192    if (jj_3R_90()) return true;
5193    return false;
5194  }
5195
5196  private boolean jj_3R_182() {
5197    if (jj_scan_token(BREAK)) return true;
5198    Token xsp;
5199    xsp = jj_scanpos;
5200    if (jj_scan_token(76)) jj_scanpos = xsp;
5201    if (jj_scan_token(SEMICOLON)) return true;
5202    return false;
5203  }
5204
5205  private boolean jj_3R_151() {
5206    Token xsp;
5207    xsp = jj_scanpos;
5208    if (jj_scan_token(20)) {
5209    jj_scanpos = xsp;
5210    if (jj_3R_171()) return true;
5211    }
5212    if (jj_scan_token(IDENTIFIER)) return true;
5213    xsp = jj_scanpos;
5214    if (jj_3R_256()) jj_scanpos = xsp;
5215    xsp = jj_scanpos;
5216    if (jj_3R_257()) jj_scanpos = xsp;
5217    xsp = jj_scanpos;
5218    if (jj_3R_258()) jj_scanpos = xsp;
5219    if (jj_3R_242()) return true;
5220    return false;
5221  }
5222
5223  private boolean jj_3R_309() {
5224    if (jj_3R_312()) return true;
5225    return false;
5226  }
5227
5228  private boolean jj_3R_303() {
5229    if (jj_3R_74()) return true;
5230    return false;
5231  }
5232
5233  private boolean jj_3_39() {
5234    if (jj_3R_85()) return true;
5235    if (jj_3R_66()) return true;
5236    if (jj_scan_token(IDENTIFIER)) return true;
5237    return false;
5238  }
5239
5240  private boolean jj_3R_312() {
5241    if (jj_3R_176()) return true;
5242    Token xsp;
5243    while (true) {
5244      xsp = jj_scanpos;
5245      if (jj_3R_313()) { jj_scanpos = xsp; break; }
5246    }
5247    return false;
5248  }
5249
5250  private boolean jj_3R_293() {
5251    if (jj_scan_token(ELSE)) return true;
5252    if (jj_3R_150()) return true;
5253    return false;
5254  }
5255
5256  private boolean jj_3R_311() {
5257    if (jj_3R_312()) return true;
5258    return false;
5259  }
5260
5261  private boolean jj_3_38() {
5262    if (jj_3R_85()) return true;
5263    if (jj_3R_66()) return true;
5264    if (jj_scan_token(IDENTIFIER)) return true;
5265    if (jj_scan_token(COLON)) return true;
5266    return false;
5267  }
5268
5269  private boolean jj_3R_310() {
5270    if (jj_3R_149()) return true;
5271    return false;
5272  }
5273
5274  private boolean jj_3R_308() {
5275    Token xsp;
5276    xsp = jj_scanpos;
5277    if (jj_3R_310()) {
5278    jj_scanpos = xsp;
5279    if (jj_3R_311()) return true;
5280    }
5281    return false;
5282  }
5283
5284  private boolean jj_3R_302() {
5285    if (jj_3R_308()) return true;
5286    return false;
5287  }
5288
5289  private boolean jj_3R_295() {
5290    Token xsp;
5291    xsp = jj_scanpos;
5292    if (jj_3R_302()) jj_scanpos = xsp;
5293    if (jj_scan_token(SEMICOLON)) return true;
5294    xsp = jj_scanpos;
5295    if (jj_3R_303()) jj_scanpos = xsp;
5296    if (jj_scan_token(SEMICOLON)) return true;
5297    xsp = jj_scanpos;
5298    if (jj_3R_304()) jj_scanpos = xsp;
5299    return false;
5300  }
5301
5302  private boolean jj_3R_294() {
5303    if (jj_3R_85()) return true;
5304    if (jj_3R_66()) return true;
5305    if (jj_scan_token(IDENTIFIER)) return true;
5306    if (jj_scan_token(COLON)) return true;
5307    if (jj_3R_74()) return true;
5308    return false;
5309  }
5310
5311  private boolean jj_3R_181() {
5312    if (jj_scan_token(FOR)) return true;
5313    if (jj_scan_token(LPAREN)) return true;
5314    Token xsp;
5315    xsp = jj_scanpos;
5316    if (jj_3R_294()) {
5317    jj_scanpos = xsp;
5318    if (jj_3R_295()) return true;
5319    }
5320    if (jj_scan_token(RPAREN)) return true;
5321    if (jj_3R_150()) return true;
5322    return false;
5323  }
5324
5325  private boolean jj_3R_63() {
5326    if (jj_3R_89()) return true;
5327    return false;
5328  }
5329
5330  private boolean jj_3R_62() {
5331    if (jj_scan_token(STRICTFP)) return true;
5332    return false;
5333  }
5334
5335  private boolean jj_3R_61() {
5336    if (jj_scan_token(VOLATILE)) return true;
5337    return false;
5338  }
5339
5340  private boolean jj_3R_180() {
5341    if (jj_scan_token(DO)) return true;
5342    if (jj_3R_150()) return true;
5343    if (jj_scan_token(WHILE)) return true;
5344    if (jj_scan_token(LPAREN)) return true;
5345    if (jj_3R_74()) return true;
5346    if (jj_scan_token(RPAREN)) return true;
5347    if (jj_scan_token(SEMICOLON)) return true;
5348    return false;
5349  }
5350
5351  private boolean jj_3R_60() {
5352    if (jj_scan_token(TRANSIENT)) return true;
5353    return false;
5354  }
5355
5356  private boolean jj_3R_59() {
5357    if (jj_scan_token(NATIVE)) return true;
5358    return false;
5359  }
5360
5361  private boolean jj_3R_58() {
5362    if (jj_scan_token(SYNCHRONIZED)) return true;
5363    return false;
5364  }
5365
5366  private boolean jj_3R_179() {
5367    if (jj_scan_token(WHILE)) return true;
5368    if (jj_scan_token(LPAREN)) return true;
5369    if (jj_3R_74()) return true;
5370    if (jj_scan_token(RPAREN)) return true;
5371    if (jj_3R_150()) return true;
5372    return false;
5373  }
5374
5375  private boolean jj_3R_57() {
5376    if (jj_scan_token(ABSTRACT)) return true;
5377    return false;
5378  }
5379
5380  private boolean jj_3R_56() {
5381    if (jj_scan_token(FINAL)) return true;
5382    return false;
5383  }
5384
5385  private boolean jj_3R_301() {
5386    if (jj_3R_134()) return true;
5387    return false;
5388  }
5389
5390  private boolean jj_3R_55() {
5391    if (jj_scan_token(PRIVATE)) return true;
5392    return false;
5393  }
5394
5395  private boolean jj_3R_178() {
5396    if (jj_scan_token(IF)) return true;
5397    if (jj_scan_token(LPAREN)) return true;
5398    if (jj_3R_74()) return true;
5399    if (jj_scan_token(RPAREN)) return true;
5400    if (jj_3R_150()) return true;
5401    Token xsp;
5402    xsp = jj_scanpos;
5403    if (jj_3R_293()) jj_scanpos = xsp;
5404    return false;
5405  }
5406
5407  private boolean jj_3R_54() {
5408    if (jj_scan_token(PROTECTED)) return true;
5409    return false;
5410  }
5411
5412  private boolean jj_3R_53() {
5413    if (jj_scan_token(STATIC)) return true;
5414    return false;
5415  }
5416
5417  private boolean jj_3R_52() {
5418    if (jj_scan_token(PUBLIC)) return true;
5419    return false;
5420  }
5421
5422  private boolean jj_3_2() {
5423    Token xsp;
5424    xsp = jj_scanpos;
5425    if (jj_3R_52()) {
5426    jj_scanpos = xsp;
5427    if (jj_3R_53()) {
5428    jj_scanpos = xsp;
5429    if (jj_3R_54()) {
5430    jj_scanpos = xsp;
5431    if (jj_3R_55()) {
5432    jj_scanpos = xsp;
5433    if (jj_3R_56()) {
5434    jj_scanpos = xsp;
5435    if (jj_3R_57()) {
5436    jj_scanpos = xsp;
5437    if (jj_3R_58()) {
5438    jj_scanpos = xsp;
5439    if (jj_3R_59()) {
5440    jj_scanpos = xsp;
5441    if (jj_3R_60()) {
5442    jj_scanpos = xsp;
5443    if (jj_3R_61()) {
5444    jj_scanpos = xsp;
5445    if (jj_3R_62()) {
5446    jj_scanpos = xsp;
5447    if (jj_3R_63()) return true;
5448    }
5449    }
5450    }
5451    }
5452    }
5453    }
5454    }
5455    }
5456    }
5457    }
5458    }
5459    return false;
5460  }
5461
5462  private boolean jj_3R_307() {
5463    if (jj_scan_token(_DEFAULT)) return true;
5464    if (jj_scan_token(COLON)) return true;
5465    return false;
5466  }
5467
5468  private boolean jj_3R_85() {
5469    Token xsp;
5470    while (true) {
5471      xsp = jj_scanpos;
5472      if (jj_3_2()) { jj_scanpos = xsp; break; }
5473    }
5474    return false;
5475  }
5476
5477  private boolean jj_3R_306() {
5478    if (jj_scan_token(CASE)) return true;
5479    if (jj_3R_74()) return true;
5480    if (jj_scan_token(COLON)) return true;
5481    return false;
5482  }
5483
5484  private boolean jj_3R_300() {
5485    Token xsp;
5486    xsp = jj_scanpos;
5487    if (jj_3R_306()) {
5488    jj_scanpos = xsp;
5489    if (jj_3R_307()) return true;
5490    }
5491    return false;
5492  }
5493
5494  private boolean jj_3R_290() {
5495    if (jj_scan_token(COMMA)) return true;
5496    if (jj_3R_266()) return true;
5497    return false;
5498  }
5499
5500  private boolean jj_3R_292() {
5501    if (jj_3R_300()) return true;
5502    Token xsp;
5503    while (true) {
5504      xsp = jj_scanpos;
5505      if (jj_3R_301()) { jj_scanpos = xsp; break; }
5506    }
5507    return false;
5508  }
5509
5510  private boolean jj_3R_177() {
5511    if (jj_scan_token(SWITCH)) return true;
5512    if (jj_scan_token(LPAREN)) return true;
5513    if (jj_3R_74()) return true;
5514    if (jj_scan_token(RPAREN)) return true;
5515    if (jj_scan_token(LBRACE)) return true;
5516    Token xsp;
5517    while (true) {
5518      xsp = jj_scanpos;
5519      if (jj_3R_292()) { jj_scanpos = xsp; break; }
5520    }
5521    if (jj_scan_token(RBRACE)) return true;
5522    return false;
5523  }
5524
5525  private boolean jj_3R_305() {
5526    if (jj_3R_73()) return true;
5527    if (jj_3R_74()) return true;
5528    return false;
5529  }
5530
5531  private boolean jj_3R_299() {
5532    Token xsp;
5533    xsp = jj_scanpos;
5534    if (jj_scan_token(101)) {
5535    jj_scanpos = xsp;
5536    if (jj_scan_token(102)) {
5537    jj_scanpos = xsp;
5538    if (jj_3R_305()) return true;
5539    }
5540    }
5541    return false;
5542  }
5543
5544  private boolean jj_3R_194() {
5545    if (jj_3R_199()) return true;
5546    Token xsp;
5547    xsp = jj_scanpos;
5548    if (jj_3R_299()) jj_scanpos = xsp;
5549    return false;
5550  }
5551
5552  private boolean jj_3R_51() {
5553    if (jj_3R_89()) return true;
5554    return false;
5555  }
5556
5557  private boolean jj_3R_193() {
5558    if (jj_3R_198()) return true;
5559    return false;
5560  }
5561
5562  private boolean jj_3_1() {
5563    Token xsp;
5564    while (true) {
5565      xsp = jj_scanpos;
5566      if (jj_3R_51()) { jj_scanpos = xsp; break; }
5567    }
5568    if (jj_scan_token(PACKAGE)) return true;
5569    return false;
5570  }
5571
5572  private boolean jj_3R_176() {
5573    Token xsp;
5574    xsp = jj_scanpos;
5575    if (jj_3R_192()) {
5576    jj_scanpos = xsp;
5577    if (jj_3R_193()) {
5578    jj_scanpos = xsp;
5579    if (jj_3R_194()) return true;
5580    }
5581    }
5582    return false;
5583  }
5584
5585  private boolean jj_3R_192() {
5586    if (jj_3R_197()) return true;
5587    return false;
5588  }
5589
5590  private boolean jj_3_37() {
5591    if (jj_3R_85()) return true;
5592    if (jj_3R_66()) return true;
5593    if (jj_scan_token(IDENTIFIER)) return true;
5594    return false;
5595  }
5596
5597  private boolean jj_3R_149() {
5598    if (jj_3R_85()) return true;
5599    if (jj_3R_66()) return true;
5600    if (jj_3R_266()) return true;
5601    Token xsp;
5602    while (true) {
5603      xsp = jj_scanpos;
5604      if (jj_3R_290()) { jj_scanpos = xsp; break; }
5605    }
5606    return false;
5607  }
5608
5609  private boolean jj_3R_291() {
5610    if (jj_scan_token(COLON)) return true;
5611    if (jj_3R_74()) return true;
5612    return false;
5613  }
5614
5615  private boolean jj_3R_143() {
5616    if (jj_3R_151()) return true;
5617    return false;
5618  }
5619
5620  private boolean jj_3R_142() {
5621    if (jj_3R_150()) return true;
5622    return false;
5623  }
5624
5625  private boolean jj_3R_141() {
5626    if (jj_3R_149()) return true;
5627    if (jj_scan_token(SEMICOLON)) return true;
5628    return false;
5629  }
5630
5631  private boolean jj_3R_134() {
5632    Token xsp;
5633    xsp = jj_scanpos;
5634    if (jj_3R_141()) {
5635    jj_scanpos = xsp;
5636    if (jj_3R_142()) {
5637    jj_scanpos = xsp;
5638    if (jj_3R_143()) return true;
5639    }
5640    }
5641    return false;
5642  }
5643
5644  private boolean jj_3R_121() {
5645    if (jj_3R_134()) return true;
5646    return false;
5647  }
5648
5649  private boolean jj_3R_92() {
5650    if (jj_scan_token(LBRACE)) return true;
5651    Token xsp;
5652    while (true) {
5653      xsp = jj_scanpos;
5654      if (jj_3R_121()) { jj_scanpos = xsp; break; }
5655    }
5656    if (jj_scan_token(RBRACE)) return true;
5657    return false;
5658  }
5659
5660  private boolean jj_3R_84() {
5661    if (jj_scan_token(IDENTIFIER)) return true;
5662    if (jj_scan_token(COLON)) return true;
5663    if (jj_3R_150()) return true;
5664    return false;
5665  }
5666
5667  private boolean jj_3R_175() {
5668    if (jj_scan_token(ASSERT)) return true;
5669    if (jj_3R_74()) return true;
5670    Token xsp;
5671    xsp = jj_scanpos;
5672    if (jj_3R_291()) jj_scanpos = xsp;
5673    if (jj_scan_token(SEMICOLON)) return true;
5674    return false;
5675  }
5676
5677  private boolean jj_3R_170() {
5678    if (jj_3R_187()) return true;
5679    return false;
5680  }
5681
5682  private boolean jj_3R_169() {
5683    if (jj_3R_186()) return true;
5684    return false;
5685  }
5686
5687  private boolean jj_3_34() {
5688    if (jj_scan_token(LBRACKET)) return true;
5689    if (jj_scan_token(RBRACKET)) return true;
5690    return false;
5691  }
5692
5693  private boolean jj_3R_168() {
5694    if (jj_3R_185()) return true;
5695    return false;
5696  }
5697
5698  private boolean jj_3R_167() {
5699    if (jj_3R_184()) return true;
5700    return false;
5701  }
5702
5703  private boolean jj_3R_166() {
5704    if (jj_3R_183()) return true;
5705    return false;
5706  }
5707
5708  private boolean jj_3R_165() {
5709    if (jj_3R_182()) return true;
5710    return false;
5711  }
5712
5713  private boolean jj_3R_164() {
5714    if (jj_3R_181()) return true;
5715    return false;
5716  }
5717
5718  private boolean jj_3R_163() {
5719    if (jj_3R_180()) return true;
5720    return false;
5721  }
5722
5723  private boolean jj_3R_162() {
5724    if (jj_3R_179()) return true;
5725    return false;
5726  }
5727
5728  private boolean jj_3R_161() {
5729    if (jj_3R_178()) return true;
5730    return false;
5731  }
5732
5733  private boolean jj_3R_160() {
5734    if (jj_3R_177()) return true;
5735    return false;
5736  }
5737
5738  private boolean jj_3R_159() {
5739    if (jj_3R_176()) return true;
5740    if (jj_scan_token(SEMICOLON)) return true;
5741    return false;
5742  }
5743
5744  private boolean jj_3R_158() {
5745    if (jj_3R_92()) return true;
5746    return false;
5747  }
5748
5749  private boolean jj_3R_157() {
5750    if (jj_3R_175()) return true;
5751    return false;
5752  }
5753
5754  private boolean jj_3R_236() {
5755    if (jj_3R_72()) return true;
5756    return false;
5757  }
5758
5759  private boolean jj_3_36() {
5760    if (jj_3R_84()) return true;
5761    return false;
5762  }
5763
5764  private boolean jj_3R_150() {
5765    Token xsp;
5766    xsp = jj_scanpos;
5767    if (jj_3_36()) {
5768    jj_scanpos = xsp;
5769    if (jj_3R_157()) {
5770    jj_scanpos = xsp;
5771    if (jj_3R_158()) {
5772    jj_scanpos = xsp;
5773    if (jj_scan_token(85)) {
5774    jj_scanpos = xsp;
5775    if (jj_3R_159()) {
5776    jj_scanpos = xsp;
5777    if (jj_3R_160()) {
5778    jj_scanpos = xsp;
5779    if (jj_3R_161()) {
5780    jj_scanpos = xsp;
5781    if (jj_3R_162()) {
5782    jj_scanpos = xsp;
5783    if (jj_3R_163()) {
5784    jj_scanpos = xsp;
5785    if (jj_3R_164()) {
5786    jj_scanpos = xsp;
5787    if (jj_3R_165()) {
5788    jj_scanpos = xsp;
5789    if (jj_3R_166()) {
5790    jj_scanpos = xsp;
5791    if (jj_3R_167()) {
5792    jj_scanpos = xsp;
5793    if (jj_3R_168()) {
5794    jj_scanpos = xsp;
5795    if (jj_3R_169()) {
5796    jj_scanpos = xsp;
5797    if (jj_3R_170()) return true;
5798    }
5799    }
5800    }
5801    }
5802    }
5803    }
5804    }
5805    }
5806    }
5807    }
5808    }
5809    }
5810    }
5811    }
5812    }
5813    return false;
5814  }
5815
5816  private boolean jj_3R_240() {
5817    if (jj_3R_242()) return true;
5818    return false;
5819  }
5820
5821  private boolean jj_3R_241() {
5822    if (jj_scan_token(LBRACKET)) return true;
5823    if (jj_scan_token(RBRACKET)) return true;
5824    return false;
5825  }
5826
5827  private boolean jj_3_33() {
5828    if (jj_scan_token(LBRACKET)) return true;
5829    if (jj_3R_74()) return true;
5830    if (jj_scan_token(RBRACKET)) return true;
5831    return false;
5832  }
5833
5834  private boolean jj_3R_239() {
5835    Token xsp;
5836    if (jj_3R_241()) return true;
5837    while (true) {
5838      xsp = jj_scanpos;
5839      if (jj_3R_241()) { jj_scanpos = xsp; break; }
5840    }
5841    if (jj_3R_122()) return true;
5842    return false;
5843  }
5844
5845  private boolean jj_3_35() {
5846    Token xsp;
5847    if (jj_3_33()) return true;
5848    while (true) {
5849      xsp = jj_scanpos;
5850      if (jj_3_33()) { jj_scanpos = xsp; break; }
5851    }
5852    while (true) {
5853      xsp = jj_scanpos;
5854      if (jj_3_34()) { jj_scanpos = xsp; break; }
5855    }
5856    return false;
5857  }
5858
5859  private boolean jj_3R_235() {
5860    Token xsp;
5861    xsp = jj_scanpos;
5862    if (jj_3_35()) {
5863    jj_scanpos = xsp;
5864    if (jj_3R_239()) return true;
5865    }
5866    return false;
5867  }
5868
5869  private boolean jj_3R_238() {
5870    if (jj_3R_97()) return true;
5871    Token xsp;
5872    xsp = jj_scanpos;
5873    if (jj_3R_240()) jj_scanpos = xsp;
5874    return false;
5875  }
5876
5877  private boolean jj_3R_144() {
5878    if (jj_scan_token(COMMA)) return true;
5879    if (jj_3R_74()) return true;
5880    return false;
5881  }
5882
5883  private boolean jj_3R_237() {
5884    if (jj_3R_235()) return true;
5885    return false;
5886  }
5887
5888  private boolean jj_3R_112() {
5889    if (jj_scan_token(NEW)) return true;
5890    if (jj_3R_124()) return true;
5891    Token xsp;
5892    xsp = jj_scanpos;
5893    if (jj_3R_236()) jj_scanpos = xsp;
5894    xsp = jj_scanpos;
5895    if (jj_3R_237()) {
5896    jj_scanpos = xsp;
5897    if (jj_3R_238()) return true;
5898    }
5899    return false;
5900  }
5901
5902  private boolean jj_3R_82() {
5903    Token xsp;
5904    xsp = jj_scanpos;
5905    if (jj_3_32()) {
5906    jj_scanpos = xsp;
5907    if (jj_3R_112()) return true;
5908    }
5909    return false;
5910  }
5911
5912  private boolean jj_3_32() {
5913    if (jj_scan_token(NEW)) return true;
5914    if (jj_3R_78()) return true;
5915    if (jj_3R_235()) return true;
5916    return false;
5917  }
5918
5919  private boolean jj_3R_136() {
5920    if (jj_3R_74()) return true;
5921    Token xsp;
5922    while (true) {
5923      xsp = jj_scanpos;
5924      if (jj_3R_144()) { jj_scanpos = xsp; break; }
5925    }
5926    return false;
5927  }
5928
5929  private boolean jj_3R_123() {
5930    if (jj_3R_136()) return true;
5931    return false;
5932  }
5933
5934  private boolean jj_3R_97() {
5935    if (jj_scan_token(LPAREN)) return true;
5936    Token xsp;
5937    xsp = jj_scanpos;
5938    if (jj_3R_123()) jj_scanpos = xsp;
5939    if (jj_scan_token(RPAREN)) return true;
5940    return false;
5941  }
5942
5943  private boolean jj_3R_154() {
5944    Token xsp;
5945    xsp = jj_scanpos;
5946    if (jj_scan_token(60)) {
5947    jj_scanpos = xsp;
5948    if (jj_scan_token(29)) return true;
5949    }
5950    return false;
5951  }
5952
5953  private boolean jj_3R_146() {
5954    if (jj_3R_154()) return true;
5955    return false;
5956  }
5957
5958  private boolean jj_3R_128() {
5959    if (jj_3R_138()) return true;
5960    return false;
5961  }
5962
5963  private boolean jj_3R_138() {
5964    Token xsp;
5965    xsp = jj_scanpos;
5966    if (jj_scan_token(65)) {
5967    jj_scanpos = xsp;
5968    if (jj_scan_token(69)) {
5969    jj_scanpos = xsp;
5970    if (jj_scan_token(74)) {
5971    jj_scanpos = xsp;
5972    if (jj_scan_token(75)) {
5973    jj_scanpos = xsp;
5974    if (jj_3R_146()) {
5975    jj_scanpos = xsp;
5976    if (jj_scan_token(44)) return true;
5977    }
5978    }
5979    }
5980    }
5981    }
5982    return false;
5983  }
5984
5985  private boolean jj_3R_110() {
5986    if (jj_3R_97()) return true;
5987    return false;
5988  }
5989
5990  private boolean jj_3R_109() {
5991    if (jj_scan_token(DOT)) return true;
5992    if (jj_scan_token(IDENTIFIER)) return true;
5993    return false;
5994  }
5995
5996  private boolean jj_3_29() {
5997    if (jj_scan_token(DOT)) return true;
5998    if (jj_scan_token(THIS)) return true;
5999    return false;
6000  }
6001
6002  private boolean jj_3R_108() {
6003    if (jj_scan_token(LBRACKET)) return true;
6004    if (jj_3R_74()) return true;
6005    if (jj_scan_token(RBRACKET)) return true;
6006    return false;
6007  }
6008
6009  private boolean jj_3_28() {
6010    if (jj_scan_token(DOT)) return true;
6011    if (jj_scan_token(SUPER)) return true;
6012    if (jj_scan_token(DOT)) return true;
6013    return false;
6014  }
6015
6016  private boolean jj_3_31() {
6017    if (jj_3R_83()) return true;
6018    return false;
6019  }
6020
6021  private boolean jj_3_30() {
6022    if (jj_scan_token(DOT)) return true;
6023    if (jj_3R_82()) return true;
6024    return false;
6025  }
6026
6027  private boolean jj_3R_107() {
6028    if (jj_scan_token(DOT)) return true;
6029    if (jj_scan_token(THIS)) return true;
6030    return false;
6031  }
6032
6033  private boolean jj_3_27() {
6034    if (jj_3R_81()) return true;
6035    if (jj_scan_token(DOT)) return true;
6036    if (jj_scan_token(CLASS)) return true;
6037    return false;
6038  }
6039
6040  private boolean jj_3R_106() {
6041    if (jj_scan_token(DOT)) return true;
6042    if (jj_scan_token(SUPER)) return true;
6043    return false;
6044  }
6045
6046  private boolean jj_3R_79() {
6047    Token xsp;
6048    xsp = jj_scanpos;
6049    if (jj_3R_106()) {
6050    jj_scanpos = xsp;
6051    if (jj_3R_107()) {
6052    jj_scanpos = xsp;
6053    if (jj_3_30()) {
6054    jj_scanpos = xsp;
6055    if (jj_3_31()) {
6056    jj_scanpos = xsp;
6057    if (jj_3R_108()) {
6058    jj_scanpos = xsp;
6059    if (jj_3R_109()) {
6060    jj_scanpos = xsp;
6061    if (jj_3R_110()) return true;
6062    }
6063    }
6064    }
6065    }
6066    }
6067    }
6068    return false;
6069  }
6070
6071  private boolean jj_3R_80() {
6072    if (jj_scan_token(IDENTIFIER)) return true;
6073    if (jj_scan_token(DOT)) return true;
6074    return false;
6075  }
6076
6077  private boolean jj_3R_211() {
6078    if (jj_3R_86()) return true;
6079    return false;
6080  }
6081
6082  private boolean jj_3_26() {
6083    Token xsp;
6084    while (true) {
6085      xsp = jj_scanpos;
6086      if (jj_3R_80()) { jj_scanpos = xsp; break; }
6087    }
6088    if (jj_scan_token(THIS)) return true;
6089    return false;
6090  }
6091
6092  private boolean jj_3R_210() {
6093    if (jj_3R_81()) return true;
6094    if (jj_scan_token(DOT)) return true;
6095    if (jj_scan_token(CLASS)) return true;
6096    return false;
6097  }
6098
6099  private boolean jj_3R_209() {
6100    if (jj_3R_82()) return true;
6101    return false;
6102  }
6103
6104  private boolean jj_3R_208() {
6105    if (jj_scan_token(LPAREN)) return true;
6106    if (jj_3R_74()) return true;
6107    if (jj_scan_token(RPAREN)) return true;
6108    return false;
6109  }
6110
6111  private boolean jj_3_25() {
6112    if (jj_3R_79()) return true;
6113    return false;
6114  }
6115
6116  private boolean jj_3R_207() {
6117    if (jj_scan_token(SUPER)) return true;
6118    if (jj_scan_token(DOT)) return true;
6119    if (jj_scan_token(IDENTIFIER)) return true;
6120    return false;
6121  }
6122
6123  private boolean jj_3R_214() {
6124    if (jj_scan_token(IDENTIFIER)) return true;
6125    if (jj_scan_token(DOT)) return true;
6126    return false;
6127  }
6128
6129  private boolean jj_3R_206() {
6130    Token xsp;
6131    while (true) {
6132      xsp = jj_scanpos;
6133      if (jj_3R_214()) { jj_scanpos = xsp; break; }
6134    }
6135    if (jj_scan_token(THIS)) return true;
6136    return false;
6137  }
6138
6139  private boolean jj_3R_202() {
6140    Token xsp;
6141    xsp = jj_scanpos;
6142    if (jj_3R_205()) {
6143    jj_scanpos = xsp;
6144    if (jj_3R_206()) {
6145    jj_scanpos = xsp;
6146    if (jj_3R_207()) {
6147    jj_scanpos = xsp;
6148    if (jj_3R_208()) {
6149    jj_scanpos = xsp;
6150    if (jj_3R_209()) {
6151    jj_scanpos = xsp;
6152    if (jj_3R_210()) {
6153    jj_scanpos = xsp;
6154    if (jj_3R_211()) return true;
6155    }
6156    }
6157    }
6158    }
6159    }
6160    }
6161    return false;
6162  }
6163
6164  private boolean jj_3R_205() {
6165    if (jj_3R_138()) return true;
6166    return false;
6167  }
6168
6169  private boolean jj_3R_234() {
6170    Token xsp;
6171    xsp = jj_scanpos;
6172    if (jj_scan_token(101)) {
6173    jj_scanpos = xsp;
6174    if (jj_scan_token(102)) return true;
6175    }
6176    return false;
6177  }
6178
6179  private boolean jj_3R_83() {
6180    if (jj_scan_token(DOT)) return true;
6181    if (jj_3R_72()) return true;
6182    if (jj_scan_token(IDENTIFIER)) return true;
6183    return false;
6184  }
6185
6186  private boolean jj_3_24() {
6187    if (jj_scan_token(LPAREN)) return true;
6188    if (jj_3R_78()) return true;
6189    return false;
6190  }
6191
6192  private boolean jj_3R_199() {
6193    if (jj_3R_202()) return true;
6194    Token xsp;
6195    while (true) {
6196      xsp = jj_scanpos;
6197      if (jj_3_25()) { jj_scanpos = xsp; break; }
6198    }
6199    return false;
6200  }
6201
6202  private boolean jj_3R_233() {
6203    if (jj_scan_token(LPAREN)) return true;
6204    if (jj_3R_66()) return true;
6205    if (jj_scan_token(RPAREN)) return true;
6206    if (jj_3R_224()) return true;
6207    return false;
6208  }
6209
6210  private boolean jj_3R_230() {
6211    Token xsp;
6212    xsp = jj_scanpos;
6213    if (jj_3R_232()) {
6214    jj_scanpos = xsp;
6215    if (jj_3R_233()) return true;
6216    }
6217    return false;
6218  }
6219
6220  private boolean jj_3R_232() {
6221    if (jj_scan_token(LPAREN)) return true;
6222    if (jj_3R_66()) return true;
6223    if (jj_scan_token(RPAREN)) return true;
6224    if (jj_3R_218()) return true;
6225    return false;
6226  }
6227
6228  private boolean jj_3_23() {
6229    if (jj_scan_token(LPAREN)) return true;
6230    if (jj_3R_66()) return true;
6231    if (jj_scan_token(LBRACKET)) return true;
6232    return false;
6233  }
6234
6235  private boolean jj_3R_231() {
6236    if (jj_3R_199()) return true;
6237    Token xsp;
6238    xsp = jj_scanpos;
6239    if (jj_3R_234()) jj_scanpos = xsp;
6240    return false;
6241  }
6242
6243  private boolean jj_3R_105() {
6244    if (jj_scan_token(LPAREN)) return true;
6245    if (jj_3R_66()) return true;
6246    if (jj_scan_token(RPAREN)) return true;
6247    Token xsp;
6248    xsp = jj_scanpos;
6249    if (jj_scan_token(92)) {
6250    jj_scanpos = xsp;
6251    if (jj_scan_token(91)) {
6252    jj_scanpos = xsp;
6253    if (jj_scan_token(79)) {
6254    jj_scanpos = xsp;
6255    if (jj_scan_token(76)) {
6256    jj_scanpos = xsp;
6257    if (jj_scan_token(56)) {
6258    jj_scanpos = xsp;
6259    if (jj_scan_token(53)) {
6260    jj_scanpos = xsp;
6261    if (jj_scan_token(43)) {
6262    jj_scanpos = xsp;
6263    if (jj_3R_128()) return true;
6264    }
6265    }
6266    }
6267    }
6268    }
6269    }
6270    }
6271    return false;
6272  }
6273
6274  private boolean jj_3R_104() {
6275    if (jj_scan_token(LPAREN)) return true;
6276    if (jj_3R_66()) return true;
6277    if (jj_scan_token(LBRACKET)) return true;
6278    if (jj_scan_token(RBRACKET)) return true;
6279    return false;
6280  }
6281
6282  private boolean jj_3_22() {
6283    if (jj_scan_token(LPAREN)) return true;
6284    if (jj_3R_78()) return true;
6285    return false;
6286  }
6287
6288  private boolean jj_3R_77() {
6289    Token xsp;
6290    xsp = jj_scanpos;
6291    if (jj_3_22()) {
6292    jj_scanpos = xsp;
6293    if (jj_3R_104()) {
6294    jj_scanpos = xsp;
6295    if (jj_3R_105()) return true;
6296    }
6297    }
6298    return false;
6299  }
6300
6301  private boolean jj_3_21() {
6302    if (jj_3R_77()) return true;
6303    return false;
6304  }
6305
6306  private boolean jj_3_20() {
6307    if (jj_3R_76()) return true;
6308    return false;
6309  }
6310
6311  private boolean jj_3R_228() {
6312    if (jj_3R_231()) return true;
6313    return false;
6314  }
6315
6316  private boolean jj_3R_227() {
6317    if (jj_3R_230()) return true;
6318    return false;
6319  }
6320
6321  private boolean jj_3R_224() {
6322    Token xsp;
6323    xsp = jj_scanpos;
6324    if (jj_3R_226()) {
6325    jj_scanpos = xsp;
6326    if (jj_3R_227()) {
6327    jj_scanpos = xsp;
6328    if (jj_3R_228()) return true;
6329    }
6330    }
6331    return false;
6332  }
6333
6334  private boolean jj_3R_226() {
6335    Token xsp;
6336    xsp = jj_scanpos;
6337    if (jj_scan_token(92)) {
6338    jj_scanpos = xsp;
6339    if (jj_scan_token(91)) return true;
6340    }
6341    if (jj_3R_218()) return true;
6342    return false;
6343  }
6344
6345  private boolean jj_3R_198() {
6346    if (jj_scan_token(DECR)) return true;
6347    if (jj_3R_199()) return true;
6348    return false;
6349  }
6350
6351  private boolean jj_3R_225() {
6352    Token xsp;
6353    xsp = jj_scanpos;
6354    if (jj_scan_token(103)) {
6355    jj_scanpos = xsp;
6356    if (jj_scan_token(104)) return true;
6357    }
6358    if (jj_3R_216()) return true;
6359    return false;
6360  }
6361
6362  private boolean jj_3_19() {
6363    if (jj_3R_75()) return true;
6364    return false;
6365  }
6366
6367  private boolean jj_3R_229() {
6368    Token xsp;
6369    xsp = jj_scanpos;
6370    if (jj_scan_token(105)) {
6371    jj_scanpos = xsp;
6372    if (jj_scan_token(106)) {
6373    jj_scanpos = xsp;
6374    if (jj_scan_token(110)) return true;
6375    }
6376    }
6377    if (jj_3R_218()) return true;
6378    return false;
6379  }
6380
6381  private boolean jj_3R_197() {
6382    if (jj_scan_token(INCR)) return true;
6383    if (jj_3R_199()) return true;
6384    return false;
6385  }
6386
6387  private boolean jj_3R_223() {
6388    if (jj_3R_224()) return true;
6389    return false;
6390  }
6391
6392  private boolean jj_3_18() {
6393    Token xsp;
6394    xsp = jj_scanpos;
6395    if (jj_scan_token(111)) {
6396    jj_scanpos = xsp;
6397    if (jj_3_19()) {
6398    jj_scanpos = xsp;
6399    if (jj_3_20()) return true;
6400    }
6401    }
6402    if (jj_3R_213()) return true;
6403    return false;
6404  }
6405
6406  private boolean jj_3R_222() {
6407    if (jj_3R_198()) return true;
6408    return false;
6409  }
6410
6411  private boolean jj_3R_221() {
6412    if (jj_3R_197()) return true;
6413    return false;
6414  }
6415
6416  private boolean jj_3R_218() {
6417    Token xsp;
6418    xsp = jj_scanpos;
6419    if (jj_3R_220()) {
6420    jj_scanpos = xsp;
6421    if (jj_3R_221()) {
6422    jj_scanpos = xsp;
6423    if (jj_3R_222()) {
6424    jj_scanpos = xsp;
6425    if (jj_3R_223()) return true;
6426    }
6427    }
6428    }
6429    return false;
6430  }
6431
6432  private boolean jj_3R_220() {
6433    Token xsp;
6434    xsp = jj_scanpos;
6435    if (jj_scan_token(103)) {
6436    jj_scanpos = xsp;
6437    if (jj_scan_token(104)) return true;
6438    }
6439    if (jj_3R_218()) return true;
6440    return false;
6441  }
6442
6443  private boolean jj_3R_219() {
6444    Token xsp;
6445    xsp = jj_scanpos;
6446    if (jj_scan_token(90)) {
6447    jj_scanpos = xsp;
6448    if (jj_scan_token(126)) {
6449    jj_scanpos = xsp;
6450    if (jj_scan_token(96)) {
6451    jj_scanpos = xsp;
6452    if (jj_scan_token(97)) return true;
6453    }
6454    }
6455    }
6456    if (jj_3R_204()) return true;
6457    return false;
6458  }
6459
6460  private boolean jj_3R_217() {
6461    if (jj_scan_token(INSTANCEOF)) return true;
6462    if (jj_3R_66()) return true;
6463    return false;
6464  }
6465
6466  private boolean jj_3R_216() {
6467    if (jj_3R_218()) return true;
6468    Token xsp;
6469    while (true) {
6470      xsp = jj_scanpos;
6471      if (jj_3R_229()) { jj_scanpos = xsp; break; }
6472    }
6473    return false;
6474  }
6475
6476  private boolean jj_3R_215() {
6477    Token xsp;
6478    xsp = jj_scanpos;
6479    if (jj_scan_token(95)) {
6480    jj_scanpos = xsp;
6481    if (jj_scan_token(98)) return true;
6482    }
6483    if (jj_3R_196()) return true;
6484    return false;
6485  }
6486
6487  private boolean jj_3R_213() {
6488    if (jj_3R_216()) return true;
6489    Token xsp;
6490    while (true) {
6491      xsp = jj_scanpos;
6492      if (jj_3R_225()) { jj_scanpos = xsp; break; }
6493    }
6494    return false;
6495  }
6496
6497  private boolean jj_3R_204() {
6498    if (jj_3R_213()) return true;
6499    Token xsp;
6500    while (true) {
6501      xsp = jj_scanpos;
6502      if (jj_3_18()) { jj_scanpos = xsp; break; }
6503    }
6504    return false;
6505  }
6506
6507  private boolean jj_3R_212() {
6508    if (jj_scan_token(BIT_AND)) return true;
6509    if (jj_3R_191()) return true;
6510    return false;
6511  }
6512
6513  private boolean jj_3R_201() {
6514    if (jj_3R_204()) return true;
6515    Token xsp;
6516    while (true) {
6517      xsp = jj_scanpos;
6518      if (jj_3R_219()) { jj_scanpos = xsp; break; }
6519    }
6520    return false;
6521  }
6522
6523  private boolean jj_3R_200() {
6524    if (jj_scan_token(BIT_OR)) return true;
6525    if (jj_3R_153()) return true;
6526    return false;
6527  }
6528
6529  private boolean jj_3R_196() {
6530    if (jj_3R_201()) return true;
6531    Token xsp;
6532    xsp = jj_scanpos;
6533    if (jj_3R_217()) jj_scanpos = xsp;
6534    return false;
6535  }
6536
6537  private boolean jj_3R_203() {
6538    if (jj_scan_token(XOR)) return true;
6539    if (jj_3R_174()) return true;
6540    return false;
6541  }
6542
6543  private boolean jj_3R_195() {
6544    if (jj_scan_token(SC_AND)) return true;
6545    if (jj_3R_145()) return true;
6546    return false;
6547  }
6548
6549  private boolean jj_3R_191() {
6550    if (jj_3R_196()) return true;
6551    Token xsp;
6552    while (true) {
6553      xsp = jj_scanpos;
6554      if (jj_3R_215()) { jj_scanpos = xsp; break; }
6555    }
6556    return false;
6557  }
6558
6559  private boolean jj_3R_190() {
6560    if (jj_scan_token(SC_OR)) return true;
6561    if (jj_3R_137()) return true;
6562    return false;
6563  }
6564
6565  private boolean jj_3R_174() {
6566    if (jj_3R_191()) return true;
6567    Token xsp;
6568    while (true) {
6569      xsp = jj_scanpos;
6570      if (jj_3R_212()) { jj_scanpos = xsp; break; }
6571    }
6572    return false;
6573  }
6574
6575  private boolean jj_3R_173() {
6576    if (jj_scan_token(HOOK)) return true;
6577    if (jj_3R_74()) return true;
6578    if (jj_scan_token(COLON)) return true;
6579    if (jj_3R_74()) return true;
6580    return false;
6581  }
6582
6583  private boolean jj_3R_153() {
6584    if (jj_3R_174()) return true;
6585    Token xsp;
6586    while (true) {
6587      xsp = jj_scanpos;
6588      if (jj_3R_203()) { jj_scanpos = xsp; break; }
6589    }
6590    return false;
6591  }
6592
6593  private boolean jj_3R_145() {
6594    if (jj_3R_153()) return true;
6595    Token xsp;
6596    while (true) {
6597      xsp = jj_scanpos;
6598      if (jj_3R_200()) { jj_scanpos = xsp; break; }
6599    }
6600    return false;
6601  }
6602
6603  private boolean jj_3R_137() {
6604    if (jj_3R_145()) return true;
6605    Token xsp;
6606    while (true) {
6607      xsp = jj_scanpos;
6608      if (jj_3R_195()) { jj_scanpos = xsp; break; }
6609    }
6610    return false;
6611  }
6612
6613  private boolean jj_3R_127() {
6614    if (jj_3R_137()) return true;
6615    Token xsp;
6616    while (true) {
6617      xsp = jj_scanpos;
6618      if (jj_3R_190()) { jj_scanpos = xsp; break; }
6619    }
6620    return false;
6621  }
6622
6623  private boolean jj_3R_101() {
6624    if (jj_3R_127()) return true;
6625    Token xsp;
6626    xsp = jj_scanpos;
6627    if (jj_3R_173()) jj_scanpos = xsp;
6628    return false;
6629  }
6630
6631  private boolean jj_3R_73() {
6632    Token xsp;
6633    xsp = jj_scanpos;
6634    if (jj_scan_token(89)) {
6635    jj_scanpos = xsp;
6636    if (jj_scan_token(114)) {
6637    jj_scanpos = xsp;
6638    if (jj_scan_token(115)) {
6639    jj_scanpos = xsp;
6640    if (jj_scan_token(119)) {
6641    jj_scanpos = xsp;
6642    if (jj_scan_token(112)) {
6643    jj_scanpos = xsp;
6644    if (jj_scan_token(113)) {
6645    jj_scanpos = xsp;
6646    if (jj_scan_token(120)) {
6647    jj_scanpos = xsp;
6648    if (jj_scan_token(121)) {
6649    jj_scanpos = xsp;
6650    if (jj_scan_token(122)) {
6651    jj_scanpos = xsp;
6652    if (jj_scan_token(116)) {
6653    jj_scanpos = xsp;
6654    if (jj_scan_token(118)) {
6655    jj_scanpos = xsp;
6656    if (jj_scan_token(117)) return true;
6657    }
6658    }
6659    }
6660    }
6661    }
6662    }
6663    }
6664    }
6665    }
6666    }
6667    }
6668    return false;
6669  }
6670
6671  private boolean jj_3_17() {
6672    if (jj_3R_73()) return true;
6673    if (jj_3R_74()) return true;
6674    return false;
6675  }
6676
6677  private boolean jj_3R_74() {
6678    if (jj_3R_101()) return true;
6679    Token xsp;
6680    xsp = jj_scanpos;
6681    if (jj_3_17()) jj_scanpos = xsp;
6682    return false;
6683  }
6684
6685  private boolean jj_3R_286() {
6686    if (jj_scan_token(COMMA)) return true;
6687    if (jj_3R_86()) return true;
6688    return false;
6689  }
6690
6691  private boolean jj_3R_277() {
6692    if (jj_3R_86()) return true;
6693    Token xsp;
6694    while (true) {
6695      xsp = jj_scanpos;
6696      if (jj_3R_286()) { jj_scanpos = xsp; break; }
6697    }
6698    return false;
6699  }
6700
6701  private boolean jj_3_16() {
6702    if (jj_scan_token(DOT)) return true;
6703    if (jj_scan_token(IDENTIFIER)) return true;
6704    return false;
6705  }
6706
6707  private boolean jj_3R_86() {
6708    if (jj_scan_token(IDENTIFIER)) return true;
6709    Token xsp;
6710    while (true) {
6711      xsp = jj_scanpos;
6712      if (jj_3_16()) { jj_scanpos = xsp; break; }
6713    }
6714    return false;
6715  }
6716
6717  private boolean jj_3R_111() {
6718    if (jj_3R_66()) return true;
6719    return false;
6720  }
6721
6722  private boolean jj_3R_81() {
6723    Token xsp;
6724    xsp = jj_scanpos;
6725    if (jj_scan_token(62)) {
6726    jj_scanpos = xsp;
6727    if (jj_3R_111()) return true;
6728    }
6729    return false;
6730  }
6731
6732  private boolean jj_3_15() {
6733    if (jj_3R_72()) return true;
6734    return false;
6735  }
6736
6737  private boolean jj_3R_78() {
6738    Token xsp;
6739    xsp = jj_scanpos;
6740    if (jj_scan_token(14)) {
6741    jj_scanpos = xsp;
6742    if (jj_scan_token(19)) {
6743    jj_scanpos = xsp;
6744    if (jj_scan_token(16)) {
6745    jj_scanpos = xsp;
6746    if (jj_scan_token(50)) {
6747    jj_scanpos = xsp;
6748    if (jj_scan_token(39)) {
6749    jj_scanpos = xsp;
6750    if (jj_scan_token(41)) {
6751    jj_scanpos = xsp;
6752    if (jj_scan_token(32)) {
6753    jj_scanpos = xsp;
6754    if (jj_scan_token(25)) return true;
6755    }
6756    }
6757    }
6758    }
6759    }
6760    }
6761    }
6762    return false;
6763  }
6764
6765  private boolean jj_3R_135() {
6766    if (jj_scan_token(COMMA)) return true;
6767    if (jj_3R_100()) return true;
6768    return false;
6769  }
6770
6771  private boolean jj_3_12() {
6772    if (jj_scan_token(LBRACKET)) return true;
6773    if (jj_scan_token(RBRACKET)) return true;
6774    return false;
6775  }
6776
6777  private boolean jj_3R_189() {
6778    if (jj_scan_token(SUPER)) return true;
6779    if (jj_3R_71()) return true;
6780    return false;
6781  }
6782
6783  private boolean jj_3R_152() {
6784    if (jj_3R_172()) return true;
6785    return false;
6786  }
6787
6788  private boolean jj_3R_172() {
6789    Token xsp;
6790    xsp = jj_scanpos;
6791    if (jj_3R_188()) {
6792    jj_scanpos = xsp;
6793    if (jj_3R_189()) return true;
6794    }
6795    return false;
6796  }
6797
6798  private boolean jj_3R_188() {
6799    if (jj_scan_token(EXTENDS)) return true;
6800    if (jj_3R_71()) return true;
6801    return false;
6802  }
6803
6804  private boolean jj_3R_126() {
6805    if (jj_scan_token(HOOK)) return true;
6806    Token xsp;
6807    xsp = jj_scanpos;
6808    if (jj_3R_152()) jj_scanpos = xsp;
6809    return false;
6810  }
6811
6812  private boolean jj_3_13() {
6813    if (jj_3R_72()) return true;
6814    return false;
6815  }
6816
6817  private boolean jj_3R_125() {
6818    if (jj_3R_71()) return true;
6819    return false;
6820  }
6821
6822  private boolean jj_3R_100() {
6823    Token xsp;
6824    xsp = jj_scanpos;
6825    if (jj_3R_125()) {
6826    jj_scanpos = xsp;
6827    if (jj_3R_126()) return true;
6828    }
6829    return false;
6830  }
6831
6832  private boolean jj_3_11() {
6833    if (jj_scan_token(LBRACKET)) return true;
6834    if (jj_scan_token(RBRACKET)) return true;
6835    return false;
6836  }
6837
6838  private boolean jj_3R_72() {
6839    if (jj_scan_token(LT)) return true;
6840    if (jj_3R_100()) return true;
6841    Token xsp;
6842    while (true) {
6843      xsp = jj_scanpos;
6844      if (jj_3R_135()) { jj_scanpos = xsp; break; }
6845    }
6846    if (jj_scan_token(GT)) return true;
6847    return false;
6848  }
6849
6850  private boolean jj_3_14() {
6851    if (jj_scan_token(DOT)) return true;
6852    if (jj_scan_token(IDENTIFIER)) return true;
6853    Token xsp;
6854    xsp = jj_scanpos;
6855    if (jj_3_15()) jj_scanpos = xsp;
6856    return false;
6857  }
6858
6859  /** Generated Token Manager. */
6860  public JavaParser15DebugTokenManager token_source;
6861  JavaCharStream jj_input_stream;
6862  /** Current token. */
6863  public Token token;
6864  /** Next token. */
6865  public Token jj_nt;
6866  private int jj_ntk;
6867  private Token jj_scanpos, jj_lastpos;
6868  private int jj_la;
6869  /** Whether we are looking ahead. */
6870  private boolean jj_lookingAhead = false;
6871  private boolean jj_semLA;
6872
6873  /** Constructor with InputStream. */
6874  public JavaParser15Debug(java.io.InputStream stream) {
6875     this(stream, null);
6876  }
6877  /** Constructor with InputStream and supplied encoding */
6878  public JavaParser15Debug(java.io.InputStream stream, String encoding) {
6879    try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
6880    token_source = new JavaParser15DebugTokenManager(jj_input_stream);
6881    token = new Token();
6882    jj_ntk = -1;
6883  }
6884
6885  /** Reinitialise. */
6886  public void ReInit(java.io.InputStream stream) {
6887     ReInit(stream, null);
6888  }
6889  /** Reinitialise. */
6890  public void ReInit(java.io.InputStream stream, String encoding) {
6891    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
6892    token_source.ReInit(jj_input_stream);
6893    token = new Token();
6894    jj_ntk = -1;
6895  }
6896
6897  /** Constructor. */
6898  public JavaParser15Debug(java.io.Reader stream) {
6899    jj_input_stream = new JavaCharStream(stream, 1, 1);
6900    token_source = new JavaParser15DebugTokenManager(jj_input_stream);
6901    token = new Token();
6902    jj_ntk = -1;
6903  }
6904
6905  /** Reinitialise. */
6906  public void ReInit(java.io.Reader stream) {
6907    jj_input_stream.ReInit(stream, 1, 1);
6908    token_source.ReInit(jj_input_stream);
6909    token = new Token();
6910    jj_ntk = -1;
6911  }
6912
6913  /** Constructor with generated Token Manager. */
6914  public JavaParser15Debug(JavaParser15DebugTokenManager tm) {
6915    token_source = tm;
6916    token = new Token();
6917    jj_ntk = -1;
6918  }
6919
6920  /** Reinitialise. */
6921  public void ReInit(JavaParser15DebugTokenManager tm) {
6922    token_source = tm;
6923    token = new Token();
6924    jj_ntk = -1;
6925  }
6926
6927  private Token jj_consume_token(int kind) throws ParseException {
6928    Token oldToken;
6929    if ((oldToken = token).next != null) token = token.next;
6930    else token = token.next = token_source.getNextToken();
6931    jj_ntk = -1;
6932    if (token.kind == kind) {
6933      trace_token(token, "");
6934      return token;
6935    }
6936    token = oldToken;
6937    throw generateParseException();
6938  }
6939
6940  static private final class LookaheadSuccess extends java.lang.Error { }
6941  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
6942  private boolean jj_scan_token(int kind) {
6943    if (jj_scanpos == jj_lastpos) {
6944      jj_la--;
6945      if (jj_scanpos.next == null) {
6946        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
6947      } else {
6948        jj_lastpos = jj_scanpos = jj_scanpos.next;
6949      }
6950    } else {
6951      jj_scanpos = jj_scanpos.next;
6952    }
6953    if (jj_scanpos.kind != kind) return true;
6954    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
6955    return false;
6956  }
6957
6958
6959/** Get the next Token. */
6960  final public Token getNextToken() {
6961    if (token.next != null) token = token.next;
6962    else token = token.next = token_source.getNextToken();
6963    jj_ntk = -1;
6964      trace_token(token, " (in getNextToken)");
6965    return token;
6966  }
6967
6968/** Get the specific Token. */
6969  final public Token getToken(int index) {
6970    Token t = jj_lookingAhead ? jj_scanpos : token;
6971    for (int i = 0; i < index; i++) {
6972      if (t.next != null) t = t.next;
6973      else t = t.next = token_source.getNextToken();
6974    }
6975    return t;
6976  }
6977
6978  private int jj_ntk() {
6979    if ((jj_nt=token.next) == null)
6980      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
6981    else
6982      return (jj_ntk = jj_nt.kind);
6983  }
6984
6985  /** Generate ParseException. */
6986  public ParseException generateParseException() {
6987    Token errortok = token.next;
6988    int line = errortok.beginLine, column = errortok.beginColumn;
6989    String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
6990    return new ParseException("Parse error at line " + line + ", column " + column + ".  Encountered: " + mess);
6991  }
6992
6993  private int trace_indent = 0;
6994  private boolean trace_enabled = true;
6995
6996/** Enable tracing. */
6997  final public void enable_tracing() {
6998    trace_enabled = true;
6999  }
7000
7001/** Disable tracing. */
7002  final public void disable_tracing() {
7003    trace_enabled = false;
7004  }
7005
7006  private void trace_call(String s) {
7007    if (trace_enabled) {
7008      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7009      System.out.println("Call:   " + s);
7010    }
7011    trace_indent = trace_indent + 2;
7012  }
7013
7014  private void trace_return(String s) {
7015    trace_indent = trace_indent - 2;
7016    if (trace_enabled) {
7017      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7018      System.out.println("Return: " + s);
7019    }
7020  }
7021
7022  private void trace_token(Token t, String where) {
7023    if (trace_enabled) {
7024      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7025      System.out.print("Consumed token: <" + tokenImage[t.kind]);
7026      if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
7027        System.out.print(": \"" + t.image + "\"");
7028      }
7029      System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
7030    }
7031  }
7032
7033  private void trace_scan(Token t1, int t2) {
7034    if (trace_enabled) {
7035      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
7036      System.out.print("Visited token: <" + tokenImage[t1.kind]);
7037      if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
7038        System.out.print(": \"" + t1.image + "\"");
7039      }
7040      System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
7041    }
7042  }
7043
7044}