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