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