Javaparser Android.bp

Test: mmma external/javaparser and inspect resulting
out/host/linux-x86/framework/javaparser.jar

(cherry picked from commit 2a66cdba31a132a02d16db7b065b243658250e36)

Bug: 135178920
Merged-In: Ibf69fcb1467c0414221913f2f1a9e1599b604aa0
Change-Id: Ie76c306a05e481d571276c43a5501037ead84f14

12 files changed, 15036 insertions, 0 deletions

diff --git a/Android.bp b/Android.bp
new file mode 100644
index 000000000..68567d967
--- /dev/null
+++ b/Android.bp
@@ -0,0 +1,26 @@
+// Copyright (C) 2018 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// build javaparser jar
+// ============================================================
+
+java_library_host {
+    name: "javaparser",
+
+    srcs: [
+        "javaparser-core/src/main/java/**/*.java",
+        "javaparser-core/src/main/javacc-support/**/*.java",
+        "javaparser-core/generated-sources/**/*.java",
+    ],
+}
diff --git a/javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java b/javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java
new file mode 100644
index 000000000..1fb494ece
--- /dev/null
+++ b/javaparser-core/generated-sources/java-templates/com/github/javaparser/JavaParserBuild.java
@@ -0,0 +1,19 @@
+package com.github.javaparser;
+
+/**
+ * Some information that was available when this library was built by Maven.
+ */
+public class JavaParserBuild {
+    public static final String PROJECT_VERSION = "3.5.16-SNAPSHOT";
+    public static final String PROJECT_NAME = "javaparser-core";
+    public static final String PROJECT_BUILD_FINAL_NAME = "javaparser-core-3.5.16-SNAPSHOT";
+    public static final String MAVEN_VERSION = "3.3.9";
+    public static final String MAVEN_BUILD_VERSION = "Apache Maven 3.3.9";
+    public static final String MAVEN_BUILD_TIMESTAMP = "2018-04-25T22:45:26Z";
+    public static final String JAVA_VENDOR ="Oracle Corporation";
+    public static final String JAVA_VENDOR_URL ="http://java.oracle.com/";
+    public static final String JAVA_VERSION ="9";
+    public static final String OS_ARCH ="amd64";
+    public static final String OS_NAME ="Linux";
+    public static final String OS_VERSION ="4.9.0-6-amd64";
+}
\ No newline at end of file
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java
new file mode 100644
index 000000000..88d806892
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParser.java
@@ -0,0 +1,10387 @@
+/* GeneratedJavaParser.java */
+/* Generated By:JavaCC: Do not edit this line. GeneratedJavaParser.java */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+import java.io.*;
+import java.util.*;
+import com.github.javaparser.ast.*;
+import com.github.javaparser.ast.body.*;
+import com.github.javaparser.ast.comments.*;
+import com.github.javaparser.ast.modules.*;
+import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.ast.stmt.*;
+import com.github.javaparser.ast.type.*;
+import com.github.javaparser.utils.*;
+import javax.annotation.Generated;
+import static com.github.javaparser.JavaToken.INVALID;
+import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE;
+import static com.github.javaparser.utils.Utils.*;
+import static com.github.javaparser.ast.NodeList.*;
+import static com.github.javaparser.GeneratedJavaParser.*;
+import static com.github.javaparser.Range.*;
+import static com.github.javaparser.Position.*;
+import static com.github.javaparser.ast.type.ArrayType.*;
+import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*;
+
+@Generated("JavaCC")
+final class GeneratedJavaParser extends GeneratedJavaParserBase implements GeneratedJavaParserConstants {
+    /* Returns the JavaParser specific token type of the last matched token */
+    JavaToken token() {
+        return token.javaToken;
+    }
+
+    /* Changes the amount by which the horizontal position is increased when a tab character is encountered.
+        One by default.*/
+    void setTabSize(int size) {
+        jj_input_stream.setTabSize(size);
+    }
+
+    @Override
+    GeneratedJavaParserTokenManager getTokenSource() {
+        return token_source;
+    }
+
+/*****************************************
+ * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
+ *****************************************/
+
+/*
+ * Program structuring syntax follows.
+ */
+  final public 
+CompilationUnit CompilationUnit() throws ParseException {PackageDeclaration pakage = null;
+        NodeList<ImportDeclaration> imports = emptyList();
+        ImportDeclaration in = null;
+        NodeList<TypeDeclaration<?>> types = emptyList();
+   ModifierHolder modifier;
+        TypeDeclaration tn = null;
+        ModuleDeclaration module = null;
+    try {
+      label_1:
+      while (true) {
+        if (jj_2_1(2)) {
+          ;
+        } else {
+          break label_1;
+        }
+        jj_consume_token(SEMICOLON);
+      }
+      if (jj_2_2(2147483647)) {
+        pakage = PackageDeclaration();
+      } else {
+        ;
+      }
+      label_2:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ABSTRACT:
+        case CLASS:
+        case _DEFAULT:
+        case ENUM:
+        case FINAL:
+        case IMPORT:
+        case INTERFACE:
+        case NATIVE:
+        case PRIVATE:
+        case PROTECTED:
+        case PUBLIC:
+        case STATIC:
+        case STRICTFP:
+        case SYNCHRONIZED:
+        case TRANSIENT:
+        case VOLATILE:
+        case OPEN:
+        case MODULE:
+        case TRANSITIVE:
+        case SEMICOLON:
+        case AT:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[0] = jj_gen;
+          break label_2;
+        }
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case IMPORT:{
+          in = ImportDeclaration();
+imports = add(imports, in);
+          break;
+          }
+        case ABSTRACT:
+        case CLASS:
+        case _DEFAULT:
+        case ENUM:
+        case FINAL:
+        case INTERFACE:
+        case NATIVE:
+        case PRIVATE:
+        case PROTECTED:
+        case PUBLIC:
+        case STATIC:
+        case STRICTFP:
+        case SYNCHRONIZED:
+        case TRANSIENT:
+        case VOLATILE:
+        case OPEN:
+        case MODULE:
+        case TRANSITIVE:
+        case SEMICOLON:
+        case AT:{
+          modifier = Modifiers();
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case CLASS:
+          case INTERFACE:{
+            tn = ClassOrInterfaceDeclaration(modifier);
+types = add(types, tn);
+            break;
+            }
+          case ENUM:{
+            tn = EnumDeclaration(modifier);
+types = add(types, tn);
+            break;
+            }
+          case AT:{
+            tn = AnnotationTypeDeclaration(modifier);
+types = add(types, tn);
+            break;
+            }
+          case OPEN:
+          case MODULE:{
+            module = ModuleDeclaration(modifier);
+            break;
+            }
+          case SEMICOLON:{
+            jj_consume_token(SEMICOLON);
+            break;
+            }
+          default:
+            jj_la1[1] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+          break;
+          }
+        default:
+          jj_la1[2] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case 0:{
+        jj_consume_token(0);
+        break;
+        }
+      case CTRL_Z:{
+        jj_consume_token(CTRL_Z);
+        break;
+        }
+      default:
+        jj_la1[3] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+return new CompilationUnit(range(token_source.getHomeToken(), token()), pakage, imports, types, module);
+    } catch (ParseException e) {
+recover(EOF, e);
+        final CompilationUnit compilationUnit = new CompilationUnit(range(token_source.getHomeToken(), token()), null, new NodeList<ImportDeclaration>(), new NodeList<TypeDeclaration<?>>(), null);
+        compilationUnit.setParsed(UNPARSABLE);
+        return compilationUnit;
+    }
+}
+
+  final public PackageDeclaration PackageDeclaration() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+        Name name;
+        JavaToken begin;
+    annotations = Annotations();
+    jj_consume_token(PACKAGE);
+begin = token();
+    name = Name();
+    jj_consume_token(SEMICOLON);
+return new PackageDeclaration(range(begin, token()), annotations, name);
+}
+
+  final public ImportDeclaration ImportDeclaration() throws ParseException {Name name;
+    boolean isStatic = false;
+    boolean isAsterisk = false;
+    JavaToken begin;
+    jj_consume_token(IMPORT);
+begin = token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case STATIC:{
+      jj_consume_token(STATIC);
+isStatic = true;
+      break;
+      }
+    default:
+      jj_la1[4] = jj_gen;
+      ;
+    }
+    name = Name();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case DOT:{
+      jj_consume_token(DOT);
+      jj_consume_token(STAR);
+isAsterisk = true;
+      break;
+      }
+    default:
+      jj_la1[5] = jj_gen;
+      ;
+    }
+    jj_consume_token(SEMICOLON);
+return new ImportDeclaration(range(begin, token()), name, isStatic, isAsterisk);
+}
+
+/*
+ * Modifiers. We match all modifiers in a single rule to reduce the chances of
+ * syntax errors for simple modifier mistakes. It will also enable us to give
+ * better error messages.
+ */
+  final public 
+ModifierHolder Modifiers() throws ParseException {JavaToken begin = INVALID;
+    EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class);
+        NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+    AnnotationExpr ann;
+    label_3:
+    while (true) {
+      if (jj_2_3(2)) {
+        ;
+      } else {
+        break label_3;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case PUBLIC:{
+        jj_consume_token(PUBLIC);
+addModifier(modifiers, Modifier.PUBLIC); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case STATIC:{
+        jj_consume_token(STATIC);
+addModifier(modifiers, Modifier.STATIC); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case PROTECTED:{
+        jj_consume_token(PROTECTED);
+addModifier(modifiers, Modifier.PROTECTED); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case PRIVATE:{
+        jj_consume_token(PRIVATE);
+addModifier(modifiers, Modifier.PRIVATE); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case FINAL:{
+        jj_consume_token(FINAL);
+addModifier(modifiers, Modifier.FINAL); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case ABSTRACT:{
+        jj_consume_token(ABSTRACT);
+addModifier(modifiers, Modifier.ABSTRACT); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case SYNCHRONIZED:{
+        jj_consume_token(SYNCHRONIZED);
+addModifier(modifiers, Modifier.SYNCHRONIZED); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case NATIVE:{
+        jj_consume_token(NATIVE);
+addModifier(modifiers, Modifier.NATIVE); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case TRANSIENT:{
+        jj_consume_token(TRANSIENT);
+addModifier(modifiers, Modifier.TRANSIENT); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case VOLATILE:{
+        jj_consume_token(VOLATILE);
+addModifier(modifiers, Modifier.VOLATILE); begin = orIfInvalid(begin, token());
+        break;
+        }
+      case STRICTFP:{
+        jj_consume_token(STRICTFP);
+addModifier(modifiers, Modifier.STRICTFP);  begin = orIfInvalid(begin, token());
+        break;
+        }
+      case TRANSITIVE:{
+        jj_consume_token(TRANSITIVE);
+addModifier(modifiers, Modifier.TRANSITIVE);  begin = orIfInvalid(begin, token());
+        break;
+        }
+      case _DEFAULT:{
+        jj_consume_token(_DEFAULT);
+addModifier(modifiers, Modifier.DEFAULT);  begin = orIfInvalid(begin, token());
+        break;
+        }
+      case AT:{
+        ann = Annotation();
+annotations = add(annotations, ann); begin = orIfInvalid(begin, ann);
+        break;
+        }
+      default:
+        jj_la1[6] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return new ModifierHolder(begin, modifiers, annotations);
+}
+
+/*
+ * Declaration syntax follows.
+ */
+  final public 
+ClassOrInterfaceDeclaration ClassOrInterfaceDeclaration(ModifierHolder modifier) throws ParseException {boolean isInterface = false;
+    SimpleName name;
+    RangedList<TypeParameter> typePar = new RangedList<TypeParameter>(emptyList());
+    NodeList<ClassOrInterfaceType> extList = emptyList();
+    NodeList<ClassOrInterfaceType> impList = emptyList();
+    NodeList<BodyDeclaration<?>> members = emptyList();
+    JavaToken begin = modifier.begin;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case CLASS:{
+      jj_consume_token(CLASS);
+      break;
+      }
+    case INTERFACE:{
+      jj_consume_token(INTERFACE);
+isInterface = true;
+      break;
+      }
+    default:
+      jj_la1[7] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+begin = orIfInvalid(begin, token());
+    name = SimpleName();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LT:{
+      typePar = TypeParameters();
+      break;
+      }
+    default:
+      jj_la1[8] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case EXTENDS:{
+      extList = ExtendsList();
+      break;
+      }
+    default:
+      jj_la1[9] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case IMPLEMENTS:{
+      impList = ImplementsList();
+      break;
+      }
+    default:
+      jj_la1[10] = jj_gen;
+      ;
+    }
+    members = ClassOrInterfaceBody();
+return new ClassOrInterfaceDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, isInterface, name, typePar.list, extList, impList, members);
+}
+
+  final public NodeList<ClassOrInterfaceType> ExtendsList() throws ParseException {boolean extendsMoreThanOne = false;
+   NodeList<ClassOrInterfaceType> ret = new NodeList<ClassOrInterfaceType>();
+   ClassOrInterfaceType cit;
+    jj_consume_token(EXTENDS);
+    cit = AnnotatedClassOrInterfaceType();
+ret.add(cit);
+    label_4:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[11] = jj_gen;
+        break label_4;
+      }
+      jj_consume_token(COMMA);
+      cit = AnnotatedClassOrInterfaceType();
+ret.add(cit); extendsMoreThanOne = true;
+    }
+return ret;
+}
+
+  final public NodeList<ClassOrInterfaceType> ImplementsList() throws ParseException {NodeList<ClassOrInterfaceType> ret = new NodeList<ClassOrInterfaceType>();
+   ClassOrInterfaceType cit;
+    jj_consume_token(IMPLEMENTS);
+    cit = AnnotatedClassOrInterfaceType();
+ret.add(cit);
+    label_5:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[12] = jj_gen;
+        break label_5;
+      }
+      jj_consume_token(COMMA);
+      cit = AnnotatedClassOrInterfaceType();
+ret.add(cit);
+    }
+return ret;
+}
+
+  final public EnumDeclaration EnumDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name;
+    NodeList<ClassOrInterfaceType> impList = emptyList();
+        EnumConstantDeclaration entry;
+        NodeList<EnumConstantDeclaration> entries = emptyList();
+        BodyDeclaration<?> member;
+    NodeList<BodyDeclaration<?>> members = emptyList();
+        JavaToken begin = modifier.begin;
+    jj_consume_token(ENUM);
+begin = orIfInvalid(begin, token());
+    name = SimpleName();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case IMPLEMENTS:{
+      impList = ImplementsList();
+      break;
+      }
+    default:
+      jj_la1[13] = jj_gen;
+      ;
+    }
+    jj_consume_token(LBRACE);
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ENUM:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:
+    case AT:{
+      entry = EnumConstantDeclaration();
+entries.add(entry);
+      label_6:
+      while (true) {
+        if (jj_2_4(2)) {
+          ;
+        } else {
+          break label_6;
+        }
+        jj_consume_token(COMMA);
+        entry = EnumConstantDeclaration();
+entries.add(entry);
+      }
+      break;
+      }
+    default:
+      jj_la1[14] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case COMMA:{
+      jj_consume_token(COMMA);
+      break;
+      }
+    default:
+      jj_la1[15] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case SEMICOLON:{
+      jj_consume_token(SEMICOLON);
+      label_7:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ABSTRACT:
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case CLASS:
+        case _DEFAULT:
+        case DOUBLE:
+        case ENUM:
+        case FINAL:
+        case FLOAT:
+        case INT:
+        case INTERFACE:
+        case LONG:
+        case NATIVE:
+        case PRIVATE:
+        case PROTECTED:
+        case PUBLIC:
+        case SHORT:
+        case STATIC:
+        case STRICTFP:
+        case SYNCHRONIZED:
+        case TRANSIENT:
+        case VOID:
+        case VOLATILE:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case IDENTIFIER:
+        case LBRACE:
+        case SEMICOLON:
+        case AT:
+        case LT:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[16] = jj_gen;
+          break label_7;
+        }
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ABSTRACT:
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case CLASS:
+        case _DEFAULT:
+        case DOUBLE:
+        case ENUM:
+        case FINAL:
+        case FLOAT:
+        case INT:
+        case INTERFACE:
+        case LONG:
+        case NATIVE:
+        case PRIVATE:
+        case PROTECTED:
+        case PUBLIC:
+        case SHORT:
+        case STATIC:
+        case STRICTFP:
+        case SYNCHRONIZED:
+        case TRANSIENT:
+        case VOID:
+        case VOLATILE:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case IDENTIFIER:
+        case LBRACE:
+        case AT:
+        case LT:{
+          member = ClassOrInterfaceBodyDeclaration();
+members = add(members, member);
+          break;
+          }
+        case SEMICOLON:{
+          jj_consume_token(SEMICOLON);
+          break;
+          }
+        default:
+          jj_la1[17] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+      }
+    default:
+      jj_la1[18] = jj_gen;
+      ;
+    }
+    jj_consume_token(RBRACE);
+return new EnumDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, impList, entries, members);
+}
+
+  final public EnumConstantDeclaration EnumConstantDeclaration() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+        AnnotationExpr ann;
+        SimpleName name;
+        NodeList<Expression> args = emptyList();
+        NodeList<BodyDeclaration<?>> classBody = emptyList();
+        JavaToken begin = INVALID;
+
+    label_8:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case AT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[19] = jj_gen;
+        break label_8;
+      }
+      ann = Annotation();
+annotations = add(annotations, ann); begin = orIfInvalid(begin, ann);
+    }
+    name = SimpleName();
+begin = orIfInvalid(begin, token());
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LPAREN:{
+      args = Arguments();
+      break;
+      }
+    default:
+      jj_la1[20] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LBRACE:{
+      classBody = ClassOrInterfaceBody();
+      break;
+      }
+    default:
+      jj_la1[21] = jj_gen;
+      ;
+    }
+return new EnumConstantDeclaration(range(begin, token()), annotations, name, args, classBody);
+}
+
+/**
+ * If the list inside the returned RangedList is null, there are no brackets.
+ * If it is empty, there are brackets, but nothing is in them <>.
+ * The normal case is that it contains TypeParameters, like <A, B, C>.
+ */
+  final public RangedList<TypeParameter> TypeParameters() throws ParseException {RangedList<TypeParameter> ret = new RangedList<TypeParameter>(new NodeList<TypeParameter>());
+        TypeParameter tp;
+        NodeList<AnnotationExpr> annotations;
+    jj_consume_token(LT);
+ret.beginAt(token());
+    annotations = Annotations();
+    tp = TypeParameter(annotations);
+ret.add(tp); annotations = null;
+    label_9:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[22] = jj_gen;
+        break label_9;
+      }
+      jj_consume_token(COMMA);
+      annotations = Annotations();
+      tp = TypeParameter(annotations);
+ret.add(tp); annotations = null;
+    }
+    jj_consume_token(GT);
+ret.endAt(token());
+return ret;
+}
+
+  final public TypeParameter TypeParameter(NodeList<AnnotationExpr> annotations) throws ParseException {SimpleName name;
+        NodeList<ClassOrInterfaceType> typeBound  = emptyList();
+        JavaToken begin;
+    name = SimpleName();
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case EXTENDS:{
+      typeBound = TypeBound();
+      break;
+      }
+    default:
+      jj_la1[23] = jj_gen;
+      ;
+    }
+return new TypeParameter(range(begin, token()), name, typeBound, annotations);
+}
+
+  final public NodeList<ClassOrInterfaceType> TypeBound() throws ParseException {NodeList<ClassOrInterfaceType> ret = emptyList();
+        ClassOrInterfaceType cit;
+    jj_consume_token(EXTENDS);
+    cit = AnnotatedClassOrInterfaceType();
+ret.add(cit);
+    label_10:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BIT_AND:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[24] = jj_gen;
+        break label_10;
+      }
+      jj_consume_token(BIT_AND);
+      cit = AnnotatedClassOrInterfaceType();
+ret.add(cit);
+    }
+return ret;
+}
+
+  final public NodeList<BodyDeclaration<?>> ClassOrInterfaceBody() throws ParseException {NodeList<BodyDeclaration<?>> ret = emptyList();
+        BodyDeclaration member;
+    jj_consume_token(LBRACE);
+    label_11:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ABSTRACT:
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case CLASS:
+      case _DEFAULT:
+      case DOUBLE:
+      case ENUM:
+      case FINAL:
+      case FLOAT:
+      case INT:
+      case INTERFACE:
+      case LONG:
+      case NATIVE:
+      case PRIVATE:
+      case PROTECTED:
+      case PUBLIC:
+      case SHORT:
+      case STATIC:
+      case STRICTFP:
+      case SYNCHRONIZED:
+      case TRANSIENT:
+      case VOID:
+      case VOLATILE:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:
+      case LBRACE:
+      case SEMICOLON:
+      case AT:
+      case LT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[25] = jj_gen;
+        break label_11;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ABSTRACT:
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case CLASS:
+      case _DEFAULT:
+      case DOUBLE:
+      case ENUM:
+      case FINAL:
+      case FLOAT:
+      case INT:
+      case INTERFACE:
+      case LONG:
+      case NATIVE:
+      case PRIVATE:
+      case PROTECTED:
+      case PUBLIC:
+      case SHORT:
+      case STATIC:
+      case STRICTFP:
+      case SYNCHRONIZED:
+      case TRANSIENT:
+      case VOID:
+      case VOLATILE:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:
+      case LBRACE:
+      case AT:
+      case LT:{
+        member = ClassOrInterfaceBodyDeclaration();
+ret.add(member);
+        break;
+        }
+      case SEMICOLON:{
+        jj_consume_token(SEMICOLON);
+        break;
+        }
+      default:
+        jj_la1[26] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    jj_consume_token(RBRACE);
+return ret;
+}
+
+  final public BodyDeclaration<?> ClassOrInterfaceBodyDeclaration() throws ParseException {ModifierHolder modifier;
+   BodyDeclaration<?> ret;
+    if (jj_2_9(2)) {
+      ret = InitializerDeclaration();
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ABSTRACT:
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case CLASS:
+      case _DEFAULT:
+      case DOUBLE:
+      case ENUM:
+      case FINAL:
+      case FLOAT:
+      case INT:
+      case INTERFACE:
+      case LONG:
+      case NATIVE:
+      case PRIVATE:
+      case PROTECTED:
+      case PUBLIC:
+      case SHORT:
+      case STATIC:
+      case STRICTFP:
+      case SYNCHRONIZED:
+      case TRANSIENT:
+      case VOID:
+      case VOLATILE:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:
+      case AT:
+      case LT:{
+        // Just get all the modifiers out of the way. If you want to do
+              // more checks, pass the modifiers down to the member
+                  modifier = Modifiers();
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case CLASS:
+        case INTERFACE:{
+          ret = ClassOrInterfaceDeclaration(modifier);
+          break;
+          }
+        default:
+          jj_la1[27] = jj_gen;
+          if (jj_2_5(2147483647)) {
+            ret = EnumDeclaration(modifier);
+          } else if (jj_2_6(2147483647)) {
+            ret = AnnotationTypeDeclaration(modifier);
+          } else if (jj_2_7(2147483647)) {
+            ret = ConstructorDeclaration(modifier);
+          } else if (jj_2_8(2147483647)) {
+            ret = FieldDeclaration(modifier);
+          } else {
+            switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+            case BOOLEAN:
+            case BYTE:
+            case CHAR:
+            case DOUBLE:
+            case ENUM:
+            case FLOAT:
+            case INT:
+            case LONG:
+            case SHORT:
+            case STRICTFP:
+            case VOID:
+            case REQUIRES:
+            case TO:
+            case WITH:
+            case OPEN:
+            case OPENS:
+            case USES:
+            case MODULE:
+            case EXPORTS:
+            case PROVIDES:
+            case TRANSITIVE:
+            case IDENTIFIER:
+            case AT:
+            case LT:{
+              ret = MethodDeclaration(modifier);
+              break;
+              }
+            default:
+              jj_la1[28] = jj_gen;
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+          }
+        }
+        break;
+        }
+      default:
+        jj_la1[29] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return ret;
+}
+
+  final public FieldDeclaration FieldDeclaration(ModifierHolder modifier) throws ParseException {Type partialType;
+        NodeList<VariableDeclarator> variables = new NodeList<VariableDeclarator>();
+        VariableDeclarator val;
+    // Modifiers are already matched in the caller
+        partialType = Type(emptyList());
+    val = VariableDeclarator(partialType);
+variables.add(val);
+    label_12:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[30] = jj_gen;
+        break label_12;
+      }
+      jj_consume_token(COMMA);
+      val = VariableDeclarator(partialType);
+variables.add(val);
+    }
+    jj_consume_token(SEMICOLON);
+JavaToken begin = orIfInvalid(modifier.begin, partialType);
+        return new FieldDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, variables);
+}
+
+  final public VariableDeclarator VariableDeclarator(Type partialType) throws ParseException {Pair<SimpleName, List<ArrayBracketPair>> id;
+        Expression init = null;
+    id = VariableDeclaratorId();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ASSIGN:{
+      jj_consume_token(ASSIGN);
+      init = VariableInitializer();
+      break;
+      }
+    default:
+      jj_la1[31] = jj_gen;
+      ;
+    }
+return new VariableDeclarator(range(id.a, token()), juggleArrayType(partialType, id.b), id.a, init);
+}
+
+  final public Pair<SimpleName, List<ArrayBracketPair>> VariableDeclaratorId() throws ParseException {SimpleName name;
+        JavaToken begin;
+        ArrayBracketPair arrayBracketPair;
+        List<ArrayBracketPair> arrayBracketPairs = new ArrayList(0);
+    name = SimpleName();
+begin=token();
+    label_13:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LBRACKET:
+      case AT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[32] = jj_gen;
+        break label_13;
+      }
+      arrayBracketPair = ArrayBracketPair(Origin.NAME);
+arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
+    }
+if(storeTokens) {
+            name.setTokenRange(name.getTokenRange().get().withEnd(token()));
+        }
+        return new Pair(name, arrayBracketPairs);
+}
+
+  final public Expression VariableInitializer() throws ParseException {Expression ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LBRACE:{
+      ret = ArrayInitializer();
+      break;
+      }
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case AT:
+    case BANG:
+    case TILDE:
+    case INCR:
+    case DECR:
+    case PLUS:
+    case MINUS:{
+      ret = Expression();
+      break;
+      }
+    default:
+      jj_la1[33] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public ArrayInitializerExpr ArrayInitializer() throws ParseException {NodeList<Expression> values = emptyList();
+        Expression val;
+        JavaToken begin;
+    jj_consume_token(LBRACE);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case LBRACE:
+    case AT:
+    case BANG:
+    case TILDE:
+    case INCR:
+    case DECR:
+    case PLUS:
+    case MINUS:{
+      val = VariableInitializer();
+values = add(values, val);
+      label_14:
+      while (true) {
+        if (jj_2_10(2)) {
+          ;
+        } else {
+          break label_14;
+        }
+        jj_consume_token(COMMA);
+        val = VariableInitializer();
+values = add(values, val);
+      }
+      break;
+      }
+    default:
+      jj_la1[34] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case COMMA:{
+      jj_consume_token(COMMA);
+      break;
+      }
+    default:
+      jj_la1[35] = jj_gen;
+      ;
+    }
+    jj_consume_token(RBRACE);
+return new ArrayInitializerExpr(range(begin, token()), values);
+}
+
+  final public MethodDeclaration MethodDeclaration(ModifierHolder modifier) throws ParseException {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(emptyList());
+        Type type;
+        SimpleName name;
+        Pair<NodeList<Parameter>, ReceiverParameter> parameters = new Pair<NodeList<Parameter>, ReceiverParameter>(emptyList(), null);
+        ArrayBracketPair arrayBracketPair;
+        List<ArrayBracketPair> arrayBracketPairs = new ArrayList(0);
+        NodeList<ReferenceType> throws_ = emptyList();
+        BlockStmt body = null;
+        NodeList<AnnotationExpr> annotations;
+        JavaToken begin = modifier.begin;
+        ReferenceType throwType;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LT:{
+      typeParameters = TypeParameters();
+begin = orIfInvalid(begin, typeParameters.range.getBegin());
+      break;
+      }
+    default:
+      jj_la1[36] = jj_gen;
+      ;
+    }
+    annotations = Annotations();
+modifier.annotations.addAll(annotations); begin = orIfInvalid(begin, nodeListBegin(annotations));
+    type = ResultType(emptyList());
+begin = orIfInvalid(begin, type);
+    name = SimpleName();
+    parameters = Parameters();
+    label_15:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LBRACKET:
+      case AT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[37] = jj_gen;
+        break label_15;
+      }
+      arrayBracketPair = ArrayBracketPair(Origin.NAME);
+arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case THROWS:{
+      jj_consume_token(THROWS);
+      throwType = AnnotatedReferenceType();
+throws_ = add(throws_, throwType);
+      label_16:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case COMMA:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[38] = jj_gen;
+          break label_16;
+        }
+        jj_consume_token(COMMA);
+        throwType = AnnotatedReferenceType();
+throws_ = add(throws_, throwType);
+      }
+      break;
+      }
+    default:
+      jj_la1[39] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LBRACE:{
+      body = Block();
+      break;
+      }
+    case SEMICOLON:{
+      jj_consume_token(SEMICOLON);
+      break;
+      }
+    default:
+      jj_la1[40] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+type = juggleArrayType(type, arrayBracketPairs);
+        return new MethodDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, type, name, parameters.a, throws_, body, parameters.b);
+}
+
+  final public ReferenceType AnnotatedReferenceType() throws ParseException {NodeList<AnnotationExpr> annotations;
+        ReferenceType type;
+    annotations = Annotations();
+    type = ReferenceType(annotations);
+return type;
+}
+
+  final public Type AnnotatedType() throws ParseException {NodeList<AnnotationExpr> annotations;
+        Type type;
+    annotations = Annotations();
+    type = Type(annotations);
+return type;
+}
+
+  final public Pair<NodeList<Parameter>, ReceiverParameter> Parameters() throws ParseException {NodeList<Parameter> ret = emptyList();
+        Parameter par;
+        ReceiverParameter rp = null;
+    jj_consume_token(LPAREN);
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ABSTRACT:
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case _DEFAULT:
+    case DOUBLE:
+    case ENUM:
+    case FINAL:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NATIVE:
+    case PRIVATE:
+    case PROTECTED:
+    case PUBLIC:
+    case SHORT:
+    case STATIC:
+    case STRICTFP:
+    case SYNCHRONIZED:
+    case TRANSIENT:
+    case VOLATILE:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:
+    case AT:{
+      if (jj_2_11(2147483647)) {
+        rp = ReceiverParameter();
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ABSTRACT:
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case _DEFAULT:
+        case DOUBLE:
+        case ENUM:
+        case FINAL:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NATIVE:
+        case PRIVATE:
+        case PROTECTED:
+        case PUBLIC:
+        case SHORT:
+        case STATIC:
+        case STRICTFP:
+        case SYNCHRONIZED:
+        case TRANSIENT:
+        case VOLATILE:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case IDENTIFIER:
+        case AT:{
+          par = Parameter();
+ret = add(ret, par);
+          break;
+          }
+        default:
+          jj_la1[41] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      label_17:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case COMMA:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[42] = jj_gen;
+          break label_17;
+        }
+        jj_consume_token(COMMA);
+        par = Parameter();
+ret = add(ret, par);
+      }
+      break;
+      }
+    default:
+      jj_la1[43] = jj_gen;
+      ;
+    }
+    jj_consume_token(RPAREN);
+return new Pair(ret, rp);
+}
+
+  final public NodeList<Parameter> LambdaParameters() throws ParseException {NodeList<Parameter> ret = null;
+  Parameter par;
+    par = Parameter();
+ret = add(ret, par);
+    label_18:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[44] = jj_gen;
+        break label_18;
+      }
+      jj_consume_token(COMMA);
+      par = Parameter();
+ret = add(ret, par);
+    }
+return ret;
+}
+
+  final public NodeList<Parameter> InferredLambdaParameters() throws ParseException {NodeList<Parameter> ret = null;
+    Pair<SimpleName, List<ArrayBracketPair>> id;
+    id = VariableDeclaratorId();
+ret = add(ret, new Parameter(range(id.a, id.a), EnumSet.noneOf(Modifier.class), emptyList(), new UnknownType(), false, emptyList(), id.a));
+    label_19:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[45] = jj_gen;
+        break label_19;
+      }
+      jj_consume_token(COMMA);
+      id = VariableDeclaratorId();
+ret = add(ret, new Parameter(range(id.a, id.a), EnumSet.noneOf(Modifier.class), emptyList(), new UnknownType(), false, emptyList(), id.a));
+    }
+return ret;
+}
+
+  final public Parameter Parameter() throws ParseException {ModifierHolder modifier;
+        Type partialType;
+        boolean isVarArg = false;
+        Pair<SimpleName, List<ArrayBracketPair>> id;
+        NodeList<AnnotationExpr> varArgAnnotations = emptyList();
+    modifier = Modifiers();
+    partialType = Type(emptyList());
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case AT:
+    case ELLIPSIS:{
+      varArgAnnotations = Annotations();
+      jj_consume_token(ELLIPSIS);
+isVarArg = true;
+      break;
+      }
+    default:
+      jj_la1[46] = jj_gen;
+      ;
+    }
+    id = VariableDeclaratorId();
+JavaToken begin = orIfInvalid(modifier.begin, partialType);
+        return new Parameter(range(begin, token()), modifier.modifiers, modifier.annotations, juggleArrayType(partialType, id.b), isVarArg, varArgAnnotations, id.a);
+}
+
+  final public ReceiverParameter ReceiverParameter() throws ParseException {Type partialType;
+        Name id;
+        NodeList<AnnotationExpr> annotations = emptyList();
+    annotations = Annotations();
+    partialType = Type(emptyList());
+    id = ReceiverParameterId();
+return new ReceiverParameter(range(partialType, token()), annotations, partialType, id);
+}
+
+  final public Name ReceiverParameterId() throws ParseException {Name ret = null;
+        NodeList<AnnotationExpr> annotations;
+    if (jj_2_12(2147483647)) {
+      ret = Name();
+      jj_consume_token(DOT);
+    } else {
+      ;
+    }
+    annotations = Annotations();
+    jj_consume_token(THIS);
+return new Name(tokenRange(), ret, token.image, annotations);
+}
+
+  final public ConstructorDeclaration ConstructorDeclaration(ModifierHolder modifier) throws ParseException {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(emptyList());
+        SimpleName name;
+        Pair<NodeList<Parameter>, ReceiverParameter> parameters = new Pair<NodeList<Parameter>, ReceiverParameter>(emptyList(), null);
+        NodeList<ReferenceType> throws_ = emptyList();
+        ExplicitConstructorInvocationStmt exConsInv = null;
+        NodeList<Statement> stmts = emptyList();
+    JavaToken begin = modifier.begin;
+        JavaToken blockBegin = INVALID;
+        ReferenceType throwType;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LT:{
+      typeParameters = TypeParameters();
+begin = orIfInvalid(begin, typeParameters.range.getBegin());
+      break;
+      }
+    default:
+      jj_la1[47] = jj_gen;
+      ;
+    }
+    // Modifiers matched in the caller
+      name = SimpleName();
+begin = orIfInvalid(begin, typeParameters.range.getBegin()); begin = orIfInvalid(begin, token());
+    parameters = Parameters();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case THROWS:{
+      jj_consume_token(THROWS);
+      throwType = AnnotatedReferenceType();
+throws_ = add(throws_, throwType);
+      label_20:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case COMMA:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[48] = jj_gen;
+          break label_20;
+        }
+        jj_consume_token(COMMA);
+        throwType = AnnotatedReferenceType();
+throws_ = add(throws_, throwType);
+      }
+      break;
+      }
+    default:
+      jj_la1[49] = jj_gen;
+      ;
+    }
+    jj_consume_token(LBRACE);
+blockBegin=token();
+    if (jj_2_13(2147483647)) {
+      exConsInv = ExplicitConstructorInvocation();
+    } else {
+      ;
+    }
+    stmts = Statements();
+    jj_consume_token(RBRACE);
+if (exConsInv != null) {
+                stmts = prepend(stmts, exConsInv);
+        }
+        return new ConstructorDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, name, parameters.a, throws_, new BlockStmt(range(blockBegin, token()), stmts), parameters.b);
+}
+
+  final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocation() throws ParseException {boolean isThis = false;
+        NodeList<Expression> args;
+        Expression expr = null;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+        JavaToken begin = INVALID;
+    if (jj_2_15(2147483647)) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LT:{
+        typeArgs = TypeArguments();
+begin=typeArgs.range.getBegin();
+        break;
+        }
+      default:
+        jj_la1[50] = jj_gen;
+        ;
+      }
+      jj_consume_token(THIS);
+begin = orIfInvalid(begin, token()); isThis = true;
+      args = Arguments();
+      jj_consume_token(SEMICOLON);
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:
+      case LT:{
+        if (jj_2_14(2147483647)) {
+          expr = PrimaryExpressionWithoutSuperSuffix();
+          jj_consume_token(DOT);
+begin = orIfInvalid(begin, expr);
+        } else {
+          ;
+        }
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case LT:{
+          typeArgs = TypeArguments();
+begin = orIfInvalid(begin, typeArgs.range.getBegin());
+          break;
+          }
+        default:
+          jj_la1[51] = jj_gen;
+          ;
+        }
+        jj_consume_token(SUPER);
+begin = orIfInvalid(begin, token());
+        args = Arguments();
+        jj_consume_token(SEMICOLON);
+        break;
+        }
+      default:
+        jj_la1[52] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return new ExplicitConstructorInvocationStmt(range(begin, token()),typeArgs.list, isThis, expr, args);
+}
+
+  final public NodeList<Statement> Statements() throws ParseException {NodeList<Statement> ret = emptyList();
+        Statement stmt;
+    label_21:
+    while (true) {
+      if (jj_2_16(2)) {
+        ;
+      } else {
+        break label_21;
+      }
+      stmt = BlockStatement();
+ret = add(ret, stmt);
+    }
+return ret;
+}
+
+  final public InitializerDeclaration InitializerDeclaration() throws ParseException {BlockStmt body;
+        JavaToken begin = INVALID;
+        boolean isStatic = false;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case STATIC:{
+      jj_consume_token(STATIC);
+isStatic = true; begin=token();
+      break;
+      }
+    default:
+      jj_la1[53] = jj_gen;
+      ;
+    }
+    body = Block();
+begin = orIfInvalid(begin, body);
+return new InitializerDeclaration(range(begin, token()), isStatic, body);
+}
+
+/*
+ * Type, name and expression syntax follows.
+ */
+  final public 
+Type Type(NodeList<AnnotationExpr> annotations) throws ParseException {Type ret;
+    if (jj_2_17(2)) {
+      ret = ReferenceType(annotations);
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case SHORT:{
+        ret = PrimitiveType(annotations);
+        break;
+        }
+      default:
+        jj_la1[54] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return ret;
+}
+
+  final public ReferenceType ReferenceType(NodeList<AnnotationExpr> annotations) throws ParseException {Type type;
+        ArrayBracketPair arrayBracketPair;
+        List<ArrayBracketPair> arrayBracketPairs = new ArrayList(0);
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case SHORT:{
+      type = PrimitiveType(annotations);
+      label_22:
+      while (true) {
+        arrayBracketPair = ArrayBracketPair(Origin.TYPE);
+arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
+        if (jj_2_18(2147483647)) {
+          ;
+        } else {
+          break label_22;
+        }
+      }
+      break;
+      }
+    case ENUM:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:{
+      type = ClassOrInterfaceType(annotations);
+      label_23:
+      while (true) {
+        if (jj_2_19(2147483647)) {
+          ;
+        } else {
+          break label_23;
+        }
+        arrayBracketPair = ArrayBracketPair(Origin.TYPE);
+arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
+      }
+      break;
+      }
+    default:
+      jj_la1[55] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return (ReferenceType)wrapInArrayTypes(type, arrayBracketPairs);
+}
+
+  final public ArrayBracketPair ArrayBracketPair(Origin origin) throws ParseException {NodeList<AnnotationExpr> annotations;
+    JavaToken begin = INVALID;
+    annotations = Annotations();
+    jj_consume_token(LBRACKET);
+begin = orIfInvalid(begin, token());
+    jj_consume_token(RBRACKET);
+return new ArrayBracketPair(range(begin, token()), origin, annotations);
+}
+
+  final public IntersectionType IntersectionType(NodeList<AnnotationExpr> annotations) throws ParseException {JavaToken begin = INVALID;
+        ReferenceType elementType;
+        NodeList<ReferenceType> elements = emptyList();
+    elementType = ReferenceType(annotations);
+begin = orIfInvalid(begin, elementType); elements = add(elements, elementType);
+    jj_consume_token(BIT_AND);
+    label_24:
+    while (true) {
+      elementType = AnnotatedReferenceType();
+elements = add(elements, elementType);
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case SHORT:
+      case STRICTFP:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:
+      case AT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[56] = jj_gen;
+        break label_24;
+      }
+    }
+return new IntersectionType(range(begin, token()), elements);
+}
+
+  final public ClassOrInterfaceType AnnotatedClassOrInterfaceType() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+        ClassOrInterfaceType cit;
+    annotations = Annotations();
+    cit = ClassOrInterfaceType(annotations);
+return cit;
+}
+
+  final public ClassOrInterfaceType ClassOrInterfaceType(NodeList<AnnotationExpr> firstAnnotations) throws ParseException {ClassOrInterfaceType ret;
+        SimpleName name;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+        JavaToken begin;
+        NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+    name = SimpleName();
+begin=token();
+    if (jj_2_20(2)) {
+      typeArgs = TypeArguments();
+    } else {
+      ;
+    }
+ret = new ClassOrInterfaceType(range(begin, token()), null, name, typeArgs.list, firstAnnotations);
+      typeArgs = new RangedList<Type>(null);
+    label_25:
+    while (true) {
+      if (jj_2_21(2)) {
+        ;
+      } else {
+        break label_25;
+      }
+      jj_consume_token(DOT);
+      annotations = Annotations();
+      name = SimpleName();
+      if (jj_2_22(2)) {
+        typeArgs = TypeArguments();
+      } else {
+        ;
+      }
+ret = new ClassOrInterfaceType(range(begin, token()), ret, name, typeArgs.list, annotations);
+        typeArgs = new RangedList<Type>(null);
+    }
+return ret;
+}
+
+  final public RangedList<Type> TypeArguments() throws ParseException {RangedList<Type> ret = new RangedList<Type>(new NodeList<Type>());
+        Type type;
+    jj_consume_token(LT);
+ret.beginAt(token());
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case SHORT:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:
+    case AT:
+    case HOOK:{
+      type = TypeArgument();
+ret.add(type);
+      label_26:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case COMMA:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[57] = jj_gen;
+          break label_26;
+        }
+        jj_consume_token(COMMA);
+        type = TypeArgument();
+ret.add(type);
+      }
+      break;
+      }
+    default:
+      jj_la1[58] = jj_gen;
+      ;
+    }
+    jj_consume_token(GT);
+ret.endAt(token());
+return ret;
+}
+
+  final public Type TypeArgument() throws ParseException {Type ret;
+        NodeList<AnnotationExpr> annotations;
+    annotations = Annotations();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case SHORT:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:{
+      ret = Type(annotations);
+      break;
+      }
+    case HOOK:{
+      ret = Wildcard(annotations);
+      break;
+      }
+    default:
+      jj_la1[59] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public WildcardType Wildcard(NodeList<AnnotationExpr> firstAnnotations) throws ParseException {ReferenceType ext = null;
+        ReferenceType sup = null;
+        JavaToken begin;
+        NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+    jj_consume_token(HOOK);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case EXTENDS:
+    case SUPER:{
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case EXTENDS:{
+        jj_consume_token(EXTENDS);
+        annotations = Annotations();
+        ext = ReferenceType(annotations);
+        break;
+        }
+      case SUPER:{
+        jj_consume_token(SUPER);
+        annotations = Annotations();
+        sup = ReferenceType(annotations);
+        break;
+        }
+      default:
+        jj_la1[60] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      break;
+      }
+    default:
+      jj_la1[61] = jj_gen;
+      ;
+    }
+return new WildcardType(range(begin, token()), ext, sup, firstAnnotations);
+}
+
+  final public PrimitiveType PrimitiveType(NodeList<AnnotationExpr> annotations) throws ParseException {PrimitiveType ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:{
+      jj_consume_token(BOOLEAN);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BOOLEAN, annotations);
+      break;
+      }
+    case CHAR:{
+      jj_consume_token(CHAR);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.CHAR, annotations);
+      break;
+      }
+    case BYTE:{
+      jj_consume_token(BYTE);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BYTE, annotations);
+      break;
+      }
+    case SHORT:{
+      jj_consume_token(SHORT);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.SHORT, annotations);
+      break;
+      }
+    case INT:{
+      jj_consume_token(INT);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.INT, annotations);
+      break;
+      }
+    case LONG:{
+      jj_consume_token(LONG);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.LONG, annotations);
+      break;
+      }
+    case FLOAT:{
+      jj_consume_token(FLOAT);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.FLOAT, annotations);
+      break;
+      }
+    case DOUBLE:{
+      jj_consume_token(DOUBLE);
+ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.DOUBLE, annotations);
+      break;
+      }
+    default:
+      jj_la1[62] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Type ResultType(NodeList<AnnotationExpr> annotations) throws ParseException {Type ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case VOID:{
+      jj_consume_token(VOID);
+ret = new VoidType(tokenRange());
+      break;
+      }
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case SHORT:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:{
+      ret = Type(annotations);
+      break;
+      }
+    default:
+      jj_la1[63] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Name Name() throws ParseException {Name ret;
+        NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+    annotations = Annotations();
+    Identifier();
+ret = new Name(tokenRange(), null, token.image, annotations);
+    label_27:
+    while (true) {
+      if (jj_2_23(2147483647)) {
+        ;
+      } else {
+        break label_27;
+      }
+      jj_consume_token(DOT);
+      annotations = Annotations();
+      Identifier();
+ret = new Name(range(ret, token()), ret, token.image, annotations);
+    }
+return ret;
+}
+
+  final public SimpleName SimpleName() throws ParseException {SimpleName ret;
+    Identifier();
+ret = new SimpleName(tokenRange(), token.image);
+return ret;
+}
+
+  final public String Identifier() throws ParseException {String ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case MODULE:{
+      jj_consume_token(MODULE);
+      break;
+      }
+    case REQUIRES:{
+      jj_consume_token(REQUIRES);
+      break;
+      }
+    case TO:{
+      jj_consume_token(TO);
+      break;
+      }
+    case WITH:{
+      jj_consume_token(WITH);
+      break;
+      }
+    case OPEN:{
+      jj_consume_token(OPEN);
+      break;
+      }
+    case OPENS:{
+      jj_consume_token(OPENS);
+      break;
+      }
+    case USES:{
+      jj_consume_token(USES);
+      break;
+      }
+    case EXPORTS:{
+      jj_consume_token(EXPORTS);
+      break;
+      }
+    case PROVIDES:{
+      jj_consume_token(PROVIDES);
+      break;
+      }
+    case TRANSITIVE:{
+      jj_consume_token(TRANSITIVE);
+      break;
+      }
+    case ENUM:{
+      jj_consume_token(ENUM);
+      break;
+      }
+    case STRICTFP:{
+      jj_consume_token(STRICTFP);
+      break;
+      }
+    case IDENTIFIER:{
+      jj_consume_token(IDENTIFIER);
+      break;
+      }
+    default:
+      jj_la1[64] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+ret = token.image; setTokenKind(IDENTIFIER);
+return ret;
+}
+
+/*
+ * Expression syntax follows.
+ */
+  final public 
+Expression Expression() throws ParseException {Expression ret;
+        AssignExpr.Operator op;
+        Expression value;
+        Statement lambdaBody = null;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+    ret = ConditionalExpression();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ASSIGN:
+    case PLUSASSIGN:
+    case MINUSASSIGN:
+    case STARASSIGN:
+    case SLASHASSIGN:
+    case ANDASSIGN:
+    case ORASSIGN:
+    case XORASSIGN:
+    case REMASSIGN:
+    case LSHIFTASSIGN:
+    case RSIGNEDSHIFTASSIGN:
+    case RUNSIGNEDSHIFTASSIGN:
+    case ARROW:
+    case DOUBLECOLON:{
+      if (jj_2_24(2)) {
+        op = AssignmentOperator();
+        value = Expression();
+ret = new AssignExpr(range(ret, token()), ret, value, op);
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ARROW:{
+          jj_consume_token(ARROW);
+          lambdaBody = LambdaBody();
+if (ret instanceof CastExpr) {
+                    ret = generateLambda(ret, lambdaBody);
+                } else if (ret instanceof ConditionalExpr) {
+                    ConditionalExpr ce = (ConditionalExpr) ret;
+                    if(ce.getElseExpr() != null) {
+                        ce.setElseExpr(generateLambda(ce.getElseExpr(), lambdaBody));
+                    }
+                } else {
+                    ret = generateLambda(ret, lambdaBody);
+                }
+          break;
+          }
+        case DOUBLECOLON:{
+          jj_consume_token(DOUBLECOLON);
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case LT:{
+            typeArgs = TypeArguments();
+            break;
+            }
+          default:
+            jj_la1[65] = jj_gen;
+            ;
+          }
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case ENUM:
+          case STRICTFP:
+          case REQUIRES:
+          case TO:
+          case WITH:
+          case OPEN:
+          case OPENS:
+          case USES:
+          case MODULE:
+          case EXPORTS:
+          case PROVIDES:
+          case TRANSITIVE:
+          case IDENTIFIER:{
+            Identifier();
+            break;
+            }
+          case NEW:{
+            jj_consume_token(NEW);
+            break;
+            }
+          default:
+            jj_la1[66] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image);
+          break;
+          }
+        default:
+          jj_la1[67] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+      }
+    default:
+      jj_la1[68] = jj_gen;
+      ;
+    }
+return ret;
+}
+
+  final public AssignExpr.Operator AssignmentOperator() throws ParseException {AssignExpr.Operator ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ASSIGN:{
+      jj_consume_token(ASSIGN);
+ret = AssignExpr.Operator.ASSIGN;
+      break;
+      }
+    case STARASSIGN:{
+      jj_consume_token(STARASSIGN);
+ret = AssignExpr.Operator.MULTIPLY;
+      break;
+      }
+    case SLASHASSIGN:{
+      jj_consume_token(SLASHASSIGN);
+ret = AssignExpr.Operator.DIVIDE;
+      break;
+      }
+    case REMASSIGN:{
+      jj_consume_token(REMASSIGN);
+ret = AssignExpr.Operator.REMAINDER;
+      break;
+      }
+    case PLUSASSIGN:{
+      jj_consume_token(PLUSASSIGN);
+ret = AssignExpr.Operator.PLUS;
+      break;
+      }
+    case MINUSASSIGN:{
+      jj_consume_token(MINUSASSIGN);
+ret = AssignExpr.Operator.MINUS;
+      break;
+      }
+    case LSHIFTASSIGN:{
+      jj_consume_token(LSHIFTASSIGN);
+ret = AssignExpr.Operator.LEFT_SHIFT;
+      break;
+      }
+    case RSIGNEDSHIFTASSIGN:{
+      jj_consume_token(RSIGNEDSHIFTASSIGN);
+ret = AssignExpr.Operator.SIGNED_RIGHT_SHIFT;
+      break;
+      }
+    case RUNSIGNEDSHIFTASSIGN:{
+      jj_consume_token(RUNSIGNEDSHIFTASSIGN);
+ret = AssignExpr.Operator.UNSIGNED_RIGHT_SHIFT;
+      break;
+      }
+    case ANDASSIGN:{
+      jj_consume_token(ANDASSIGN);
+ret = AssignExpr.Operator.BINARY_AND;
+      break;
+      }
+    case XORASSIGN:{
+      jj_consume_token(XORASSIGN);
+ret = AssignExpr.Operator.XOR;
+      break;
+      }
+    case ORASSIGN:{
+      jj_consume_token(ORASSIGN);
+ret = AssignExpr.Operator.BINARY_OR;
+      break;
+      }
+    default:
+      jj_la1[69] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Expression ConditionalExpression() throws ParseException {Expression ret;
+        Expression left;
+        Expression right;
+    ret = ConditionalOrExpression();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case HOOK:{
+      jj_consume_token(HOOK);
+      left = Expression();
+      jj_consume_token(COLON);
+      right = ConditionalExpression();
+ret = new ConditionalExpr(range(ret, token()), ret, left, right);
+      break;
+      }
+    default:
+      jj_la1[70] = jj_gen;
+      ;
+    }
+return ret;
+}
+
+  final public Expression ConditionalOrExpression() throws ParseException {Expression ret;
+        Expression right;
+    ret = ConditionalAndExpression();
+    label_28:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case SC_OR:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[71] = jj_gen;
+        break label_28;
+      }
+      jj_consume_token(SC_OR);
+      right = ConditionalAndExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.OR);
+    }
+return ret;
+}
+
+  final public Expression ConditionalAndExpression() throws ParseException {Expression ret;
+        Expression right;
+    ret = InclusiveOrExpression();
+    label_29:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case SC_AND:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[72] = jj_gen;
+        break label_29;
+      }
+      jj_consume_token(SC_AND);
+      right = InclusiveOrExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.AND);
+    }
+return ret;
+}
+
+  final public Expression InclusiveOrExpression() throws ParseException {Expression ret;
+        Expression right;
+    ret = ExclusiveOrExpression();
+    label_30:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BIT_OR:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[73] = jj_gen;
+        break label_30;
+      }
+      jj_consume_token(BIT_OR);
+      right = ExclusiveOrExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_OR);
+    }
+return ret;
+}
+
+  final public Expression ExclusiveOrExpression() throws ParseException {Expression ret;
+        Expression right;
+    ret = AndExpression();
+    label_31:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case XOR:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[74] = jj_gen;
+        break label_31;
+      }
+      jj_consume_token(XOR);
+      right = AndExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.XOR);
+    }
+return ret;
+}
+
+  final public Expression AndExpression() throws ParseException {Expression ret;
+        Expression right;
+    ret = EqualityExpression();
+    label_32:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BIT_AND:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[75] = jj_gen;
+        break label_32;
+      }
+      jj_consume_token(BIT_AND);
+      right = EqualityExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_AND);
+    }
+return ret;
+}
+
+  final public Expression EqualityExpression() throws ParseException {Expression ret;
+        Expression right;
+        BinaryExpr.Operator op;
+    ret = InstanceOfExpression();
+    label_33:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case EQ:
+      case NE:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[76] = jj_gen;
+        break label_33;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case EQ:{
+        jj_consume_token(EQ);
+op = BinaryExpr.Operator.EQUALS;
+        break;
+        }
+      case NE:{
+        jj_consume_token(NE);
+op = BinaryExpr.Operator.NOT_EQUALS;
+        break;
+        }
+      default:
+        jj_la1[77] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      right = InstanceOfExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, op);
+    }
+return ret;
+}
+
+  final public Expression InstanceOfExpression() throws ParseException {Expression ret;
+        ReferenceType type;
+        NodeList<AnnotationExpr> annotations;
+    ret = RelationalExpression();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case INSTANCEOF:{
+      jj_consume_token(INSTANCEOF);
+      type = AnnotatedReferenceType();
+ret = new InstanceOfExpr(range(ret, token()), ret, type);
+      break;
+      }
+    default:
+      jj_la1[78] = jj_gen;
+      ;
+    }
+return ret;
+}
+
+  final public Expression RelationalExpression() throws ParseException {Expression ret;
+        Expression right;
+        BinaryExpr.Operator op;
+    ret = ShiftExpression();
+    label_34:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LT:
+      case LE:
+      case GE:
+      case GT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[79] = jj_gen;
+        break label_34;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LT:{
+        jj_consume_token(LT);
+op = BinaryExpr.Operator.LESS;
+        break;
+        }
+      case GT:{
+        jj_consume_token(GT);
+op = BinaryExpr.Operator.GREATER;
+        break;
+        }
+      case LE:{
+        jj_consume_token(LE);
+op = BinaryExpr.Operator.LESS_EQUALS;
+        break;
+        }
+      case GE:{
+        jj_consume_token(GE);
+op = BinaryExpr.Operator.GREATER_EQUALS;
+        break;
+        }
+      default:
+        jj_la1[80] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      right = ShiftExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, op);
+    }
+return ret;
+}
+
+  final public Expression ShiftExpression() throws ParseException {Expression ret;
+        Expression right;
+        BinaryExpr.Operator op;
+    ret = AdditiveExpression();
+    label_35:
+    while (true) {
+      if (jj_2_25(1)) {
+        ;
+      } else {
+        break label_35;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LSHIFT:{
+        jj_consume_token(LSHIFT);
+op = BinaryExpr.Operator.LEFT_SHIFT;
+        break;
+        }
+      default:
+        jj_la1[81] = jj_gen;
+        if (jj_2_26(1)) {
+          RSIGNEDSHIFT();
+op = BinaryExpr.Operator.SIGNED_RIGHT_SHIFT;
+        } else if (jj_2_27(1)) {
+          RUNSIGNEDSHIFT();
+op = BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT;
+        } else {
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      right = AdditiveExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, op);
+    }
+return ret;
+}
+
+  final public Expression AdditiveExpression() throws ParseException {Expression ret;
+        Expression right;
+        BinaryExpr.Operator op;
+    ret = MultiplicativeExpression();
+    label_36:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case PLUS:
+      case MINUS:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[82] = jj_gen;
+        break label_36;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case PLUS:{
+        jj_consume_token(PLUS);
+op = BinaryExpr.Operator.PLUS;
+        break;
+        }
+      case MINUS:{
+        jj_consume_token(MINUS);
+op = BinaryExpr.Operator.MINUS;
+        break;
+        }
+      default:
+        jj_la1[83] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      right = MultiplicativeExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, op);
+    }
+return ret;
+}
+
+  final public Expression MultiplicativeExpression() throws ParseException {Expression ret;
+        Expression right;
+        BinaryExpr.Operator op;
+    ret = UnaryExpression();
+    label_37:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case STAR:
+      case SLASH:
+      case REM:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[84] = jj_gen;
+        break label_37;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case STAR:{
+        jj_consume_token(STAR);
+op = BinaryExpr.Operator.MULTIPLY;
+        break;
+        }
+      case SLASH:{
+        jj_consume_token(SLASH);
+op = BinaryExpr.Operator.DIVIDE;
+        break;
+        }
+      case REM:{
+        jj_consume_token(REM);
+op = BinaryExpr.Operator.REMAINDER;
+        break;
+        }
+      default:
+        jj_la1[85] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      right = UnaryExpression();
+ret = new BinaryExpr(range(ret, token()), ret, right, op);
+    }
+return ret;
+}
+
+  final public Expression UnaryExpression() throws ParseException {Expression ret;
+        UnaryExpr.Operator op;
+        JavaToken begin = INVALID;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case INCR:{
+      ret = PreIncrementExpression();
+      break;
+      }
+    case DECR:{
+      ret = PreDecrementExpression();
+      break;
+      }
+    case PLUS:
+    case MINUS:{
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case PLUS:{
+        jj_consume_token(PLUS);
+op = UnaryExpr.Operator.PLUS; begin=token();
+        break;
+        }
+      case MINUS:{
+        jj_consume_token(MINUS);
+op = UnaryExpr.Operator.MINUS; begin=token();
+        break;
+        }
+      default:
+        jj_la1[86] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      ret = UnaryExpression();
+ret = new UnaryExpr(range(begin, token()), ret, op);
+      break;
+      }
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case AT:
+    case BANG:
+    case TILDE:{
+      ret = UnaryExpressionNotPlusMinus();
+      break;
+      }
+    default:
+      jj_la1[87] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Expression PreIncrementExpression() throws ParseException {Expression ret;
+        JavaToken begin = INVALID;
+    jj_consume_token(INCR);
+begin=token();
+    ret = UnaryExpression();
+ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_INCREMENT);
+return ret;
+}
+
+  final public Expression PreDecrementExpression() throws ParseException {Expression ret;
+        JavaToken begin;
+    jj_consume_token(DECR);
+begin=token();
+    ret = UnaryExpression();
+ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_DECREMENT);
+return ret;
+}
+
+  final public Expression UnaryExpressionNotPlusMinus() throws ParseException {Expression ret;
+        UnaryExpr.Operator op;
+        JavaToken begin = INVALID;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BANG:
+    case TILDE:{
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case TILDE:{
+        jj_consume_token(TILDE);
+op = UnaryExpr.Operator.BITWISE_COMPLEMENT; begin=token();
+        break;
+        }
+      case BANG:{
+        jj_consume_token(BANG);
+op = UnaryExpr.Operator.LOGICAL_COMPLEMENT;     begin=token();
+        break;
+        }
+      default:
+        jj_la1[88] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      ret = UnaryExpression();
+ret = new UnaryExpr(range(begin, token()), ret, op);
+      break;
+      }
+    default:
+      jj_la1[89] = jj_gen;
+      if (jj_2_28(2147483647)) {
+        ret = CastExpression();
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case DOUBLE:
+        case ENUM:
+        case FALSE:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NEW:
+        case NULL:
+        case SHORT:
+        case STRICTFP:
+        case SUPER:
+        case THIS:
+        case TRUE:
+        case VOID:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case LONG_LITERAL:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case AT:{
+          ret = PostfixExpression();
+          break;
+          }
+        default:
+          jj_la1[90] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+    }
+return ret;
+}
+
+  final public Expression PostfixExpression() throws ParseException {Expression ret;
+        UnaryExpr.Operator op;
+    ret = PrimaryExpression();
+    if (jj_2_29(2)) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case INCR:{
+        jj_consume_token(INCR);
+op = UnaryExpr.Operator.POSTFIX_INCREMENT;
+        break;
+        }
+      case DECR:{
+        jj_consume_token(DECR);
+op = UnaryExpr.Operator.POSTFIX_DECREMENT;
+        break;
+        }
+      default:
+        jj_la1[91] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+ret = new UnaryExpr(range(ret, token()), ret, op);
+    } else {
+      ;
+    }
+return ret;
+}
+
+  final public Expression CastExpression() throws ParseException {Expression ret;
+        ReferenceType referenceType;
+        PrimitiveType primitiveType;
+        JavaToken begin = INVALID;
+        NodeList<AnnotationExpr> annotations;
+        NodeList<ReferenceType> typesOfMultiCast = emptyList();
+    jj_consume_token(LPAREN);
+begin=token();
+    annotations = Annotations();
+    if (jj_2_30(2)) {
+      primitiveType = PrimitiveType(annotations);
+      jj_consume_token(RPAREN);
+      ret = UnaryExpression();
+ret = new CastExpr(range(begin, token()), primitiveType, ret);
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case SHORT:
+      case STRICTFP:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:{
+        referenceType = ReferenceType(annotations);
+typesOfMultiCast = add(typesOfMultiCast, referenceType);
+        label_38:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case BIT_AND:{
+            ;
+            break;
+            }
+          default:
+            jj_la1[92] = jj_gen;
+            break label_38;
+          }
+          jj_consume_token(BIT_AND);
+          referenceType = AnnotatedReferenceType();
+typesOfMultiCast = add(typesOfMultiCast, referenceType);
+        }
+        jj_consume_token(RPAREN);
+        ret = UnaryExpressionNotPlusMinus();
+if (typesOfMultiCast.size() > 1) {
+                ret = new CastExpr(range(begin, token()), new IntersectionType(range(typesOfMultiCast.get(0), typesOfMultiCast.get(typesOfMultiCast.size() -1)), typesOfMultiCast), ret);
+            } else {
+                ret = new CastExpr(range(begin, token()), referenceType, ret);
+            }
+        break;
+        }
+      default:
+        jj_la1[93] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return ret;
+}
+
+  final public Expression PrimaryExpression() throws ParseException {Expression ret;
+    ret = PrimaryPrefix();
+    label_39:
+    while (true) {
+      if (jj_2_31(2)) {
+        ;
+      } else {
+        break label_39;
+      }
+      ret = PrimarySuffix(ret);
+    }
+return ret;
+}
+
+  final public Expression PrimaryExpressionWithoutSuperSuffix() throws ParseException {Expression ret;
+    ret = PrimaryPrefix();
+    label_40:
+    while (true) {
+      if (jj_2_32(2147483647)) {
+        ;
+      } else {
+        break label_40;
+      }
+      ret = PrimarySuffixWithoutSuper(ret);
+    }
+return ret;
+}
+
+  final public Expression PrimaryPrefix() throws ParseException {Expression ret = null;
+        SimpleName name;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+        NodeList<Expression> args = emptyList();
+        NodeList<Parameter> params = emptyList();
+        boolean hasArgs = false;
+        boolean isLambda = false;
+        Type type;
+        JavaToken begin;
+        Parameter p = null;
+        SimpleName id = null;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case FALSE:
+    case NULL:
+    case TRUE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:{
+      ret = Literal();
+      break;
+      }
+    case THIS:{
+      jj_consume_token(THIS);
+ret = new ThisExpr(tokenRange(), null);
+      break;
+      }
+    case SUPER:{
+      jj_consume_token(SUPER);
+ret = new SuperExpr(tokenRange(), null);
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case DOT:{
+        jj_consume_token(DOT);
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case LT:{
+          typeArgs = TypeArguments();
+          break;
+          }
+        default:
+          jj_la1[94] = jj_gen;
+          ;
+        }
+        name = SimpleName();
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case LPAREN:{
+          args = Arguments();
+hasArgs=true;
+          break;
+          }
+        default:
+          jj_la1[95] = jj_gen;
+          ;
+        }
+if (hasArgs) {
+                                ret = new MethodCallExpr(range(ret, token()), ret, typeArgs.list, name, args);
+                        } else {
+                                ret = new FieldAccessExpr(range(ret, token()), ret, emptyList(), name);
+                        }
+        break;
+        }
+      case DOUBLECOLON:{
+        jj_consume_token(DOUBLECOLON);
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case LT:{
+          typeArgs = TypeArguments();
+          break;
+          }
+        default:
+          jj_la1[96] = jj_gen;
+          ;
+        }
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ENUM:
+        case STRICTFP:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case IDENTIFIER:{
+          Identifier();
+          break;
+          }
+        case NEW:{
+          jj_consume_token(NEW);
+          break;
+          }
+        default:
+          jj_la1[97] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image);
+        break;
+        }
+      default:
+        jj_la1[98] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      break;
+      }
+    case LPAREN:{
+      jj_consume_token(LPAREN);
+begin=token();
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case RPAREN:{
+        jj_consume_token(RPAREN);
+ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true);
+        break;
+        }
+      default:
+        jj_la1[99] = jj_gen;
+        if (jj_2_33(2147483647)) {
+          params = LambdaParameters();
+          jj_consume_token(RPAREN);
+ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true);
+        } else if (jj_2_34(2147483647)) {
+          params = InferredLambdaParameters();
+          jj_consume_token(RPAREN);
+ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true);
+        } else {
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case BOOLEAN:
+          case BYTE:
+          case CHAR:
+          case DOUBLE:
+          case ENUM:
+          case FALSE:
+          case FLOAT:
+          case INT:
+          case LONG:
+          case NEW:
+          case NULL:
+          case SHORT:
+          case STRICTFP:
+          case SUPER:
+          case THIS:
+          case TRUE:
+          case VOID:
+          case REQUIRES:
+          case TO:
+          case WITH:
+          case OPEN:
+          case OPENS:
+          case USES:
+          case MODULE:
+          case EXPORTS:
+          case PROVIDES:
+          case TRANSITIVE:
+          case LONG_LITERAL:
+          case INTEGER_LITERAL:
+          case FLOATING_POINT_LITERAL:
+          case CHARACTER_LITERAL:
+          case STRING_LITERAL:
+          case IDENTIFIER:
+          case LPAREN:
+          case AT:
+          case BANG:
+          case TILDE:
+          case INCR:
+          case DECR:
+          case PLUS:
+          case MINUS:{
+            // This could still be a lambda expression, but this is handled after matching -> elsewhere
+                        ret = Expression();
+            jj_consume_token(RPAREN);
+ret = new EnclosedExpr(range(begin, token()), ret);
+            break;
+            }
+          default:
+            jj_la1[100] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+      }
+      break;
+      }
+    case NEW:{
+      ret = AllocationExpression(null);
+      break;
+      }
+    default:
+      jj_la1[104] = jj_gen;
+      if (jj_2_35(2147483647)) {
+        type = ResultType(emptyList());
+        jj_consume_token(DOT);
+        jj_consume_token(CLASS);
+ret = new ClassExpr(range(type, token()), type);
+      } else if (jj_2_36(2147483647)) {
+        type = AnnotatedType();
+        jj_consume_token(DOUBLECOLON);
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case LT:{
+          typeArgs = TypeArguments();
+          break;
+          }
+        default:
+          jj_la1[101] = jj_gen;
+          ;
+        }
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ENUM:
+        case STRICTFP:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case IDENTIFIER:{
+          Identifier();
+          break;
+          }
+        case NEW:{
+          jj_consume_token(NEW);
+          break;
+          }
+        default:
+          jj_la1[102] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+ret = new TypeExpr(range(type, type), type);
+                  ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image);
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ENUM:
+        case STRICTFP:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case IDENTIFIER:{
+          name = SimpleName();
+begin=token();
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case LPAREN:{
+            args = Arguments();
+hasArgs=true;
+            break;
+            }
+          default:
+            jj_la1[103] = jj_gen;
+            ;
+          }
+if (hasArgs) {
+                                ret = new MethodCallExpr(range(begin, token()), null, null, name, args);
+                        } else {
+                                ret = new NameExpr(name);
+                        }
+          break;
+          }
+        default:
+          jj_la1[105] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+    }
+return ret;
+}
+
+  final public Expression PrimarySuffix(Expression scope) throws ParseException {Expression ret;
+    if (jj_2_37(2)) {
+      ret = PrimarySuffixWithoutSuper(scope);
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case DOT:{
+        jj_consume_token(DOT);
+        jj_consume_token(SUPER);
+ret = new SuperExpr(range(scope, token()), scope);
+        break;
+        }
+      default:
+        jj_la1[106] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return ret;
+}
+
+  final public Expression PrimarySuffixWithoutSuper(Expression scope) throws ParseException {Expression ret;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+        NodeList<Expression> args = emptyList();
+        boolean hasArgs = false;
+        SimpleName name;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case DOT:{
+      jj_consume_token(DOT);
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case THIS:{
+        jj_consume_token(THIS);
+ret = new ThisExpr(range(scope, token()), scope);
+        break;
+        }
+      case NEW:{
+        ret = AllocationExpression(scope);
+        break;
+        }
+      default:
+        jj_la1[109] = jj_gen;
+        if (jj_2_38(2147483647)) {
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case LT:{
+            typeArgs = TypeArguments();
+            break;
+            }
+          default:
+            jj_la1[107] = jj_gen;
+            ;
+          }
+          name = SimpleName();
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case LPAREN:{
+            args = Arguments();
+hasArgs=true;
+            break;
+            }
+          default:
+            jj_la1[108] = jj_gen;
+            ;
+          }
+if (hasArgs) {
+                                ret = new MethodCallExpr(range(scope, token()), scope, typeArgs.list, name, args);
+                        } else {
+                                ret =  new FieldAccessExpr(range(scope, token()), scope, typeArgs.list, name);
+                        }
+        } else {
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      break;
+      }
+    case LBRACKET:{
+      jj_consume_token(LBRACKET);
+      ret = Expression();
+      jj_consume_token(RBRACKET);
+ret = new ArrayAccessExpr(range(scope, token()), scope, ret);
+      break;
+      }
+    default:
+      jj_la1[110] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Expression Literal() throws ParseException {Expression ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case INTEGER_LITERAL:{
+      jj_consume_token(INTEGER_LITERAL);
+ret = new IntegerLiteralExpr(tokenRange(), token.image);
+      break;
+      }
+    case LONG_LITERAL:{
+      jj_consume_token(LONG_LITERAL);
+ret = new LongLiteralExpr(tokenRange(), token.image);
+      break;
+      }
+    case FLOATING_POINT_LITERAL:{
+      jj_consume_token(FLOATING_POINT_LITERAL);
+ret = new DoubleLiteralExpr(tokenRange(), token.image);
+      break;
+      }
+    case CHARACTER_LITERAL:{
+      jj_consume_token(CHARACTER_LITERAL);
+ret = new CharLiteralExpr(tokenRange(), token.image.substring(1, token.image.length()-1));
+      break;
+      }
+    case STRING_LITERAL:{
+      jj_consume_token(STRING_LITERAL);
+ret = new StringLiteralExpr(tokenRange(), token.image.substring(1, token.image.length()-1));
+      break;
+      }
+    case FALSE:
+    case TRUE:{
+      ret = BooleanLiteral();
+      break;
+      }
+    case NULL:{
+      ret = NullLiteral();
+      break;
+      }
+    default:
+      jj_la1[111] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Expression BooleanLiteral() throws ParseException {Expression ret;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case TRUE:{
+      jj_consume_token(TRUE);
+ret = new BooleanLiteralExpr(tokenRange(), true);
+      break;
+      }
+    case FALSE:{
+      jj_consume_token(FALSE);
+ret = new BooleanLiteralExpr(tokenRange(), false);
+      break;
+      }
+    default:
+      jj_la1[112] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public Expression NullLiteral() throws ParseException {
+    jj_consume_token(NULL);
+return new NullLiteralExpr(tokenRange());
+}
+
+  final public NodeList<Expression> Arguments() throws ParseException {NodeList<Expression> ret = emptyList();
+    jj_consume_token(LPAREN);
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case AT:
+    case BANG:
+    case TILDE:
+    case INCR:
+    case DECR:
+    case PLUS:
+    case MINUS:{
+      ret = ArgumentList();
+      break;
+      }
+    default:
+      jj_la1[113] = jj_gen;
+      ;
+    }
+    jj_consume_token(RPAREN);
+return ret;
+}
+
+  final public NodeList<Expression> ArgumentList() throws ParseException {NodeList<Expression> ret = emptyList();
+        Expression expr;
+    expr = Expression();
+ret.add(expr);
+    label_41:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[114] = jj_gen;
+        break label_41;
+      }
+      jj_consume_token(COMMA);
+      expr = Expression();
+ret.add(expr);
+    }
+return ret;
+}
+
+  final public Expression AllocationExpression(Expression scope) throws ParseException {Expression ret;
+        Type type;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+        NodeList<BodyDeclaration<?>> anonymousBody = null;
+        NodeList<Expression> args;
+        JavaToken begin = INVALID;
+        NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+    jj_consume_token(NEW);
+if(scope==null) {begin=token();} else {begin = orIfInvalid(begin, scope);}
+    annotations = Annotations();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case SHORT:{
+      type = PrimitiveType(annotations);
+      ret = ArrayCreation(begin, type);
+      break;
+      }
+    case ENUM:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:
+    case AT:
+    case LT:{
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LT:{
+        typeArgs = TypeArguments();
+        break;
+        }
+      default:
+        jj_la1[115] = jj_gen;
+        ;
+      }
+      type = AnnotatedClassOrInterfaceType();
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LBRACKET:
+      case AT:{
+        ret = ArrayCreation(begin, type);
+        break;
+        }
+      case LPAREN:{
+        args = Arguments();
+        if (jj_2_39(2)) {
+          anonymousBody = ClassOrInterfaceBody();
+        } else {
+          ;
+        }
+ret = new ObjectCreationExpr(range(begin, token()), scope, (ClassOrInterfaceType) type, typeArgs.list, args, anonymousBody);
+        break;
+        }
+      default:
+        jj_la1[116] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      break;
+      }
+    default:
+      jj_la1[117] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return ret;
+}
+
+  final public ArrayCreationExpr ArrayCreation(JavaToken begin, Type type) throws ParseException {Expression expr = null;
+        ArrayInitializerExpr arrayInitializerExpr = null;
+        NodeList<Expression> inits = emptyList();
+        List<NodeList<AnnotationExpr>> accum = new ArrayList<NodeList<AnnotationExpr>>();
+        NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+        JavaToken arrayCreationLevelStart = INVALID;
+        List<TokenRange> levelRanges = new ArrayList<TokenRange>();
+    label_42:
+    while (true) {
+      annotations = Annotations();
+      jj_consume_token(LBRACKET);
+arrayCreationLevelStart = annotations.isEmpty() ? token() : orIfInvalid(arrayCreationLevelStart, annotations.get(0));
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:
+      case BANG:
+      case TILDE:
+      case INCR:
+      case DECR:
+      case PLUS:
+      case MINUS:{
+        expr = Expression();
+        break;
+        }
+      default:
+        jj_la1[118] = jj_gen;
+        ;
+      }
+accum = add(accum, annotations); inits = add(inits, expr); annotations=null; expr=null;
+      jj_consume_token(RBRACKET);
+levelRanges.add(range(arrayCreationLevelStart, token()));
+      if (jj_2_40(2)) {
+        ;
+      } else {
+        break label_42;
+      }
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LBRACE:{
+      arrayInitializerExpr = ArrayInitializer();
+      break;
+      }
+    default:
+      jj_la1[119] = jj_gen;
+      ;
+    }
+return juggleArrayCreation(range(begin, token()), levelRanges, type, inits, accum, arrayInitializerExpr);
+}
+
+/*
+ * Statement syntax follows.
+ */
+  final public 
+Statement Statement() throws ParseException {Statement ret;
+    try {
+      if (jj_2_41(2)) {
+        ret = LabeledStatement();
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ASSERT:{
+          ret = AssertStatement();
+          break;
+          }
+        case LBRACE:{
+          ret = Block();
+          break;
+          }
+        case SEMICOLON:{
+          ret = EmptyStatement();
+          break;
+          }
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case DOUBLE:
+        case ENUM:
+        case FALSE:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NEW:
+        case NULL:
+        case SHORT:
+        case STRICTFP:
+        case SUPER:
+        case THIS:
+        case TRUE:
+        case VOID:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case LONG_LITERAL:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case AT:
+        case INCR:
+        case DECR:{
+          ret = StatementExpression();
+          break;
+          }
+        case SWITCH:{
+          ret = SwitchStatement();
+          break;
+          }
+        case IF:{
+          ret = IfStatement();
+          break;
+          }
+        case WHILE:{
+          ret = WhileStatement();
+          break;
+          }
+        case DO:{
+          ret = DoStatement();
+          break;
+          }
+        case FOR:{
+          ret = ForStatement();
+          break;
+          }
+        case BREAK:{
+          ret = BreakStatement();
+          break;
+          }
+        case CONTINUE:{
+          ret = ContinueStatement();
+          break;
+          }
+        case RETURN:{
+          ret = ReturnStatement();
+          break;
+          }
+        case THROW:{
+          ret = ThrowStatement();
+          break;
+          }
+        case SYNCHRONIZED:{
+          ret = SynchronizedStatement();
+          break;
+          }
+        case TRY:{
+          ret = TryStatement();
+          break;
+          }
+        default:
+          jj_la1[120] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+return ret;
+    } catch (ParseException e) {
+TokenRange errorRange = recover(SEMICOLON, e);
+        return new UnparsableStmt(errorRange);
+    }
+}
+
+  final public AssertStmt AssertStatement() throws ParseException {Expression check;
+        Expression msg = null;
+        JavaToken begin;
+    jj_consume_token(ASSERT);
+begin=token();
+    check = Expression();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case COLON:{
+      jj_consume_token(COLON);
+      msg = Expression();
+      break;
+      }
+    default:
+      jj_la1[121] = jj_gen;
+      ;
+    }
+    jj_consume_token(SEMICOLON);
+return new AssertStmt(range(begin, token()), check, msg);
+}
+
+  final public LabeledStmt LabeledStatement() throws ParseException {SimpleName label;
+        Statement stmt;
+        JavaToken begin;
+    label = SimpleName();
+begin=token();
+    jj_consume_token(COLON);
+    stmt = Statement();
+return new LabeledStmt(range(begin, token()), label, stmt);
+}
+
+  final public BlockStmt Block() throws ParseException {NodeList<Statement> stmts = emptyList();
+        JavaToken begin;
+    jj_consume_token(LBRACE);
+begin=token();
+    try {
+      stmts = Statements();
+      jj_consume_token(RBRACE);
+return new BlockStmt(range(begin, token()), stmts);
+    } catch (ParseException e) {
+recover(RBRACE, e);
+        BlockStmt block = new BlockStmt(range(begin, token()), new NodeList<Statement>());
+        block.setParsed(UNPARSABLE);
+        return block;
+    }
+}
+
+/*
+ * Classes inside body statements can only be abstract or final. The semantic must check it.
+ */
+  final public Statement BlockStatement() throws ParseException {Statement ret;
+        Expression expr;
+        ClassOrInterfaceDeclaration typeDecl;
+        ModifierHolder modifier;
+    try {
+      if (jj_2_42(2147483647)) {
+        modifier = Modifiers();
+        typeDecl = ClassOrInterfaceDeclaration(modifier);
+ret = new LocalClassDeclarationStmt(range(typeDecl, token()), typeDecl);
+      } else if (jj_2_43(2147483647)) {
+        expr = VariableDeclarationExpression();
+        jj_consume_token(SEMICOLON);
+ret = new ExpressionStmt(range(expr, token()), expr);
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ASSERT:
+        case BOOLEAN:
+        case BREAK:
+        case BYTE:
+        case CHAR:
+        case CONTINUE:
+        case DO:
+        case DOUBLE:
+        case ENUM:
+        case FALSE:
+        case FLOAT:
+        case FOR:
+        case IF:
+        case INT:
+        case LONG:
+        case NEW:
+        case NULL:
+        case RETURN:
+        case SHORT:
+        case STRICTFP:
+        case SUPER:
+        case SWITCH:
+        case SYNCHRONIZED:
+        case THIS:
+        case THROW:
+        case TRUE:
+        case TRY:
+        case VOID:
+        case WHILE:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case LONG_LITERAL:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case LBRACE:
+        case SEMICOLON:
+        case AT:
+        case INCR:
+        case DECR:{
+          ret = Statement();
+          break;
+          }
+        default:
+          jj_la1[122] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+return ret;
+    } catch (ParseException e) {
+TokenRange errorRange = recover(SEMICOLON, e);
+        return new UnparsableStmt(errorRange);
+    }
+}
+
+  final public VariableDeclarationExpr VariableDeclarationExpression() throws ParseException {ModifierHolder modifier;
+        Type partialType;
+        NodeList<VariableDeclarator> variables = new NodeList<VariableDeclarator>();
+        VariableDeclarator var;
+    modifier = Modifiers();
+    partialType = Type(emptyList());
+    var = VariableDeclarator(partialType);
+variables.add(var);
+    label_43:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[123] = jj_gen;
+        break label_43;
+      }
+      jj_consume_token(COMMA);
+      var = VariableDeclarator(partialType);
+variables.add(var);
+    }
+JavaToken begin=orIfInvalid(modifier.begin, partialType);
+        return new VariableDeclarationExpr(range(begin, token()), modifier.modifiers, modifier.annotations, variables);
+}
+
+  final public EmptyStmt EmptyStatement() throws ParseException {
+    jj_consume_token(SEMICOLON);
+return new EmptyStmt(tokenRange());
+}
+
+  final public Statement LambdaBody() throws ParseException {Expression expr;
+    Statement n = null;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case AT:
+    case BANG:
+    case TILDE:
+    case INCR:
+    case DECR:
+    case PLUS:
+    case MINUS:{
+      expr = Expression();
+n = new ExpressionStmt(range(expr, token()), expr);
+      break;
+      }
+    case LBRACE:{
+      n = Block();
+      break;
+      }
+    default:
+      jj_la1[124] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+return n;
+}
+
+  final public ExpressionStmt StatementExpression() throws ParseException {Expression expr;
+        AssignExpr.Operator op;
+        Expression value;
+        RangedList<Type> typeArgs = new RangedList<Type>(null);
+        Statement lambdaBody;
+    if (jj_2_44(2)) {
+      expr = PreIncrementExpression();
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case DECR:{
+        expr = PreDecrementExpression();
+        break;
+        }
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:{
+        expr = PrimaryExpression();
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ASSIGN:
+        case INCR:
+        case DECR:
+        case PLUSASSIGN:
+        case MINUSASSIGN:
+        case STARASSIGN:
+        case SLASHASSIGN:
+        case ANDASSIGN:
+        case ORASSIGN:
+        case XORASSIGN:
+        case REMASSIGN:
+        case LSHIFTASSIGN:
+        case RSIGNEDSHIFTASSIGN:
+        case RUNSIGNEDSHIFTASSIGN:{
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case INCR:{
+            jj_consume_token(INCR);
+expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_INCREMENT);
+            break;
+            }
+          case DECR:{
+            jj_consume_token(DECR);
+expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_DECREMENT);
+            break;
+            }
+          case ASSIGN:
+          case PLUSASSIGN:
+          case MINUSASSIGN:
+          case STARASSIGN:
+          case SLASHASSIGN:
+          case ANDASSIGN:
+          case ORASSIGN:
+          case XORASSIGN:
+          case REMASSIGN:
+          case LSHIFTASSIGN:
+          case RSIGNEDSHIFTASSIGN:
+          case RUNSIGNEDSHIFTASSIGN:{
+            op = AssignmentOperator();
+            value = Expression();
+expr = new AssignExpr(range(expr, token()), expr, value, op);
+            break;
+            }
+          default:
+            jj_la1[125] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+          break;
+          }
+        default:
+          jj_la1[126] = jj_gen;
+          ;
+        }
+        break;
+        }
+      default:
+        jj_la1[127] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    jj_consume_token(SEMICOLON);
+return new ExpressionStmt(range(expr, token()), expr);
+}
+
+  final public SwitchStmt SwitchStatement() throws ParseException {Expression selector;
+        SwitchEntryStmt entry;
+        NodeList<SwitchEntryStmt> entries = emptyList();
+        JavaToken begin;
+    jj_consume_token(SWITCH);
+begin=token();
+    jj_consume_token(LPAREN);
+    selector = Expression();
+    jj_consume_token(RPAREN);
+    jj_consume_token(LBRACE);
+    label_44:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case CASE:
+      case _DEFAULT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[128] = jj_gen;
+        break label_44;
+      }
+      entry = SwitchEntry();
+entries = add(entries, entry);
+    }
+    jj_consume_token(RBRACE);
+return new SwitchStmt(range(begin, token()), selector, entries);
+}
+
+  final public SwitchEntryStmt SwitchEntry() throws ParseException {Expression label = null;
+        NodeList<Statement> stmts;
+        JavaToken begin;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case CASE:{
+      jj_consume_token(CASE);
+begin=token();
+      label = Expression();
+      break;
+      }
+    case _DEFAULT:{
+      jj_consume_token(_DEFAULT);
+begin=token();
+      break;
+      }
+    default:
+      jj_la1[129] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    jj_consume_token(COLON);
+    stmts = Statements();
+return new SwitchEntryStmt(range(begin, token()),label, stmts);
+}
+
+  final public IfStmt IfStatement() throws ParseException {Expression condition;
+        Statement thenStmt;
+        Statement elseStmt = null;
+        JavaToken begin;
+    jj_consume_token(IF);
+begin=token();
+    jj_consume_token(LPAREN);
+    condition = Expression();
+    jj_consume_token(RPAREN);
+
+    thenStmt = Statement();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ELSE:{
+      jj_consume_token(ELSE);
+
+      elseStmt = Statement();
+      break;
+      }
+    default:
+      jj_la1[130] = jj_gen;
+      ;
+    }
+return new IfStmt(range(begin, token()), condition, thenStmt, elseStmt);
+}
+
+  final public WhileStmt WhileStatement() throws ParseException {Expression condition;
+        Statement body;
+        JavaToken begin;
+    jj_consume_token(WHILE);
+begin=token();
+    jj_consume_token(LPAREN);
+    condition = Expression();
+    jj_consume_token(RPAREN);
+    body = Statement();
+return new WhileStmt(range(begin, token()),condition, body);
+}
+
+  final public DoStmt DoStatement() throws ParseException {Expression condition;
+        Statement body;
+        JavaToken begin;
+    jj_consume_token(DO);
+begin=token();
+    body = Statement();
+    jj_consume_token(WHILE);
+    jj_consume_token(LPAREN);
+    condition = Expression();
+    jj_consume_token(RPAREN);
+    jj_consume_token(SEMICOLON);
+return new DoStmt(range(begin, token()),body, condition);
+}
+
+  final public Statement ForStatement() throws ParseException {VariableDeclarationExpr varExpr = null;
+        Expression expr = null;
+        NodeList<Expression> init = emptyList();
+        NodeList<Expression> update = emptyList();
+        Statement body;
+        JavaToken begin;
+    jj_consume_token(FOR);
+begin=token();
+    jj_consume_token(LPAREN);
+    if (jj_2_45(2147483647)) {
+      varExpr = VariableDeclarationExpression();
+      jj_consume_token(COLON);
+      expr = Expression();
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ABSTRACT:
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case _DEFAULT:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FINAL:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NATIVE:
+      case NEW:
+      case NULL:
+      case PRIVATE:
+      case PROTECTED:
+      case PUBLIC:
+      case SHORT:
+      case STATIC:
+      case STRICTFP:
+      case SUPER:
+      case SYNCHRONIZED:
+      case THIS:
+      case TRANSIENT:
+      case TRUE:
+      case VOID:
+      case VOLATILE:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case SEMICOLON:
+      case AT:
+      case BANG:
+      case TILDE:
+      case INCR:
+      case DECR:
+      case PLUS:
+      case MINUS:{
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case ABSTRACT:
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case _DEFAULT:
+        case DOUBLE:
+        case ENUM:
+        case FALSE:
+        case FINAL:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NATIVE:
+        case NEW:
+        case NULL:
+        case PRIVATE:
+        case PROTECTED:
+        case PUBLIC:
+        case SHORT:
+        case STATIC:
+        case STRICTFP:
+        case SUPER:
+        case SYNCHRONIZED:
+        case THIS:
+        case TRANSIENT:
+        case TRUE:
+        case VOID:
+        case VOLATILE:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case LONG_LITERAL:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case AT:
+        case BANG:
+        case TILDE:
+        case INCR:
+        case DECR:
+        case PLUS:
+        case MINUS:{
+          init = ForInit();
+          break;
+          }
+        default:
+          jj_la1[131] = jj_gen;
+          ;
+        }
+        jj_consume_token(SEMICOLON);
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case DOUBLE:
+        case ENUM:
+        case FALSE:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NEW:
+        case NULL:
+        case SHORT:
+        case STRICTFP:
+        case SUPER:
+        case THIS:
+        case TRUE:
+        case VOID:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case LONG_LITERAL:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case AT:
+        case BANG:
+        case TILDE:
+        case INCR:
+        case DECR:
+        case PLUS:
+        case MINUS:{
+          expr = Expression();
+          break;
+          }
+        default:
+          jj_la1[132] = jj_gen;
+          ;
+        }
+        jj_consume_token(SEMICOLON);
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case DOUBLE:
+        case ENUM:
+        case FALSE:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NEW:
+        case NULL:
+        case SHORT:
+        case STRICTFP:
+        case SUPER:
+        case THIS:
+        case TRUE:
+        case VOID:
+        case REQUIRES:
+        case TO:
+        case WITH:
+        case OPEN:
+        case OPENS:
+        case USES:
+        case MODULE:
+        case EXPORTS:
+        case PROVIDES:
+        case TRANSITIVE:
+        case LONG_LITERAL:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case AT:
+        case BANG:
+        case TILDE:
+        case INCR:
+        case DECR:
+        case PLUS:
+        case MINUS:{
+          update = ForUpdate();
+          break;
+          }
+        default:
+          jj_la1[133] = jj_gen;
+          ;
+        }
+        break;
+        }
+      default:
+        jj_la1[134] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    jj_consume_token(RPAREN);
+    body = Statement();
+if (varExpr != null) {
+                return new ForeachStmt(range(begin, token()),varExpr, expr, body);
+        }
+        return new ForStmt(range(begin, token()),init, expr, update, body);
+}
+
+  final public NodeList<Expression> ForInit() throws ParseException {NodeList<Expression> ret;
+        Expression expr;
+    if (jj_2_46(2147483647)) {
+      expr = VariableDeclarationExpression();
+ret = new NodeList<Expression>(); ret.add(expr);
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:
+      case BANG:
+      case TILDE:
+      case INCR:
+      case DECR:
+      case PLUS:
+      case MINUS:{
+        ret = ExpressionList();
+        break;
+        }
+      default:
+        jj_la1[135] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return ret;
+}
+
+  final public NodeList<Expression> ExpressionList() throws ParseException {NodeList<Expression> ret = new NodeList<Expression>();
+        Expression expr;
+    expr = Expression();
+ret.add(expr);
+    label_45:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[136] = jj_gen;
+        break label_45;
+      }
+      jj_consume_token(COMMA);
+      expr = Expression();
+ret.add(expr);
+    }
+return ret;
+}
+
+  final public NodeList<Expression> ForUpdate() throws ParseException {NodeList<Expression> ret;
+    ret = ExpressionList();
+return ret;
+}
+
+  final public BreakStmt BreakStatement() throws ParseException {SimpleName label = null;
+        JavaToken begin;
+    jj_consume_token(BREAK);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ENUM:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:{
+      label = SimpleName();
+      break;
+      }
+    default:
+      jj_la1[137] = jj_gen;
+      ;
+    }
+    jj_consume_token(SEMICOLON);
+return new BreakStmt(range(begin, token()), label);
+}
+
+  final public ContinueStmt ContinueStatement() throws ParseException {SimpleName label = null;
+        JavaToken begin;
+    jj_consume_token(CONTINUE);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case ENUM:
+    case STRICTFP:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case IDENTIFIER:{
+      label = SimpleName();
+      break;
+      }
+    default:
+      jj_la1[138] = jj_gen;
+      ;
+    }
+    jj_consume_token(SEMICOLON);
+return new ContinueStmt(range(begin, token()), label);
+}
+
+  final public ReturnStmt ReturnStatement() throws ParseException {Expression expr = null;
+        JavaToken begin;
+    jj_consume_token(RETURN);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case AT:
+    case BANG:
+    case TILDE:
+    case INCR:
+    case DECR:
+    case PLUS:
+    case MINUS:{
+      expr = Expression();
+      break;
+      }
+    default:
+      jj_la1[139] = jj_gen;
+      ;
+    }
+    jj_consume_token(SEMICOLON);
+return new ReturnStmt(range(begin, token()),expr);
+}
+
+  final public ThrowStmt ThrowStatement() throws ParseException {Expression expr;
+        JavaToken begin;
+    jj_consume_token(THROW);
+begin=token();
+    expr = Expression();
+    jj_consume_token(SEMICOLON);
+return new ThrowStmt(range(begin, token()),expr);
+}
+
+  final public SynchronizedStmt SynchronizedStatement() throws ParseException {Expression expr;
+        BlockStmt body;
+        JavaToken begin;
+    jj_consume_token(SYNCHRONIZED);
+begin=token();
+    jj_consume_token(LPAREN);
+    expr = Expression();
+    jj_consume_token(RPAREN);
+    body = Block();
+return new SynchronizedStmt(range(begin, token()),expr, body);
+}
+
+  final public TryStmt TryStatement() throws ParseException {NodeList<Expression> resources = emptyList();
+        BlockStmt tryBlock;
+        BlockStmt finallyBlock = null;
+        NodeList<CatchClause> catchs = emptyList();
+        BlockStmt catchBlock;
+        ModifierHolder exceptModifier;
+        ReferenceType exceptionType;
+        NodeList<ReferenceType> exceptionTypes = emptyList();
+        Pair<SimpleName, List<ArrayBracketPair>> exceptId;
+        JavaToken begin;
+        JavaToken catchBegin;
+        JavaToken typesBegin;
+        JavaToken paramEnd;
+        Type type;
+    jj_consume_token(TRY);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case LPAREN:{
+      resources = ResourceSpecification();
+      break;
+      }
+    default:
+      jj_la1[140] = jj_gen;
+      ;
+    }
+    tryBlock = Block();
+    label_46:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case CATCH:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[141] = jj_gen;
+        break label_46;
+      }
+      jj_consume_token(CATCH);
+catchBegin=token();
+      jj_consume_token(LPAREN);
+typesBegin=token();
+      exceptModifier = Modifiers();
+      exceptionType = ReferenceType(emptyList());
+exceptionTypes.add(exceptionType);
+      label_47:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case BIT_OR:{
+          ;
+          break;
+          }
+        default:
+          jj_la1[142] = jj_gen;
+          break label_47;
+        }
+        jj_consume_token(BIT_OR);
+        exceptionType = AnnotatedReferenceType();
+exceptionTypes.add(exceptionType);
+      }
+      exceptId = VariableDeclaratorId();
+paramEnd = token();
+      jj_consume_token(RPAREN);
+      catchBlock = Block();
+if (exceptionTypes.size() > 1) {
+                                type = new UnionType(range(exceptionTypes.get(0), exceptionTypes.get(exceptionTypes.size() - 1)), exceptionTypes);
+                            } else {
+                                type = (Type)exceptionTypes.get(0);
+                            }
+                                Parameter catchType = new Parameter(range(type, paramEnd), exceptModifier.modifiers, exceptModifier.annotations, type, false, emptyList(), exceptId.a);
+                            catchs = add(catchs, new CatchClause(range(catchBegin, token()), catchType, catchBlock));
+                            exceptionTypes = emptyList();
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case FINALLY:{
+      jj_consume_token(FINALLY);
+      finallyBlock = Block();
+      break;
+      }
+    default:
+      jj_la1[143] = jj_gen;
+      ;
+    }
+return new TryStmt(range(begin, token()), resources, tryBlock, catchs, finallyBlock);
+}
+
+  final public NodeList<Expression> ResourceSpecification() throws ParseException {NodeList<Expression> variables;
+    jj_consume_token(LPAREN);
+    variables = Resources();
+    if (jj_2_47(2)) {
+      jj_consume_token(SEMICOLON);
+    } else {
+      ;
+    }
+    jj_consume_token(RPAREN);
+return variables;
+}
+
+  final public NodeList<Expression> Resources() throws ParseException {NodeList<Expression> expressions = new NodeList<Expression>();
+        Expression expr;
+    expr = Resource();
+expressions.add(expr);
+    label_48:
+    while (true) {
+      if (jj_2_48(2)) {
+        ;
+      } else {
+        break label_48;
+      }
+      jj_consume_token(SEMICOLON);
+      expr = Resource();
+expressions.add(expr);
+    }
+return expressions;
+}
+
+  final public Expression Resource() throws ParseException {Expression expr;
+    if (jj_2_49(2147483647)) {
+      /*this is a bit more lenient than we need to be, eg allowing access modifiers like private*/
+              expr = VariableDeclarationExpression();
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:{
+        expr = PrimaryExpression();
+        break;
+        }
+      default:
+        jj_la1[144] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return expr;
+}
+
+/* We use productions to match >>>, >> and > so that we can keep the
+ * type declaration syntax with generics clean
+ */
+  final public 
+void RUNSIGNEDSHIFT() throws ParseException {
+    if (getToken(1).kind == GT &&
+                    getToken(1).realKind == RUNSIGNEDSHIFT) {
+
+    } else {
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    jj_consume_token(GT);
+    jj_consume_token(GT);
+    jj_consume_token(GT);
+}
+
+  final public void RSIGNEDSHIFT() throws ParseException {
+    if (getToken(1).kind == GT &&
+                    getToken(1).realKind == RSIGNEDSHIFT) {
+
+    } else {
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+    jj_consume_token(GT);
+    jj_consume_token(GT);
+}
+
+/* Annotation syntax follows. */
+  final public 
+NodeList<AnnotationExpr> Annotations() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
+        AnnotationExpr annotation;
+    label_49:
+    while (true) {
+      if (jj_2_50(2147483647)) {
+        ;
+      } else {
+        break label_49;
+      }
+      annotation = Annotation();
+annotations = add(annotations, annotation);
+    }
+return annotations;
+}
+
+  final public AnnotationExpr Annotation() throws ParseException {AnnotationExpr ret;
+        Name name;
+        NodeList<MemberValuePair> pairs = emptyList();
+        JavaToken begin;
+        Expression memberVal;
+    jj_consume_token(AT);
+begin=token();
+    name = Name();
+    if (jj_2_51(2147483647)) {
+      jj_consume_token(LPAREN);
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ENUM:
+      case STRICTFP:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:{
+        pairs = MemberValuePairs();
+        break;
+        }
+      default:
+        jj_la1[145] = jj_gen;
+        ;
+      }
+      jj_consume_token(RPAREN);
+ret = new NormalAnnotationExpr(range(begin, token()), name, pairs);
+    } else if (jj_2_52(2147483647)) {
+      jj_consume_token(LPAREN);
+      memberVal = MemberValue();
+      jj_consume_token(RPAREN);
+ret = new SingleMemberAnnotationExpr(range(begin, token()), name, memberVal);
+    } else {
+ret = new MarkerAnnotationExpr(range(begin, token()), name);
+    }
+return ret;
+}
+
+  final public NodeList<MemberValuePair> MemberValuePairs() throws ParseException {NodeList<MemberValuePair> ret = new NodeList<MemberValuePair>();
+        MemberValuePair pair;
+    pair = MemberValuePair();
+ret.add(pair);
+    label_50:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case COMMA:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[146] = jj_gen;
+        break label_50;
+      }
+      jj_consume_token(COMMA);
+      pair = MemberValuePair();
+ret.add(pair);
+    }
+return ret;
+}
+
+  final public MemberValuePair MemberValuePair() throws ParseException {SimpleName name;
+        Expression value;
+        JavaToken begin;
+    name = SimpleName();
+begin=token();
+    jj_consume_token(ASSIGN);
+    value = MemberValue();
+return new MemberValuePair(range(begin, token()),name, value);
+}
+
+  final public Expression MemberValue() throws ParseException {Expression ret;
+    if (jj_2_53(2147483647)) {
+      ret = Annotation();
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case LBRACE:{
+        ret = MemberValueArrayInitializer();
+        break;
+        }
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:
+      case BANG:
+      case TILDE:
+      case INCR:
+      case DECR:
+      case PLUS:
+      case MINUS:{
+        ret = ConditionalExpression();
+        break;
+        }
+      default:
+        jj_la1[147] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return ret;
+}
+
+  final public Expression MemberValueArrayInitializer() throws ParseException {NodeList<Expression> ret = emptyList();
+        Expression member;
+        JavaToken begin;
+    jj_consume_token(LBRACE);
+begin=token();
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case BOOLEAN:
+    case BYTE:
+    case CHAR:
+    case DOUBLE:
+    case ENUM:
+    case FALSE:
+    case FLOAT:
+    case INT:
+    case LONG:
+    case NEW:
+    case NULL:
+    case SHORT:
+    case STRICTFP:
+    case SUPER:
+    case THIS:
+    case TRUE:
+    case VOID:
+    case REQUIRES:
+    case TO:
+    case WITH:
+    case OPEN:
+    case OPENS:
+    case USES:
+    case MODULE:
+    case EXPORTS:
+    case PROVIDES:
+    case TRANSITIVE:
+    case LONG_LITERAL:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case CHARACTER_LITERAL:
+    case STRING_LITERAL:
+    case IDENTIFIER:
+    case LPAREN:
+    case LBRACE:
+    case AT:
+    case BANG:
+    case TILDE:
+    case INCR:
+    case DECR:
+    case PLUS:
+    case MINUS:{
+      member = MemberValue();
+ret.add(member);
+      label_51:
+      while (true) {
+        if (jj_2_54(2)) {
+          ;
+        } else {
+          break label_51;
+        }
+        jj_consume_token(COMMA);
+        member = MemberValue();
+ret.add(member);
+      }
+      break;
+      }
+    default:
+      jj_la1[148] = jj_gen;
+      ;
+    }
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case COMMA:{
+      jj_consume_token(COMMA);
+      break;
+      }
+    default:
+      jj_la1[149] = jj_gen;
+      ;
+    }
+    jj_consume_token(RBRACE);
+return new ArrayInitializerExpr(range(begin, token()),ret);
+}
+
+/* Annotation Types. */
+  final public 
+AnnotationDeclaration AnnotationTypeDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name;
+    NodeList<BodyDeclaration<?>> members = emptyList();
+        JavaToken begin = modifier.begin;
+    jj_consume_token(AT);
+begin=orIfInvalid(begin, token());
+    jj_consume_token(INTERFACE);
+    name = SimpleName();
+    members = AnnotationTypeBody();
+return new AnnotationDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, members);
+}
+
+  final public NodeList<BodyDeclaration<?>> AnnotationTypeBody() throws ParseException {NodeList<BodyDeclaration<?>> ret = emptyList();
+        BodyDeclaration member;
+    jj_consume_token(LBRACE);
+    label_52:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ABSTRACT:
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case CLASS:
+      case _DEFAULT:
+      case DOUBLE:
+      case ENUM:
+      case FINAL:
+      case FLOAT:
+      case INT:
+      case INTERFACE:
+      case LONG:
+      case NATIVE:
+      case PRIVATE:
+      case PROTECTED:
+      case PUBLIC:
+      case SHORT:
+      case STATIC:
+      case STRICTFP:
+      case SYNCHRONIZED:
+      case TRANSIENT:
+      case VOLATILE:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:
+      case SEMICOLON:
+      case AT:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[150] = jj_gen;
+        break label_52;
+      }
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case ABSTRACT:
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case CLASS:
+      case _DEFAULT:
+      case DOUBLE:
+      case ENUM:
+      case FINAL:
+      case FLOAT:
+      case INT:
+      case INTERFACE:
+      case LONG:
+      case NATIVE:
+      case PRIVATE:
+      case PROTECTED:
+      case PUBLIC:
+      case SHORT:
+      case STATIC:
+      case STRICTFP:
+      case SYNCHRONIZED:
+      case TRANSIENT:
+      case VOLATILE:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case IDENTIFIER:
+      case AT:{
+        member = AnnotationBodyDeclaration();
+ret = addWhenNotNull(ret, member);
+        break;
+        }
+      case SEMICOLON:{
+        jj_consume_token(SEMICOLON);
+        break;
+        }
+      default:
+        jj_la1[151] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    jj_consume_token(RBRACE);
+return ret;
+}
+
+  final public BodyDeclaration<?> AnnotationBodyDeclaration() throws ParseException {ModifierHolder modifier;
+   BodyDeclaration ret;
+    modifier = Modifiers();
+    if (jj_2_55(2147483647)) {
+      ret = AnnotationTypeMemberDeclaration(modifier);
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case CLASS:
+      case INTERFACE:{
+        ret = ClassOrInterfaceDeclaration(modifier);
+        break;
+        }
+      default:
+        jj_la1[152] = jj_gen;
+        if (jj_2_56(2147483647)) {
+          ret = EnumDeclaration(modifier);
+        } else {
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case AT:{
+            ret = AnnotationTypeDeclaration(modifier);
+            break;
+            }
+          case BOOLEAN:
+          case BYTE:
+          case CHAR:
+          case DOUBLE:
+          case ENUM:
+          case FLOAT:
+          case INT:
+          case LONG:
+          case SHORT:
+          case STRICTFP:
+          case REQUIRES:
+          case TO:
+          case WITH:
+          case OPEN:
+          case OPENS:
+          case USES:
+          case MODULE:
+          case EXPORTS:
+          case PROVIDES:
+          case TRANSITIVE:
+          case IDENTIFIER:{
+            ret = FieldDeclaration(modifier);
+            break;
+            }
+          default:
+            jj_la1[153] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+      }
+    }
+return ret;
+}
+
+  final public AnnotationMemberDeclaration AnnotationTypeMemberDeclaration(ModifierHolder modifier) throws ParseException {Type type;
+        SimpleName name;
+        Expression defaultVal = null;
+    type = Type(emptyList());
+    name = SimpleName();
+    jj_consume_token(LPAREN);
+    jj_consume_token(RPAREN);
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case _DEFAULT:{
+      defaultVal = DefaultValue();
+      break;
+      }
+    default:
+      jj_la1[154] = jj_gen;
+      ;
+    }
+    jj_consume_token(SEMICOLON);
+JavaToken begin = orIfInvalid(modifier.begin, type);
+    return new AnnotationMemberDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, type, name, defaultVal);
+}
+
+  final public Expression DefaultValue() throws ParseException {Expression ret;
+    jj_consume_token(_DEFAULT);
+    ret = MemberValue();
+return ret;
+}
+
+/* Module syntax follows */
+  final public 
+
+ModuleStmt ModuleStmt() throws ParseException {ModifierHolder modifiers;
+    Name name;
+    Name tmpName;
+    NodeList<Name> names=emptyList();
+    Type type;
+    Type tmpType;
+    NodeList<Type> types=emptyList();
+    JavaToken begin;
+    ModuleStmt stmt=new ModuleRequiresStmt();
+    JavaToken transitiveExceptionalToken;
+    if (jj_2_57(2147483647)) {
+      jj_consume_token(REQUIRES);
+begin=token();
+      jj_consume_token(TRANSITIVE);
+transitiveExceptionalToken=token(); setTokenKind(IDENTIFIER);
+      jj_consume_token(SEMICOLON);
+stmt=new ModuleRequiresStmt(range(begin, token()), EnumSet.noneOf(Modifier.class), new Name(range(transitiveExceptionalToken, transitiveExceptionalToken), null, transitiveExceptionalToken.getText(), new NodeList<AnnotationExpr>()));
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case REQUIRES:{
+        jj_consume_token(REQUIRES);
+begin=token();
+        modifiers = Modifiers();
+        name = Name();
+        jj_consume_token(SEMICOLON);
+stmt=new ModuleRequiresStmt(range(begin, token()), modifiers.modifiers, name);
+        break;
+        }
+      case EXPORTS:{
+        jj_consume_token(EXPORTS);
+begin=token();
+        name = Name();
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case TO:{
+          jj_consume_token(TO);
+          tmpName = Name();
+names.add(tmpName);
+          label_53:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+            case COMMA:{
+              ;
+              break;
+              }
+            default:
+              jj_la1[155] = jj_gen;
+              break label_53;
+            }
+            jj_consume_token(COMMA);
+            tmpName = Name();
+names.add(tmpName);
+          }
+          break;
+          }
+        default:
+          jj_la1[156] = jj_gen;
+          ;
+        }
+        jj_consume_token(SEMICOLON);
+stmt=new ModuleExportsStmt(range(begin, token()), name, names);
+        break;
+        }
+      case OPENS:{
+        jj_consume_token(OPENS);
+begin=token();
+        name = Name();
+        switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+        case TO:{
+          jj_consume_token(TO);
+          tmpName = Name();
+names.add(tmpName);
+          label_54:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+            case COMMA:{
+              ;
+              break;
+              }
+            default:
+              jj_la1[157] = jj_gen;
+              break label_54;
+            }
+            jj_consume_token(COMMA);
+            tmpName = Name();
+names.add(tmpName);
+          }
+          break;
+          }
+        default:
+          jj_la1[158] = jj_gen;
+          ;
+        }
+        jj_consume_token(SEMICOLON);
+stmt=new ModuleOpensStmt(range(begin, token()), name, names);
+        break;
+        }
+      case USES:{
+        jj_consume_token(USES);
+begin=token();
+        type = Type(emptyList());
+        jj_consume_token(SEMICOLON);
+stmt=new ModuleUsesStmt(range(begin, token()), type);
+        break;
+        }
+      case PROVIDES:{
+        jj_consume_token(PROVIDES);
+begin=token();
+        type = Type(emptyList());
+        jj_consume_token(WITH);
+        tmpType = Type(emptyList());
+types.add(tmpType);
+        label_55:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+          case COMMA:{
+            ;
+            break;
+            }
+          default:
+            jj_la1[159] = jj_gen;
+            break label_55;
+          }
+          jj_consume_token(COMMA);
+          tmpType = Type(emptyList());
+types.add(tmpType);
+        }
+        jj_consume_token(SEMICOLON);
+stmt=new ModuleProvidesStmt(range(begin, token()), type, types);
+        break;
+        }
+      default:
+        jj_la1[160] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+return stmt;
+}
+
+  final public ModuleDeclaration ModuleDeclaration(ModifierHolder modifier) throws ParseException {NodeList<ModuleStmt> statements = new NodeList<ModuleStmt>();
+    boolean open=false;
+    ModuleStmt st;
+    Name name;
+    JavaToken begin = modifier.begin;
+    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+    case OPEN:{
+      jj_consume_token(OPEN);
+open=true; begin = orIfInvalid(begin, token());
+      break;
+      }
+    default:
+      jj_la1[161] = jj_gen;
+      ;
+    }
+    jj_consume_token(MODULE);
+begin = orIfInvalid(begin, token());
+    name = Name();
+    jj_consume_token(LBRACE);
+    label_56:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case REQUIRES:
+      case OPENS:
+      case USES:
+      case EXPORTS:
+      case PROVIDES:{
+        ;
+        break;
+        }
+      default:
+        jj_la1[162] = jj_gen;
+        break label_56;
+      }
+      st = ModuleStmt();
+statements = add(statements, st);
+    }
+    jj_consume_token(RBRACE);
+return new ModuleDeclaration(range(begin, token()), modifier.annotations, name, open, statements);
+}
+
+/* Rules for matching partial inputs.
+These rules are needed to properly terminate them -
+if we simply use the usual rules, they will ignore everything in the provider
+after they matched their desired input, which will lead to unexpected behaviour
+*/
+  final public 
+
+BlockStmt BlockParseStart() throws ParseException {BlockStmt ret;
+    ret = Block();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public Statement BlockStatementParseStart() throws ParseException {Statement ret;
+    if (jj_2_58(3)) {
+      ret = BlockStatement();
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case ENUM:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case STRICTFP:
+      case SUPER:
+      case THIS:
+      case TRUE:
+      case VOID:
+      case REQUIRES:
+      case TO:
+      case WITH:
+      case OPEN:
+      case OPENS:
+      case USES:
+      case MODULE:
+      case EXPORTS:
+      case PROVIDES:
+      case TRANSITIVE:
+      case LONG_LITERAL:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case AT:
+      case LT:{
+        ret = ExplicitConstructorInvocation();
+        break;
+        }
+      default:
+        jj_la1[163] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    jj_consume_token(0);
+return ret;
+}
+
+  final public ImportDeclaration ImportDeclarationParseStart() throws ParseException {ImportDeclaration ret;
+    ret = ImportDeclaration();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public Expression ExpressionParseStart() throws ParseException {Expression ret;
+    ret = Expression();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public AnnotationExpr AnnotationParseStart() throws ParseException {AnnotationExpr ret;
+    ret = Annotation();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public BodyDeclaration<?> AnnotationBodyDeclarationParseStart() throws ParseException {BodyDeclaration<?> ret;
+    ret = AnnotationBodyDeclaration();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public BodyDeclaration<?> ClassOrInterfaceBodyDeclarationParseStart() throws ParseException {BodyDeclaration<?> ret;
+    ret = ClassOrInterfaceBodyDeclaration();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public ClassOrInterfaceType ClassOrInterfaceTypeParseStart() throws ParseException {ClassOrInterfaceType ret;
+    ret = AnnotatedClassOrInterfaceType();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public Type ResultTypeParseStart() throws ParseException {NodeList<AnnotationExpr> annotations; Type ret;
+    annotations = Annotations();
+    ret = ResultType(annotations);
+    jj_consume_token(0);
+return ret;
+}
+
+  final public VariableDeclarationExpr VariableDeclarationExpressionParseStart() throws ParseException {VariableDeclarationExpr ret;
+    ret = VariableDeclarationExpression();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocationParseStart() throws ParseException {ExplicitConstructorInvocationStmt ret;
+    ret = ExplicitConstructorInvocation();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public Name NameParseStart() throws ParseException {Name ret;
+    ret = Name();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public SimpleName SimpleNameParseStart() throws ParseException {SimpleName ret;
+    ret = SimpleName();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public Parameter ParameterParseStart() throws ParseException {Parameter ret;
+    ret = Parameter();
+    jj_consume_token(0);
+return ret;
+}
+
+  final public PackageDeclaration PackageDeclarationParseStart() throws ParseException {PackageDeclaration ret;
+    ret = PackageDeclaration();
+    jj_consume_token(0);
+return ret;
+}
+
+  private boolean jj_2_1(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_1()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(0, xla); }
+  }
+
+  private boolean jj_2_2(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_2()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(1, xla); }
+  }
+
+  private boolean jj_2_3(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_3()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(2, xla); }
+  }
+
+  private boolean jj_2_4(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_4()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(3, xla); }
+  }
+
+  private boolean jj_2_5(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_5()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(4, xla); }
+  }
+
+  private boolean jj_2_6(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_6()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(5, xla); }
+  }
+
+  private boolean jj_2_7(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_7()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(6, xla); }
+  }
+
+  private boolean jj_2_8(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_8()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(7, xla); }
+  }
+
+  private boolean jj_2_9(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_9()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(8, xla); }
+  }
+
+  private boolean jj_2_10(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_10()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(9, xla); }
+  }
+
+  private boolean jj_2_11(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_11()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(10, xla); }
+  }
+
+  private boolean jj_2_12(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_12()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(11, xla); }
+  }
+
+  private boolean jj_2_13(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_13()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(12, xla); }
+  }
+
+  private boolean jj_2_14(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_14()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(13, xla); }
+  }
+
+  private boolean jj_2_15(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_15()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(14, xla); }
+  }
+
+  private boolean jj_2_16(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_16()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(15, xla); }
+  }
+
+  private boolean jj_2_17(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_17()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(16, xla); }
+  }
+
+  private boolean jj_2_18(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_18()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(17, xla); }
+  }
+
+  private boolean jj_2_19(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_19()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(18, xla); }
+  }
+
+  private boolean jj_2_20(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_20()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(19, xla); }
+  }
+
+  private boolean jj_2_21(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_21()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(20, xla); }
+  }
+
+  private boolean jj_2_22(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_22()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(21, xla); }
+  }
+
+  private boolean jj_2_23(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_23()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(22, xla); }
+  }
+
+  private boolean jj_2_24(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_24()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(23, xla); }
+  }
+
+  private boolean jj_2_25(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_25()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(24, xla); }
+  }
+
+  private boolean jj_2_26(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_26()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(25, xla); }
+  }
+
+  private boolean jj_2_27(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_27()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(26, xla); }
+  }
+
+  private boolean jj_2_28(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_28()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(27, xla); }
+  }
+
+  private boolean jj_2_29(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_29()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(28, xla); }
+  }
+
+  private boolean jj_2_30(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_30()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(29, xla); }
+  }
+
+  private boolean jj_2_31(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_31()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(30, xla); }
+  }
+
+  private boolean jj_2_32(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_32()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(31, xla); }
+  }
+
+  private boolean jj_2_33(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_33()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(32, xla); }
+  }
+
+  private boolean jj_2_34(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_34()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(33, xla); }
+  }
+
+  private boolean jj_2_35(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_35()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(34, xla); }
+  }
+
+  private boolean jj_2_36(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_36()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(35, xla); }
+  }
+
+  private boolean jj_2_37(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_37()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(36, xla); }
+  }
+
+  private boolean jj_2_38(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_38()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(37, xla); }
+  }
+
+  private boolean jj_2_39(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_39()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(38, xla); }
+  }
+
+  private boolean jj_2_40(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_40()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(39, xla); }
+  }
+
+  private boolean jj_2_41(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_41()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(40, xla); }
+  }
+
+  private boolean jj_2_42(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_42()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(41, xla); }
+  }
+
+  private boolean jj_2_43(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_43()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(42, xla); }
+  }
+
+  private boolean jj_2_44(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_44()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(43, xla); }
+  }
+
+  private boolean jj_2_45(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_45()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(44, xla); }
+  }
+
+  private boolean jj_2_46(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_46()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(45, xla); }
+  }
+
+  private boolean jj_2_47(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_47()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(46, xla); }
+  }
+
+  private boolean jj_2_48(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_48()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(47, xla); }
+  }
+
+  private boolean jj_2_49(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_49()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(48, xla); }
+  }
+
+  private boolean jj_2_50(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_50()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(49, xla); }
+  }
+
+  private boolean jj_2_51(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_51()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(50, xla); }
+  }
+
+  private boolean jj_2_52(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_52()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(51, xla); }
+  }
+
+  private boolean jj_2_53(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_53()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(52, xla); }
+  }
+
+  private boolean jj_2_54(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_54()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(53, xla); }
+  }
+
+  private boolean jj_2_55(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_55()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(54, xla); }
+  }
+
+  private boolean jj_2_56(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_56()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(55, xla); }
+  }
+
+  private boolean jj_2_57(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_57()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(56, xla); }
+  }
+
+  private boolean jj_2_58(int xla)
+ {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return (!jj_3_58()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(57, xla); }
+  }
+
+  private boolean jj_3R_304()
+ {
+    if (jj_scan_token(EXTENDS)) return true;
+    if (jj_3R_306()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_408()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_296()
+ {
+    if (jj_3R_324()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_364()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_227()
+ {
+    if (jj_scan_token(INTERFACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_262()
+ {
+    if (jj_3R_305()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_286()
+ {
+    if (jj_scan_token(DO)) return true;
+    if (jj_3R_195()) return true;
+    if (jj_scan_token(WHILE)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_261()
+ {
+    if (jj_3R_304()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_260()
+ {
+    if (jj_3R_117()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_248()
+ {
+    if (jj_3R_296()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_348()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_194()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(19)) {
+    jj_scanpos = xsp;
+    if (jj_3R_227()) return true;
+    }
+    if (jj_3R_88()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_260()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_261()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_262()) jj_scanpos = xsp;
+    if (jj_3R_105()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_169()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_112()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_285()
+ {
+    if (jj_scan_token(WHILE)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_195()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_328()
+ {
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_200()
+ {
+    if (jj_3R_248()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_325()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_300()
+ {
+    if (jj_scan_token(HOOK)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_149()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_149()
+ {
+    if (jj_3R_200()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_300()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_284()
+ {
+    if (jj_scan_token(IF)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_195()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_411()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_71()
+ {
+    if (jj_3R_115()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_70()
+ {
+    if (jj_scan_token(_DEFAULT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_69()
+ {
+    if (jj_scan_token(TRANSITIVE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_148()
+ {
+    if (jj_scan_token(ORASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_147()
+ {
+    if (jj_scan_token(XORASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_68()
+ {
+    if (jj_scan_token(STRICTFP)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_146()
+ {
+    if (jj_scan_token(ANDASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_145()
+ {
+    if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_431()
+ {
+    if (jj_scan_token(_DEFAULT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_67()
+ {
+    if (jj_scan_token(VOLATILE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_144()
+ {
+    if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_143()
+ {
+    if (jj_scan_token(LSHIFTASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_430()
+ {
+    if (jj_scan_token(CASE)) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_66()
+ {
+    if (jj_scan_token(TRANSIENT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_142()
+ {
+    if (jj_scan_token(MINUSASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_141()
+ {
+    if (jj_scan_token(PLUSASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_65()
+ {
+    if (jj_scan_token(NATIVE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_140()
+ {
+    if (jj_scan_token(REMASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_139()
+ {
+    if (jj_scan_token(SLASHASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_64()
+ {
+    if (jj_scan_token(SYNCHRONIZED)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_138()
+ {
+    if (jj_scan_token(STARASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_327()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_137()
+ {
+    if (jj_scan_token(ASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_63()
+ {
+    if (jj_scan_token(ABSTRACT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_62()
+ {
+    if (jj_scan_token(FINAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_424()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_430()) {
+    jj_scanpos = xsp;
+    if (jj_3R_431()) return true;
+    }
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_179()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_61()
+ {
+    if (jj_scan_token(PRIVATE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_89()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_137()) {
+    jj_scanpos = xsp;
+    if (jj_3R_138()) {
+    jj_scanpos = xsp;
+    if (jj_3R_139()) {
+    jj_scanpos = xsp;
+    if (jj_3R_140()) {
+    jj_scanpos = xsp;
+    if (jj_3R_141()) {
+    jj_scanpos = xsp;
+    if (jj_3R_142()) {
+    jj_scanpos = xsp;
+    if (jj_3R_143()) {
+    jj_scanpos = xsp;
+    if (jj_3R_144()) {
+    jj_scanpos = xsp;
+    if (jj_3R_145()) {
+    jj_scanpos = xsp;
+    if (jj_3R_146()) {
+    jj_scanpos = xsp;
+    if (jj_3R_147()) {
+    jj_scanpos = xsp;
+    if (jj_3R_148()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_302()
+ {
+    if (jj_scan_token(DOUBLECOLON)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_327()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_328()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(42)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_60()
+ {
+    if (jj_scan_token(PROTECTED)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_59()
+ {
+    if (jj_scan_token(STATIC)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_58()
+ {
+    if (jj_scan_token(PUBLIC)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_410()
+ {
+    if (jj_3R_424()) return true;
+    return false;
+  }
+
+  private boolean jj_3_3()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_58()) {
+    jj_scanpos = xsp;
+    if (jj_3R_59()) {
+    jj_scanpos = xsp;
+    if (jj_3R_60()) {
+    jj_scanpos = xsp;
+    if (jj_3R_61()) {
+    jj_scanpos = xsp;
+    if (jj_3R_62()) {
+    jj_scanpos = xsp;
+    if (jj_3R_63()) {
+    jj_scanpos = xsp;
+    if (jj_3R_64()) {
+    jj_scanpos = xsp;
+    if (jj_3R_65()) {
+    jj_scanpos = xsp;
+    if (jj_3R_66()) {
+    jj_scanpos = xsp;
+    if (jj_3R_67()) {
+    jj_scanpos = xsp;
+    if (jj_3R_68()) {
+    jj_scanpos = xsp;
+    if (jj_3R_69()) {
+    jj_scanpos = xsp;
+    if (jj_3R_70()) {
+    jj_scanpos = xsp;
+    if (jj_3R_71()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_108()
+ {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_3()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_283()
+ {
+    if (jj_scan_token(SWITCH)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_410()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_301()
+ {
+    if (jj_scan_token(ARROW)) return true;
+    if (jj_3R_326()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_361()
+ {
+    if (jj_3R_89()) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_360()
+ {
+    if (jj_scan_token(DECR)) return true;
+    return false;
+  }
+
+  private boolean jj_3_24()
+ {
+    if (jj_3R_89()) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_359()
+ {
+    if (jj_scan_token(INCR)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_343()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_359()) {
+    jj_scanpos = xsp;
+    if (jj_3R_360()) {
+    jj_scanpos = xsp;
+    if (jj_3R_361()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_255()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_24()) {
+    jj_scanpos = xsp;
+    if (jj_3R_301()) {
+    jj_scanpos = xsp;
+    if (jj_3R_302()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_318()
+ {
+    if (jj_3R_211()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_343()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_90()
+ {
+    if (jj_3R_149()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_255()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_317()
+ {
+    if (jj_3R_257()) return true;
+    return false;
+  }
+
+  private boolean jj_3_44()
+ {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_282()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_44()) {
+    jj_scanpos = xsp;
+    if (jj_3R_317()) {
+    jj_scanpos = xsp;
+    if (jj_3R_318()) return true;
+    }
+    }
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_57()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(PACKAGE)) return true;
+    if (jj_3R_80()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_350()
+ {
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_349()
+ {
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_74()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(70)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(64)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(65)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(66)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(67)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(68)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(69)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(71)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(72)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(73)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(26)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(51)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(89)) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_326()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_349()) {
+    jj_scanpos = xsp;
+    if (jj_3R_350()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3_2()
+ {
+    if (jj_3R_57()) return true;
+    return false;
+  }
+
+  private boolean jj_3_23()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_281()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_88()
+ {
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3_1()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_125()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_109()
+ {
+    if (jj_3R_108()) return true;
+    if (jj_3R_75()) return true;
+    if (jj_3R_112()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_169()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_80()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_3R_74()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_125()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3_43()
+ {
+    if (jj_3R_109()) return true;
+    return false;
+  }
+
+  private boolean jj_3_42()
+ {
+    if (jj_3R_108()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(19)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(39)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_132()
+ {
+    if (jj_3R_195()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_167()
+ {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_166()
+ {
+    if (jj_scan_token(VOID)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_131()
+ {
+    if (jj_3R_109()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_130()
+ {
+    if (jj_3R_108()) return true;
+    if (jj_3R_194()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_102()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_166()) {
+    jj_scanpos = xsp;
+    if (jj_3R_167()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_336()
+ {
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_84()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_130()) {
+    jj_scanpos = xsp;
+    if (jj_3R_131()) {
+    jj_scanpos = xsp;
+    if (jj_3R_132()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_160()
+ {
+    if (jj_scan_token(DOUBLE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_159()
+ {
+    if (jj_scan_token(FLOAT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_158()
+ {
+    if (jj_scan_token(LONG)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_157()
+ {
+    if (jj_scan_token(INT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_156()
+ {
+    if (jj_scan_token(SHORT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_155()
+ {
+    if (jj_scan_token(BYTE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_154()
+ {
+    if (jj_scan_token(CHAR)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_358()
+ {
+    if (jj_scan_token(SUPER)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_85()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_226()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_199()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_153()
+ {
+    if (jj_scan_token(BOOLEAN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_357()
+ {
+    if (jj_scan_token(EXTENDS)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_85()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_342()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_357()) {
+    jj_scanpos = xsp;
+    if (jj_3R_358()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_97()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_153()) {
+    jj_scanpos = xsp;
+    if (jj_3R_154()) {
+    jj_scanpos = xsp;
+    if (jj_3R_155()) {
+    jj_scanpos = xsp;
+    if (jj_3R_156()) {
+    jj_scanpos = xsp;
+    if (jj_3R_157()) {
+    jj_scanpos = xsp;
+    if (jj_3R_158()) {
+    jj_scanpos = xsp;
+    if (jj_3R_159()) {
+    jj_scanpos = xsp;
+    if (jj_3R_160()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_121()
+ {
+    if (jj_scan_token(LBRACE)) return true;
+    if (jj_3R_179()) return true;
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_295()
+ {
+    if (jj_scan_token(HOOK)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_342()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_107()
+ {
+    if (jj_3R_88()) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_195()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_280()
+ {
+    if (jj_scan_token(ASSERT)) return true;
+    if (jj_3R_90()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_336()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_247()
+ {
+    if (jj_3R_295()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_246()
+ {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_242()
+ {
+    if (jj_3R_293()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_199()
+ {
+    if (jj_3R_86()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_246()) {
+    jj_scanpos = xsp;
+    if (jj_3R_247()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_241()
+ {
+    if (jj_3R_292()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_240()
+ {
+    if (jj_3R_291()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_239()
+ {
+    if (jj_3R_290()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_238()
+ {
+    if (jj_3R_289()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_136()
+ {
+    if (jj_3R_199()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_226()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_237()
+ {
+    if (jj_3R_288()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_236()
+ {
+    if (jj_3R_287()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_87()
+ {
+    if (jj_scan_token(LT)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_136()) jj_scanpos = xsp;
+    if (jj_scan_token(GT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_235()
+ {
+    if (jj_3R_286()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_234()
+ {
+    if (jj_3R_285()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_233()
+ {
+    if (jj_3R_284()) return true;
+    return false;
+  }
+
+  private boolean jj_3_22()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_232()
+ {
+    if (jj_3R_283()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_231()
+ {
+    if (jj_3R_282()) return true;
+    return false;
+  }
+
+  private boolean jj_3_21()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_88()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_22()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_230()
+ {
+    if (jj_3R_281()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_229()
+ {
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_393()
+ {
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_249()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_403()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_228()
+ {
+    if (jj_3R_280()) return true;
+    return false;
+  }
+
+  private boolean jj_3_19()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3_41()
+ {
+    if (jj_3R_107()) return true;
+    return false;
+  }
+
+  private boolean jj_3_20()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_197()
+ {
+    if (jj_3R_88()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_20()) jj_scanpos = xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_21()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_195()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_41()) {
+    jj_scanpos = xsp;
+    if (jj_3R_228()) {
+    jj_scanpos = xsp;
+    if (jj_3R_229()) {
+    jj_scanpos = xsp;
+    if (jj_3R_230()) {
+    jj_scanpos = xsp;
+    if (jj_3R_231()) {
+    jj_scanpos = xsp;
+    if (jj_3R_232()) {
+    jj_scanpos = xsp;
+    if (jj_3R_233()) {
+    jj_scanpos = xsp;
+    if (jj_3R_234()) {
+    jj_scanpos = xsp;
+    if (jj_3R_235()) {
+    jj_scanpos = xsp;
+    if (jj_3R_236()) {
+    jj_scanpos = xsp;
+    if (jj_3R_237()) {
+    jj_scanpos = xsp;
+    if (jj_3R_238()) {
+    jj_scanpos = xsp;
+    if (jj_3R_239()) {
+    jj_scanpos = xsp;
+    if (jj_3R_240()) {
+    jj_scanpos = xsp;
+    if (jj_3R_241()) {
+    jj_scanpos = xsp;
+    if (jj_3R_242()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3_18()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_198()
+ {
+    if (jj_3R_119()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_306()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_3R_197()) return true;
+    return false;
+  }
+
+  private boolean jj_3_39()
+ {
+    if (jj_3R_105()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_196()
+ {
+    if (jj_3R_119()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_106()
+ {
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_341()
+ {
+    if (jj_3R_180()) return true;
+    return false;
+  }
+
+  private boolean jj_3_40()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_106()) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_313()
+ {
+    Token xsp;
+    if (jj_3_40()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_40()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_341()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_308()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_316()
+ {
+    if (jj_3R_183()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_39()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_315()
+ {
+    if (jj_3R_313()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_119()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_314()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_279()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_314()) jj_scanpos = xsp;
+    if (jj_3R_306()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_315()) {
+    jj_scanpos = xsp;
+    if (jj_3R_316()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_278()
+ {
+    if (jj_3R_97()) return true;
+    if (jj_3R_313()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_134()
+ {
+    if (jj_3R_197()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_198()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_133()
+ {
+    if (jj_3R_97()) return true;
+    Token xsp;
+    if (jj_3R_196()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_196()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_85()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_133()) {
+    jj_scanpos = xsp;
+    if (jj_3R_134()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_222()
+ {
+    if (jj_scan_token(NEW)) return true;
+    if (jj_3R_86()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_278()) {
+    jj_scanpos = xsp;
+    if (jj_3R_279()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_118()
+ {
+    if (jj_3R_97()) return true;
+    return false;
+  }
+
+  private boolean jj_3_17()
+ {
+    if (jj_3R_85()) return true;
+    return false;
+  }
+
+  private boolean jj_3_58()
+ {
+    if (jj_3R_84()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_75()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_17()) {
+    jj_scanpos = xsp;
+    if (jj_3R_118()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_264()
+ {
+    if (jj_3R_90()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_308()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_214()
+ {
+    if (jj_3R_264()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_120()
+ {
+    if (jj_scan_token(STATIC)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_183()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_214()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_77()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_120()) jj_scanpos = xsp;
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3_16()
+ {
+    if (jj_3R_84()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_179()
+ {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_16()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3_14()
+ {
+    if (jj_3R_82()) return true;
+    if (jj_scan_token(DOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_340()
+ {
+    if (jj_scan_token(FALSE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_310()
+ {
+    if (jj_scan_token(NULL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_339()
+ {
+    if (jj_scan_token(TRUE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_441()
+ {
+    if (jj_3R_442()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_83()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_185()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3_57()
+ {
+    if (jj_scan_token(REQUIRES)) return true;
+    if (jj_scan_token(TRANSITIVE)) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3_15()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_83()) jj_scanpos = xsp;
+    if (jj_scan_token(THIS)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_184()
+ {
+    if (jj_3R_82()) return true;
+    if (jj_scan_token(DOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_309()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_339()) {
+    jj_scanpos = xsp;
+    if (jj_3R_340()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_127()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_184()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_185()) jj_scanpos = xsp;
+    if (jj_scan_token(SUPER)) return true;
+    if (jj_3R_183()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_271()
+ {
+    if (jj_3R_310()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_182()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_270()
+ {
+    if (jj_3R_309()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_126()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_182()) jj_scanpos = xsp;
+    if (jj_scan_token(THIS)) return true;
+    if (jj_3R_183()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_269()
+ {
+    if (jj_scan_token(STRING_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_268()
+ {
+    if (jj_scan_token(CHARACTER_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_81()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_126()) {
+    jj_scanpos = xsp;
+    if (jj_3R_127()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_267()
+ {
+    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_266()
+ {
+    if (jj_scan_token(LONG_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3_13()
+ {
+    if (jj_3R_81()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_265()
+ {
+    if (jj_scan_token(INTEGER_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_104()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_164()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(ELLIPSIS)) return true;
+    return false;
+  }
+
+  private boolean jj_3_38()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_104()) jj_scanpos = xsp;
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_394()
+ {
+    if (jj_3R_81()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_215()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_265()) {
+    jj_scanpos = xsp;
+    if (jj_3R_266()) {
+    jj_scanpos = xsp;
+    if (jj_3R_267()) {
+    jj_scanpos = xsp;
+    if (jj_3R_268()) {
+    jj_scanpos = xsp;
+    if (jj_3R_269()) {
+    jj_scanpos = xsp;
+    if (jj_3R_270()) {
+    jj_scanpos = xsp;
+    if (jj_3R_271()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_442()
+ {
+    if (jj_scan_token(_DEFAULT)) return true;
+    if (jj_3R_114()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_163()
+ {
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_254()
+ {
+    if (jj_3R_183()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_403()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_249()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_224()
+ {
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_253()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_365()
+ {
+    if (jj_3R_117()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_353()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_365()) jj_scanpos = xsp;
+    if (jj_3R_88()) return true;
+    if (jj_3R_392()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_393()) jj_scanpos = xsp;
+    if (jj_scan_token(LBRACE)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_394()) jj_scanpos = xsp;
+    if (jj_3R_179()) return true;
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_205()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_253()) jj_scanpos = xsp;
+    if (jj_3R_88()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_254()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_204()
+ {
+    if (jj_3R_222()) return true;
+    return false;
+  }
+
+  private boolean jj_3_12()
+ {
+    if (jj_3R_80()) return true;
+    return false;
+  }
+
+  private boolean jj_3_56()
+ {
+    if (jj_scan_token(ENUM)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_203()
+ {
+    if (jj_scan_token(THIS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_439()
+ {
+    if (jj_3R_75()) return true;
+    if (jj_3R_88()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_441()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3_55()
+ {
+    if (jj_3R_75()) return true;
+    if (jj_3R_74()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_438()
+ {
+    if (jj_3R_354()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_437()
+ {
+    if (jj_3R_352()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_436()
+ {
+    if (jj_3R_351()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_181()
+ {
+    if (jj_3R_80()) return true;
+    if (jj_scan_token(DOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_162()
+ {
+    if (jj_scan_token(DOT)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_203()) {
+    jj_scanpos = xsp;
+    if (jj_3R_204()) {
+    jj_scanpos = xsp;
+    if (jj_3R_205()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_435()
+ {
+    if (jj_3R_194()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_124()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_181()) jj_scanpos = xsp;
+    if (jj_3R_86()) return true;
+    if (jj_scan_token(THIS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_434()
+ {
+    if (jj_3R_439()) return true;
+    return false;
+  }
+
+  private boolean jj_3_54()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_114()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_99()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_162()) {
+    jj_scanpos = xsp;
+    if (jj_3R_163()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_311()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_100()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_223()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_79()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_3R_75()) return true;
+    if (jj_3R_124()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_161()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(SUPER)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_429()
+ {
+    if (jj_3R_108()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_434()) {
+    jj_scanpos = xsp;
+    if (jj_3R_435()) {
+    jj_scanpos = xsp;
+    if (jj_3R_436()) {
+    jj_scanpos = xsp;
+    if (jj_3R_437()) {
+    jj_scanpos = xsp;
+    if (jj_3R_438()) return true;
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3_37()
+ {
+    if (jj_3R_99()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_417()
+ {
+    if (jj_3R_429()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_401()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_417()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(98)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_275()
+ {
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_98()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_37()) {
+    jj_scanpos = xsp;
+    if (jj_3R_161()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_225()
+ {
+    if (jj_3R_183()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_391()
+ {
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_401()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_193()
+ {
+    if (jj_3R_88()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_225()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_100()
+ {
+    if (jj_3R_108()) return true;
+    if (jj_3R_75()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_164()) jj_scanpos = xsp;
+    if (jj_3R_101()) return true;
+    return false;
+  }
+
+  private boolean jj_3_36()
+ {
+    if (jj_3R_103()) return true;
+    if (jj_scan_token(DOUBLECOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3_35()
+ {
+    if (jj_3R_102()) return true;
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(CLASS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_312()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_101()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_352()
+ {
+    if (jj_scan_token(AT)) return true;
+    if (jj_scan_token(INTERFACE)) return true;
+    if (jj_3R_88()) return true;
+    if (jj_3R_391()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_192()
+ {
+    if (jj_3R_103()) return true;
+    if (jj_scan_token(DOUBLECOLON)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_223()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_224()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(42)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3_34()
+ {
+    if (jj_3R_101()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_277()
+ {
+    if (jj_3R_101()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_312()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_191()
+ {
+    if (jj_3R_102()) return true;
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(CLASS)) return true;
+    return false;
+  }
+
+  private boolean jj_3_33()
+ {
+    if (jj_3R_100()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_190()
+ {
+    if (jj_3R_222()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_346()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_345()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_221()
+ {
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_362()
+ {
+    if (jj_3R_114()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_54()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_274()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3_10()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_78()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_220()
+ {
+    if (jj_3R_277()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_276()
+ {
+    if (jj_3R_100()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_311()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_218()
+ {
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3_11()
+ {
+    if (jj_3R_79()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_219()
+ {
+    if (jj_3R_276()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_212()
+ {
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_362()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(99)) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_217()
+ {
+    if (jj_scan_token(DOUBLECOLON)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_274()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_275()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(42)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_420()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_100()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_419()
+ {
+    if (jj_3R_100()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_189()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_218()) {
+    jj_scanpos = xsp;
+    if (jj_3R_219()) {
+    jj_scanpos = xsp;
+    if (jj_3R_220()) {
+    jj_scanpos = xsp;
+    if (jj_3R_221()) return true;
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_176()
+ {
+    if (jj_3R_149()) return true;
+    return false;
+  }
+
+  private boolean jj_3_53()
+ {
+    if (jj_scan_token(AT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_175()
+ {
+    if (jj_3R_212()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_396()
+ {
+    if (jj_3R_119()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_418()
+ {
+    if (jj_3R_79()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_402()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_418()) {
+    jj_scanpos = xsp;
+    if (jj_3R_419()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_420()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_273()
+ {
+    if (jj_3R_183()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_174()
+ {
+    if (jj_3R_115()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_392()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_402()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_216()
+ {
+    if (jj_scan_token(DOT)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_272()) jj_scanpos = xsp;
+    if (jj_3R_88()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_273()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_272()
+ {
+    if (jj_3R_87()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_114()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_174()) {
+    jj_scanpos = xsp;
+    if (jj_3R_175()) {
+    jj_scanpos = xsp;
+    if (jj_3R_176()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3_32()
+ {
+    if (jj_3R_99()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_188()
+ {
+    if (jj_scan_token(SUPER)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_216()) {
+    jj_scanpos = xsp;
+    if (jj_3R_217()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_187()
+ {
+    if (jj_scan_token(THIS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_345()
+ {
+    if (jj_3R_88()) return true;
+    if (jj_scan_token(ASSIGN)) return true;
+    if (jj_3R_114()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_186()
+ {
+    if (jj_3R_215()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_103()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_129()
+ {
+    if (jj_3R_99()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_113()
+ {
+    if (jj_3R_74()) return true;
+    if (jj_scan_token(ASSIGN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_128()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_186()) {
+    jj_scanpos = xsp;
+    if (jj_3R_187()) {
+    jj_scanpos = xsp;
+    if (jj_3R_188()) {
+    jj_scanpos = xsp;
+    if (jj_3R_189()) {
+    jj_scanpos = xsp;
+    if (jj_3R_190()) {
+    jj_scanpos = xsp;
+    if (jj_3R_191()) {
+    jj_scanpos = xsp;
+    if (jj_3R_192()) {
+    jj_scanpos = xsp;
+    if (jj_3R_193()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3_52()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_323()
+ {
+    if (jj_3R_345()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_346()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3_31()
+ {
+    if (jj_3R_98()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_249()
+ {
+    if (jj_3R_86()) return true;
+    if (jj_3R_85()) return true;
+    return false;
+  }
+
+  private boolean jj_3_51()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_113()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(93)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_245()
+ {
+    return false;
+  }
+
+  private boolean jj_3R_294()
+ {
+    if (jj_3R_323()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_244()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_114()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_404()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_249()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_398()
+ {
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_243()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_294()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_397()
+ {
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_249()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_404()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_82()
+ {
+    if (jj_3R_128()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_129()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_366()
+ {
+    if (jj_3R_117()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_115()
+ {
+    if (jj_scan_token(AT)) return true;
+    if (jj_3R_80()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_243()) {
+    jj_scanpos = xsp;
+    if (jj_3R_244()) {
+    jj_scanpos = xsp;
+    if (jj_3R_245()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_335()
+ {
+    if (jj_3R_78()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_10()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_355()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_366()) jj_scanpos = xsp;
+    if (jj_3R_86()) return true;
+    if (jj_3R_102()) return true;
+    if (jj_3R_88()) return true;
+    if (jj_3R_392()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_396()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_397()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_398()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(98)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3_50()
+ {
+    if (jj_scan_token(AT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_211()
+ {
+    if (jj_3R_128()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_31()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_165()
+ {
+    if (jj_3R_119()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_135()
+ {
+    if (jj_3R_115()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_86()
+ {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_135()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_150()
+ {
+    return false;
+  }
+
+  private boolean jj_3R_201()
+ {
+    if (jj_scan_token(BIT_AND)) return true;
+    if (jj_3R_249()) return true;
+    return false;
+  }
+
+  private boolean jj_3_48()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    if (jj_3R_111()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_152()
+ {
+    if (jj_3R_85()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_201()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_202()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_180()
+ {
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_335()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(99)) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_30()
+ {
+    if (jj_3R_97()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_170()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_151()
+ {
+    return false;
+  }
+
+  private boolean jj_3R_123()
+ {
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_92()
+ {
+    jj_lookingAhead = true;
+    jj_semLA = getToken(1).kind == GT &&
+                getToken(1).realKind == RSIGNEDSHIFT;
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_150()) return true;
+    if (jj_scan_token(GT)) return true;
+    if (jj_scan_token(GT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_122()
+ {
+    if (jj_3R_180()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_173()
+ {
+    if (jj_scan_token(ASSIGN)) return true;
+    if (jj_3R_78()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_94()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_86()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_30()) {
+    jj_scanpos = xsp;
+    if (jj_3R_152()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_93()
+ {
+    jj_lookingAhead = true;
+    jj_semLA = getToken(1).kind == GT &&
+                getToken(1).realKind == RUNSIGNEDSHIFT;
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_151()) return true;
+    if (jj_scan_token(GT)) return true;
+    if (jj_scan_token(GT)) return true;
+    if (jj_scan_token(GT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_78()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_122()) {
+    jj_scanpos = xsp;
+    if (jj_3R_123()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3_49()
+ {
+    if (jj_3R_108()) return true;
+    if (jj_3R_75()) return true;
+    if (jj_3R_112()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_172()
+ {
+    if (jj_3R_211()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_96()
+ {
+    if (jj_scan_token(DECR)) return true;
+    return false;
+  }
+
+  private boolean jj_3_29()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_95()) {
+    jj_scanpos = xsp;
+    if (jj_3R_96()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_95()
+ {
+    if (jj_scan_token(INCR)) return true;
+    return false;
+  }
+
+  private boolean jj_3_28()
+ {
+    if (jj_3R_94()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_101()
+ {
+    if (jj_3R_88()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_165()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_76()
+ {
+    if (jj_3R_119()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_171()
+ {
+    if (jj_3R_109()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_111()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_171()) {
+    jj_scanpos = xsp;
+    if (jj_3R_172()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_299()
+ {
+    if (jj_3R_211()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_29()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_251()
+ {
+    if (jj_3R_94()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_368()
+ {
+    if (jj_3R_111()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_48()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_298()
+ {
+    if (jj_scan_token(BANG)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_252()
+ {
+    if (jj_3R_299()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_297()
+ {
+    if (jj_scan_token(TILDE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_112()
+ {
+    if (jj_3R_101()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_173()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_250()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_297()) {
+    jj_scanpos = xsp;
+    if (jj_3R_298()) return true;
+    }
+    if (jj_3R_170()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_395()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_112()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_73()
+ {
+    if (jj_3R_117()) return true;
+    return false;
+  }
+
+  private boolean jj_3_8()
+ {
+    if (jj_3R_75()) return true;
+    if (jj_3R_74()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_76()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_scan_token(99)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(102)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(98)) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_202()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_250()) {
+    jj_scanpos = xsp;
+    if (jj_3R_251()) {
+    jj_scanpos = xsp;
+    if (jj_3R_252()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_428()
+ {
+    if (jj_scan_token(FINALLY)) return true;
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_413()
+ {
+    if (jj_scan_token(FINALLY)) return true;
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3_7()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_73()) jj_scanpos = xsp;
+    if (jj_3R_74()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3_47()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_354()
+ {
+    if (jj_3R_75()) return true;
+    if (jj_3R_112()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_395()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_344()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_368()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_47()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3_6()
+ {
+    if (jj_scan_token(AT)) return true;
+    if (jj_scan_token(INTERFACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_5()
+ {
+    if (jj_scan_token(ENUM)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_334()
+ {
+    if (jj_3R_355()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_433()
+ {
+    if (jj_scan_token(BIT_OR)) return true;
+    if (jj_3R_249()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_333()
+ {
+    if (jj_3R_354()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_257()
+ {
+    if (jj_scan_token(DECR)) return true;
+    if (jj_3R_170()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_332()
+ {
+    if (jj_3R_353()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_427()
+ {
+    if (jj_scan_token(CATCH)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_108()) return true;
+    if (jj_3R_85()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_433()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_3R_101()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_331()
+ {
+    if (jj_3R_352()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_330()
+ {
+    if (jj_3R_351()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_329()
+ {
+    if (jj_3R_194()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_110()
+ {
+    if (jj_scan_token(INCR)) return true;
+    if (jj_3R_170()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_303()
+ {
+    if (jj_3R_108()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_329()) {
+    jj_scanpos = xsp;
+    if (jj_3R_330()) {
+    jj_scanpos = xsp;
+    if (jj_3R_331()) {
+    jj_scanpos = xsp;
+    if (jj_3R_332()) {
+    jj_scanpos = xsp;
+    if (jj_3R_333()) {
+    jj_scanpos = xsp;
+    if (jj_3R_334()) return true;
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_210()
+ {
+    if (jj_3R_202()) return true;
+    return false;
+  }
+
+  private boolean jj_3_9()
+ {
+    if (jj_3R_77()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_259()
+ {
+    if (jj_scan_token(MINUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_258()
+ {
+    if (jj_scan_token(PLUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_213()
+ {
+    if (jj_3R_263()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_412()
+ {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_427()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_428()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_209()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_258()) {
+    jj_scanpos = xsp;
+    if (jj_3R_259()) return true;
+    }
+    if (jj_3R_170()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_208()
+ {
+    if (jj_3R_257()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_207()
+ {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_256()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_9()) {
+    jj_scanpos = xsp;
+    if (jj_3R_303()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_322()
+ {
+    if (jj_3R_344()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_293()
+ {
+    if (jj_scan_token(TRY)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_322()) jj_scanpos = xsp;
+    if (jj_3R_121()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_412()) {
+    jj_scanpos = xsp;
+    if (jj_3R_413()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_168()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_206()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(98)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_206()
+ {
+    if (jj_3R_256()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_170()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_207()) {
+    jj_scanpos = xsp;
+    if (jj_3R_208()) {
+    jj_scanpos = xsp;
+    if (jj_3R_209()) {
+    jj_scanpos = xsp;
+    if (jj_3R_210()) return true;
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_423()
+ {
+    if (jj_scan_token(REM)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_105()
+ {
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_168()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_422()
+ {
+    if (jj_scan_token(SLASH)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_421()
+ {
+    if (jj_scan_token(STAR)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_405()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_421()) {
+    jj_scanpos = xsp;
+    if (jj_3R_422()) {
+    jj_scanpos = xsp;
+    if (jj_3R_423()) return true;
+    }
+    }
+    if (jj_3R_170()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_321()
+ {
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_307()
+ {
+    if (jj_scan_token(BIT_AND)) return true;
+    if (jj_3R_306()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_382()
+ {
+    if (jj_3R_170()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_405()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_263()
+ {
+    if (jj_scan_token(EXTENDS)) return true;
+    if (jj_3R_306()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_307()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_292()
+ {
+    if (jj_scan_token(SYNCHRONIZED)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_121()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_320()
+ {
+    if (jj_3R_88()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_407()
+ {
+    if (jj_scan_token(MINUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_406()
+ {
+    if (jj_scan_token(PLUS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_399()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_406()) {
+    jj_scanpos = xsp;
+    if (jj_3R_407()) return true;
+    }
+    if (jj_3R_382()) return true;
+    return false;
+  }
+
+  private boolean jj_3_4()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_72()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_177()
+ {
+    if (jj_3R_88()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_213()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_291()
+ {
+    if (jj_scan_token(THROW)) return true;
+    if (jj_3R_90()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_378()
+ {
+    if (jj_3R_382()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_399()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_319()
+ {
+    if (jj_3R_88()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_415()
+ {
+    if (jj_3R_105()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_178()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_177()) return true;
+    return false;
+  }
+
+  private boolean jj_3_27()
+ {
+    if (jj_3R_93()) return true;
+    return false;
+  }
+
+  private boolean jj_3_26()
+ {
+    if (jj_3R_92()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_440()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_290()
+ {
+    if (jj_scan_token(RETURN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_321()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_91()
+ {
+    if (jj_scan_token(LSHIFT)) return true;
+    return false;
+  }
+
+  private boolean jj_3_25()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_91()) {
+    jj_scanpos = xsp;
+    if (jj_3_26()) {
+    jj_scanpos = xsp;
+    if (jj_3_27()) return true;
+    }
+    }
+    if (jj_3R_378()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_117()
+ {
+    if (jj_scan_token(LT)) return true;
+    if (jj_3R_86()) return true;
+    if (jj_3R_177()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_178()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(GT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_379()
+ {
+    if (jj_scan_token(INSTANCEOF)) return true;
+    if (jj_3R_249()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_376()
+ {
+    if (jj_3R_378()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_25()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_289()
+ {
+    if (jj_scan_token(CONTINUE)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_320()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_387()
+ {
+    if (jj_scan_token(GE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_386()
+ {
+    if (jj_scan_token(LE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_426()
+ {
+    if (jj_3R_432()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_385()
+ {
+    if (jj_scan_token(GT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_384()
+ {
+    if (jj_scan_token(LT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_414()
+ {
+    if (jj_3R_183()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_383()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_384()) {
+    jj_scanpos = xsp;
+    if (jj_3R_385()) {
+    jj_scanpos = xsp;
+    if (jj_3R_386()) {
+    jj_scanpos = xsp;
+    if (jj_3R_387()) return true;
+    }
+    }
+    }
+    if (jj_3R_376()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_288()
+ {
+    if (jj_scan_token(BREAK)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_319()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_116()
+ {
+    if (jj_3R_115()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_72()
+ {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_116()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_3R_88()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_414()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_415()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_373()
+ {
+    if (jj_3R_376()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_383()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_432()
+ {
+    if (jj_3R_375()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_416()
+ {
+    if (jj_3R_256()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_411()
+ {
+    if (jj_scan_token(ELSE)) return true;
+    if (jj_3R_195()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_400()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_416()) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(98)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3_46()
+ {
+    if (jj_3R_108()) return true;
+    if (jj_3R_75()) return true;
+    if (jj_3R_74()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_374()
+ {
+    if (jj_scan_token(BIT_AND)) return true;
+    if (jj_3R_363()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_369()
+ {
+    if (jj_3R_373()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_379()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_390()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_400()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_375()
+ {
+    if (jj_3R_90()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_440()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_372()
+ {
+    if (jj_3R_375()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_425()
+ {
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_389()
+ {
+    if (jj_3R_72()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_4()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_371()
+ {
+    if (jj_3R_109()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_388()
+ {
+    if (jj_3R_305()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_381()
+ {
+    if (jj_scan_token(NE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_380()
+ {
+    if (jj_scan_token(EQ)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_377()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_380()) {
+    jj_scanpos = xsp;
+    if (jj_3R_381()) return true;
+    }
+    if (jj_3R_369()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_370()
+ {
+    if (jj_scan_token(XOR)) return true;
+    if (jj_3R_347()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_351()
+ {
+    if (jj_scan_token(ENUM)) return true;
+    if (jj_3R_88()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_388()) jj_scanpos = xsp;
+    if (jj_scan_token(LBRACE)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_389()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(99)) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_390()) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_367()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_371()) {
+    jj_scanpos = xsp;
+    if (jj_3R_372()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_364()
+ {
+    if (jj_scan_token(BIT_OR)) return true;
+    if (jj_3R_324()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_363()
+ {
+    if (jj_3R_369()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_377()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3_45()
+ {
+    if (jj_3R_109()) return true;
+    if (jj_scan_token(COLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_348()
+ {
+    if (jj_scan_token(SC_AND)) return true;
+    if (jj_3R_296()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_409()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_306()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_347()
+ {
+    if (jj_3R_363()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_374()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_356()
+ {
+    if (jj_3R_367()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_305()
+ {
+    if (jj_scan_token(IMPLEMENTS)) return true;
+    if (jj_3R_306()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_409()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_338()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_356()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_425()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_426()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_325()
+ {
+    if (jj_scan_token(SC_OR)) return true;
+    if (jj_3R_248()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_337()
+ {
+    if (jj_3R_109()) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_90()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_324()
+ {
+    if (jj_3R_347()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_370()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_408()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_306()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_287()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_337()) {
+    jj_scanpos = xsp;
+    if (jj_3R_338()) return true;
+    }
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_195()) return true;
+    return false;
+  }
+
+  /** Generated Token Manager. */
+  public GeneratedJavaParserTokenManager token_source;
+  SimpleCharStream jj_input_stream;
+  /** Current token. */
+  public Token token;
+  /** Next token. */
+  public Token jj_nt;
+  private int jj_ntk;
+  private Token jj_scanpos, jj_lastpos;
+  private int jj_la;
+  /** Whether we are looking ahead. */
+  private boolean jj_lookingAhead = false;
+  private boolean jj_semLA;
+  private int jj_gen;
+  final private int[] jj_la1 = new int[164];
+  static private int[] jj_la1_0;
+  static private int[] jj_la1_1;
+  static private int[] jj_la1_2;
+  static private int[] jj_la1_3;
+  static private int[] jj_la1_4;
+  static {
+	   jj_la1_init_0();
+	   jj_la1_init_1();
+	   jj_la1_init_2();
+	   jj_la1_init_3();
+	   jj_la1_init_4();
+	}
+	private static void jj_la1_init_0() {
+	   jj_la1_0 = new int[] {0x24480800,0x4080000,0x24480800,0x1,0x0,0x0,0x20400800,0x80000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x4000000,0x0,0xa54ca800,0xa54ca800,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0xa54ca800,0x0,0x0,0x0,0x9504a000,0x9504a000,0x0,0x0,0x0,0x0,0x0,0x0,0xa544a800,0x0,0xa544a800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x8104a000,0x8504a000,0x8504a000,0x0,0x8504a000,0x8504a000,0x8000000,0x8000000,0x8104a000,0x8504a000,0x4000000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x0,0x9504a000,0x0,0x0,0x8504a000,0x0,0x0,0x0,0x4000000,0x0,0x0,0x9504a000,0x0,0x4000000,0x0,0x10000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x9504a000,0x0,0x0,0x0,0x8504a000,0x9504a000,0x0,0x95a4f000,0x0,0x95a4f000,0x0,0x9504a000,0x0,0x0,0x9504a000,0x410000,0x410000,0x2000000,0xb544a800,0x9504a000,0x9504a000,0xb544a800,0x9504a000,0x0,0x4000000,0x4000000,0x9504a000,0x0,0x20000,0x0,0x40000000,0x9504a000,0x4000000,0x0,0x9504a000,0x9504a000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,};
+	}
+	private static void jj_la1_init_1() {
+	   jj_la1_1 = new int[] {0x444ce290,0x80,0x444ce290,0x0,0x40000,0x0,0x444ce200,0x80,0x0,0x0,0x8,0x0,0x0,0x8,0x80000,0x0,0x644ee3c0,0x644ee3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x644ee3c0,0x644ee3c0,0x80,0x200a0140,0x644ee3c0,0x0,0x0,0x0,0x289a0d40,0x289a0d40,0x0,0x0,0x0,0x0,0x2000000,0x0,0x444ee340,0x0,0x444ee340,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x289a0d40,0x40000,0x20140,0xa0140,0xa0140,0x0,0xa0140,0xa0140,0x100000,0x100000,0x20140,0x200a0140,0x80000,0x0,0x80400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,0x0,0x0,0x289a0d40,0x0,0x0,0xa0140,0x0,0x0,0x0,0x80400,0x0,0x0,0x289a0d40,0x0,0x80400,0x0,0x8900c00,0x80000,0x0,0x0,0x0,0x800400,0x0,0x8000800,0x8000000,0x289a0d40,0x0,0x0,0x0,0xa0140,0x289a0d40,0x0,0xb9fb0d45,0x0,0xb9fb0d45,0x0,0x289a0d40,0x0,0x0,0x289a0d40,0x0,0x0,0x0,0x6cdeef40,0x289a0d40,0x289a0d40,0x6cdeef40,0x289a0d40,0x0,0x80000,0x80000,0x289a0d40,0x0,0x0,0x0,0x0,0x289a0d40,0x80000,0x0,0x289a0d40,0x289a0d40,0x0,0x444ee3c0,0x444ee3c0,0x80,0xa0140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,};
+	}
+	private static void jj_la1_init_2() {
+	   jj_la1_2 = new int[] {0x248,0x48,0x248,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20003ff,0x0,0x420003ff,0x420003ff,0x0,0x0,0x10000000,0x40000000,0x0,0x0,0x0,0x420003ff,0x420003ff,0x0,0x20003ff,0x20003ff,0x0,0x0,0x0,0x53810fff,0x53810fff,0x0,0x0,0x0,0x0,0x0,0x40000000,0x20003ff,0x0,0x20003ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13810fff,0x0,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x20003ff,0x0,0x0,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13810fff,0x0,0x0,0x13810fff,0x0,0x0,0x20003ff,0x0,0x10000000,0x0,0x20003ff,0x0,0x20000000,0x13810fff,0x0,0x20003ff,0x10000000,0x11810c00,0x20003ff,0x0,0x0,0x10000000,0x0,0x0,0x1810c00,0x0,0x13810fff,0x0,0x0,0x10000000,0x20003ff,0x13810fff,0x40000000,0x53810fff,0x0,0x53810fff,0x0,0x53810fff,0x0,0x0,0x13810fff,0x0,0x0,0x0,0x13810fff,0x13810fff,0x13810fff,0x13810fff,0x13810fff,0x0,0x20003ff,0x20003ff,0x13810fff,0x10000000,0x0,0x0,0x0,0x13810fff,0x20003ff,0x0,0x53810fff,0x53810fff,0x0,0x20003ff,0x20003ff,0x0,0x20003ff,0x0,0x0,0x2,0x0,0x2,0x0,0x1b1,0x8,0x1b1,0x13810fff,};
+	}
+	private static void jj_la1_init_3() {
+	   jj_la1_3 = new int[] {0x24,0x24,0x24,0x0,0x0,0x10,0x20,0x0,0x80,0x0,0x0,0x8,0x8,0x0,0x20,0x8,0xa4,0xa4,0x4,0x20,0x0,0x0,0x8,0x0,0x1000000,0xa4,0xa4,0x0,0xa0,0xa0,0x8,0x40,0x21,0x3c0320,0x3c0320,0x8,0x80,0x21,0x8,0x0,0x4,0x20,0x8,0x20,0x8,0x8,0x20,0x80,0x8,0x0,0x80,0x80,0xa0,0x0,0x0,0x0,0x20,0x8,0x420,0x400,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0xe0000040,0xe0000040,0x400,0x10000,0x20000,0x2000000,0x4000000,0x1000000,0x9000,0x9000,0x0,0x6080,0x6080,0x10000000,0x300000,0x300000,0x8c00000,0x8c00000,0x300000,0x3c0320,0x300,0x300,0x20,0xc0000,0x1000000,0x0,0x80,0x0,0x80,0x0,0x10,0x0,0x3c0320,0x80,0x0,0x0,0x0,0x0,0x10,0x80,0x0,0x0,0x11,0x0,0x0,0x3c0320,0x8,0x80,0x21,0xa0,0x3c0320,0x0,0xc0024,0x800,0xc0024,0x8,0x3c0320,0xe00c0040,0xe00c0040,0x80020,0x0,0x0,0x0,0x3c0320,0x3c0320,0x3c0320,0x3c0324,0x3c0320,0x8,0x0,0x0,0x3c0320,0x0,0x0,0x2000000,0x0,0x20,0x0,0x8,0x3c0320,0x3c0320,0x8,0x24,0x24,0x0,0x20,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0xa0,};
+	}
+	private static void jj_la1_init_4() {
+	   jj_la1_4 = new int[] {0x0,0x0,0x0,0x4000,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,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x6ff,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,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,0xff,0xff,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,};
+	}
+  final private JJCalls[] jj_2_rtns = new JJCalls[58];
+  private boolean jj_rescan = false;
+  private int jj_gc = 0;
+
+  /** Constructor. */
+  public GeneratedJavaParser(Provider stream) {
+	 jj_input_stream = new SimpleCharStream(stream, 1, 1);
+	 token_source = new GeneratedJavaParserTokenManager(jj_input_stream);
+	 token = new Token();
+	 jj_ntk = -1;
+	 jj_gen = 0;
+	 for (int i = 0; i < 164; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Constructor. */
+  public GeneratedJavaParser(String dsl) throws ParseException, TokenMgrException {
+	   this(new StringProvider(dsl));
+  }
+
+  public void ReInit(String s) {
+	  ReInit(new StringProvider(s));
+  }
+  /** Reinitialise. */
+  public void ReInit(Provider stream) {
+	if (jj_input_stream == null) {
+	   jj_input_stream = new SimpleCharStream(stream, 1, 1);
+	} else {
+	   jj_input_stream.ReInit(stream, 1, 1);
+	}
+	if (token_source == null) {
+ token_source = new GeneratedJavaParserTokenManager(jj_input_stream);
+	}
+
+	 token_source.ReInit(jj_input_stream);
+	 token = new Token();
+	 jj_ntk = -1;
+	 jj_gen = 0;
+	 for (int i = 0; i < 164; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Constructor with generated Token Manager. */
+  public GeneratedJavaParser(GeneratedJavaParserTokenManager tm) {
+	 token_source = tm;
+	 token = new Token();
+	 jj_ntk = -1;
+	 jj_gen = 0;
+	 for (int i = 0; i < 164; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Reinitialise. */
+  public void ReInit(GeneratedJavaParserTokenManager tm) {
+	 token_source = tm;
+	 token = new Token();
+	 jj_ntk = -1;
+	 jj_gen = 0;
+	 for (int i = 0; i < 164; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  private Token jj_consume_token(int kind) throws ParseException {
+	 Token oldToken;
+	 if ((oldToken = token).next != null) token = token.next;
+	 else token = token.next = token_source.getNextToken();
+	 jj_ntk = -1;
+	 if (token.kind == kind) {
+	   jj_gen++;
+	   if (++jj_gc > 100) {
+		 jj_gc = 0;
+		 for (int i = 0; i < jj_2_rtns.length; i++) {
+		   JJCalls c = jj_2_rtns[i];
+		   while (c != null) {
+			 if (c.gen < jj_gen) c.first = null;
+			 c = c.next;
+		   }
+		 }
+	   }
+	   return token;
+	 }
+	 token = oldToken;
+	 jj_kind = kind;
+	 throw generateParseException();
+  }
+
+  @SuppressWarnings("serial")
+  static private final class LookaheadSuccess extends java.lang.RuntimeException { }
+  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
+  private boolean jj_scan_token(int kind) {
+	 if (jj_scanpos == jj_lastpos) {
+	   jj_la--;
+	   if (jj_scanpos.next == null) {
+		 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
+	   } else {
+		 jj_lastpos = jj_scanpos = jj_scanpos.next;
+	   }
+	 } else {
+	   jj_scanpos = jj_scanpos.next;
+	 }
+	 if (jj_rescan) {
+	   int i = 0; Token tok = token;
+	   while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
+	   if (tok != null) jj_add_error_token(kind, i);
+	 }
+	 if (jj_scanpos.kind != kind) return true;
+	 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+	 return false;
+  }
+
+
+/** Get the next Token. */
+  final public Token getNextToken() {
+	 if (token.next != null) token = token.next;
+	 else token = token.next = token_source.getNextToken();
+	 jj_ntk = -1;
+	 jj_gen++;
+	 return token;
+  }
+
+/** Get the specific Token. */
+  final public Token getToken(int index) {
+	 Token t = jj_lookingAhead ? jj_scanpos : token;
+	 for (int i = 0; i < index; i++) {
+	   if (t.next != null) t = t.next;
+	   else t = t.next = token_source.getNextToken();
+	 }
+	 return t;
+  }
+
+  private int jj_ntk_f() {
+	 if ((jj_nt=token.next) == null)
+	   return (jj_ntk = (token.next=token_source.getNextToken()).kind);
+	 else
+	   return (jj_ntk = jj_nt.kind);
+  }
+
+  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+  private int[] jj_expentry;
+  private int jj_kind = -1;
+  private int[] jj_lasttokens = new int[100];
+  private int jj_endpos;
+
+  private void jj_add_error_token(int kind, int pos) {
+	 if (pos >= 100) {
+		return;
+	 }
+
+	 if (pos == jj_endpos + 1) {
+	   jj_lasttokens[jj_endpos++] = kind;
+	 } else if (jj_endpos != 0) {
+	   jj_expentry = new int[jj_endpos];
+
+	   for (int i = 0; i < jj_endpos; i++) {
+		 jj_expentry[i] = jj_lasttokens[i];
+	   }
+
+	   for (int[] oldentry : jj_expentries) {
+		 if (oldentry.length == jj_expentry.length) {
+		   boolean isMatched = true;
+
+		   for (int i = 0; i < jj_expentry.length; i++) {
+			 if (oldentry[i] != jj_expentry[i]) {
+			   isMatched = false;
+			   break;
+			 }
+
+		   }
+		   if (isMatched) {
+			 jj_expentries.add(jj_expentry);
+			 break;
+		   }
+		 }
+	   }
+
+	   if (pos != 0) {
+		 jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+	   }
+	 }
+  }
+
+  /** Generate ParseException. */
+  public ParseException generateParseException() {
+	 jj_expentries.clear();
+	 boolean[] la1tokens = new boolean[143];
+	 if (jj_kind >= 0) {
+	   la1tokens[jj_kind] = true;
+	   jj_kind = -1;
+	 }
+	 for (int i = 0; i < 164; i++) {
+	   if (jj_la1[i] == jj_gen) {
+		 for (int j = 0; j < 32; j++) {
+		   if ((jj_la1_0[i] & (1<<j)) != 0) {
+			 la1tokens[j] = true;
+		   }
+		   if ((jj_la1_1[i] & (1<<j)) != 0) {
+			 la1tokens[32+j] = true;
+		   }
+		   if ((jj_la1_2[i] & (1<<j)) != 0) {
+			 la1tokens[64+j] = true;
+		   }
+		   if ((jj_la1_3[i] & (1<<j)) != 0) {
+			 la1tokens[96+j] = true;
+		   }
+		   if ((jj_la1_4[i] & (1<<j)) != 0) {
+			 la1tokens[128+j] = true;
+		   }
+		 }
+	   }
+	 }
+	 for (int i = 0; i < 143; i++) {
+	   if (la1tokens[i]) {
+		 jj_expentry = new int[1];
+		 jj_expentry[0] = i;
+		 jj_expentries.add(jj_expentry);
+	   }
+	 }
+	 jj_endpos = 0;
+	 jj_rescan_token();
+	 jj_add_error_token(0, 0);
+	 int[][] exptokseq = new int[jj_expentries.size()][];
+	 for (int i = 0; i < jj_expentries.size(); i++) {
+	   exptokseq[i] = jj_expentries.get(i);
+	 }
+	 return new ParseException(token, exptokseq, tokenImage, token_source == null ? null : GeneratedJavaParserTokenManager.lexStateNames[token_source.curLexState]);
+  }
+
+  private int trace_indent = 0;
+  private boolean trace_enabled;
+
+/** Trace enabled. */
+  final public boolean trace_enabled() {
+	 return trace_enabled;
+  }
+
+  /** Enable tracing. */
+  final public void enable_tracing() {
+  }
+
+  /** Disable tracing. */
+  final public void disable_tracing() {
+  }
+
+  private void jj_rescan_token() {
+	 jj_rescan = true;
+	 for (int i = 0; i < 58; i++) {
+	   try {
+		 JJCalls p = jj_2_rtns[i];
+
+		 do {
+		   if (p.gen > jj_gen) {
+			 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
+			 switch (i) {
+			   case 0: jj_3_1(); break;
+			   case 1: jj_3_2(); break;
+			   case 2: jj_3_3(); break;
+			   case 3: jj_3_4(); break;
+			   case 4: jj_3_5(); break;
+			   case 5: jj_3_6(); break;
+			   case 6: jj_3_7(); break;
+			   case 7: jj_3_8(); break;
+			   case 8: jj_3_9(); break;
+			   case 9: jj_3_10(); break;
+			   case 10: jj_3_11(); break;
+			   case 11: jj_3_12(); break;
+			   case 12: jj_3_13(); break;
+			   case 13: jj_3_14(); break;
+			   case 14: jj_3_15(); break;
+			   case 15: jj_3_16(); break;
+			   case 16: jj_3_17(); break;
+			   case 17: jj_3_18(); break;
+			   case 18: jj_3_19(); break;
+			   case 19: jj_3_20(); break;
+			   case 20: jj_3_21(); break;
+			   case 21: jj_3_22(); break;
+			   case 22: jj_3_23(); break;
+			   case 23: jj_3_24(); break;
+			   case 24: jj_3_25(); break;
+			   case 25: jj_3_26(); break;
+			   case 26: jj_3_27(); break;
+			   case 27: jj_3_28(); break;
+			   case 28: jj_3_29(); break;
+			   case 29: jj_3_30(); break;
+			   case 30: jj_3_31(); break;
+			   case 31: jj_3_32(); break;
+			   case 32: jj_3_33(); break;
+			   case 33: jj_3_34(); break;
+			   case 34: jj_3_35(); break;
+			   case 35: jj_3_36(); break;
+			   case 36: jj_3_37(); break;
+			   case 37: jj_3_38(); break;
+			   case 38: jj_3_39(); break;
+			   case 39: jj_3_40(); break;
+			   case 40: jj_3_41(); break;
+			   case 41: jj_3_42(); break;
+			   case 42: jj_3_43(); break;
+			   case 43: jj_3_44(); break;
+			   case 44: jj_3_45(); break;
+			   case 45: jj_3_46(); break;
+			   case 46: jj_3_47(); break;
+			   case 47: jj_3_48(); break;
+			   case 48: jj_3_49(); break;
+			   case 49: jj_3_50(); break;
+			   case 50: jj_3_51(); break;
+			   case 51: jj_3_52(); break;
+			   case 52: jj_3_53(); break;
+			   case 53: jj_3_54(); break;
+			   case 54: jj_3_55(); break;
+			   case 55: jj_3_56(); break;
+			   case 56: jj_3_57(); break;
+			   case 57: jj_3_58(); break;
+			 }
+		   }
+		   p = p.next;
+		 } while (p != null);
+
+		 } catch(LookaheadSuccess ls) { }
+	 }
+	 jj_rescan = false;
+  }
+
+  private void jj_save(int index, int xla) {
+	 JJCalls p = jj_2_rtns[index];
+	 while (p.gen > jj_gen) {
+	   if (p.next == null) { p = p.next = new JJCalls(); break; }
+	   p = p.next;
+	 }
+
+	 p.gen = jj_gen + xla - jj_la; 
+	 p.first = token;
+	 p.arg = xla;
+  }
+
+  static final class JJCalls {
+	 int gen;
+	 Token first;
+	 int arg;
+	 JJCalls next;
+  }
+
+}
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java
new file mode 100644
index 000000000..e59d1e3e6
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserConstants.java
@@ -0,0 +1,472 @@
+/* Generated By:JavaCC: Do not edit this line. GeneratedJavaParserConstants.java */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface GeneratedJavaParserConstants {
+
+  /** End of File. */
+  int EOF = 0;
+  /** RegularExpression Id. */
+  int SPACE = 1;
+  /** RegularExpression Id. */
+  int WINDOWS_EOL = 2;
+  /** RegularExpression Id. */
+  int UNIX_EOL = 3;
+  /** RegularExpression Id. */
+  int OLD_MAC_EOL = 4;
+  /** RegularExpression Id. */
+  int SINGLE_LINE_COMMENT = 5;
+  /** RegularExpression Id. */
+  int ENTER_JAVADOC_COMMENT = 6;
+  /** RegularExpression Id. */
+  int ENTER_MULTILINE_COMMENT = 7;
+  /** RegularExpression Id. */
+  int JAVADOC_COMMENT = 8;
+  /** RegularExpression Id. */
+  int MULTI_LINE_COMMENT = 9;
+  /** RegularExpression Id. */
+  int COMMENT_CONTENT = 10;
+  /** RegularExpression Id. */
+  int ABSTRACT = 11;
+  /** RegularExpression Id. */
+  int ASSERT = 12;
+  /** RegularExpression Id. */
+  int BOOLEAN = 13;
+  /** RegularExpression Id. */
+  int BREAK = 14;
+  /** RegularExpression Id. */
+  int BYTE = 15;
+  /** RegularExpression Id. */
+  int CASE = 16;
+  /** RegularExpression Id. */
+  int CATCH = 17;
+  /** RegularExpression Id. */
+  int CHAR = 18;
+  /** RegularExpression Id. */
+  int CLASS = 19;
+  /** RegularExpression Id. */
+  int CONST = 20;
+  /** RegularExpression Id. */
+  int CONTINUE = 21;
+  /** RegularExpression Id. */
+  int _DEFAULT = 22;
+  /** RegularExpression Id. */
+  int DO = 23;
+  /** RegularExpression Id. */
+  int DOUBLE = 24;
+  /** RegularExpression Id. */
+  int ELSE = 25;
+  /** RegularExpression Id. */
+  int ENUM = 26;
+  /** RegularExpression Id. */
+  int EXTENDS = 27;
+  /** RegularExpression Id. */
+  int FALSE = 28;
+  /** RegularExpression Id. */
+  int FINAL = 29;
+  /** RegularExpression Id. */
+  int FINALLY = 30;
+  /** RegularExpression Id. */
+  int FLOAT = 31;
+  /** RegularExpression Id. */
+  int FOR = 32;
+  /** RegularExpression Id. */
+  int GOTO = 33;
+  /** RegularExpression Id. */
+  int IF = 34;
+  /** RegularExpression Id. */
+  int IMPLEMENTS = 35;
+  /** RegularExpression Id. */
+  int IMPORT = 36;
+  /** RegularExpression Id. */
+  int INSTANCEOF = 37;
+  /** RegularExpression Id. */
+  int INT = 38;
+  /** RegularExpression Id. */
+  int INTERFACE = 39;
+  /** RegularExpression Id. */
+  int LONG = 40;
+  /** RegularExpression Id. */
+  int NATIVE = 41;
+  /** RegularExpression Id. */
+  int NEW = 42;
+  /** RegularExpression Id. */
+  int NULL = 43;
+  /** RegularExpression Id. */
+  int PACKAGE = 44;
+  /** RegularExpression Id. */
+  int PRIVATE = 45;
+  /** RegularExpression Id. */
+  int PROTECTED = 46;
+  /** RegularExpression Id. */
+  int PUBLIC = 47;
+  /** RegularExpression Id. */
+  int RETURN = 48;
+  /** RegularExpression Id. */
+  int SHORT = 49;
+  /** RegularExpression Id. */
+  int STATIC = 50;
+  /** RegularExpression Id. */
+  int STRICTFP = 51;
+  /** RegularExpression Id. */
+  int SUPER = 52;
+  /** RegularExpression Id. */
+  int SWITCH = 53;
+  /** RegularExpression Id. */
+  int SYNCHRONIZED = 54;
+  /** RegularExpression Id. */
+  int THIS = 55;
+  /** RegularExpression Id. */
+  int THROW = 56;
+  /** RegularExpression Id. */
+  int THROWS = 57;
+  /** RegularExpression Id. */
+  int TRANSIENT = 58;
+  /** RegularExpression Id. */
+  int TRUE = 59;
+  /** RegularExpression Id. */
+  int TRY = 60;
+  /** RegularExpression Id. */
+  int VOID = 61;
+  /** RegularExpression Id. */
+  int VOLATILE = 62;
+  /** RegularExpression Id. */
+  int WHILE = 63;
+  /** RegularExpression Id. */
+  int REQUIRES = 64;
+  /** RegularExpression Id. */
+  int TO = 65;
+  /** RegularExpression Id. */
+  int WITH = 66;
+  /** RegularExpression Id. */
+  int OPEN = 67;
+  /** RegularExpression Id. */
+  int OPENS = 68;
+  /** RegularExpression Id. */
+  int USES = 69;
+  /** RegularExpression Id. */
+  int MODULE = 70;
+  /** RegularExpression Id. */
+  int EXPORTS = 71;
+  /** RegularExpression Id. */
+  int PROVIDES = 72;
+  /** RegularExpression Id. */
+  int TRANSITIVE = 73;
+  /** RegularExpression Id. */
+  int LONG_LITERAL = 74;
+  /** RegularExpression Id. */
+  int INTEGER_LITERAL = 75;
+  /** RegularExpression Id. */
+  int DECIMAL_LITERAL = 76;
+  /** RegularExpression Id. */
+  int HEX_LITERAL = 77;
+  /** RegularExpression Id. */
+  int OCTAL_LITERAL = 78;
+  /** RegularExpression Id. */
+  int BINARY_LITERAL = 79;
+  /** RegularExpression Id. */
+  int FLOATING_POINT_LITERAL = 80;
+  /** RegularExpression Id. */
+  int DECIMAL_FLOATING_POINT_LITERAL = 81;
+  /** RegularExpression Id. */
+  int DECIMAL_EXPONENT = 82;
+  /** RegularExpression Id. */
+  int HEXADECIMAL_FLOATING_POINT_LITERAL = 83;
+  /** RegularExpression Id. */
+  int HEXADECIMAL_EXPONENT = 84;
+  /** RegularExpression Id. */
+  int HEX_DIGITS = 85;
+  /** RegularExpression Id. */
+  int UNICODE_ESCAPE = 86;
+  /** RegularExpression Id. */
+  int CHARACTER_LITERAL = 87;
+  /** RegularExpression Id. */
+  int STRING_LITERAL = 88;
+  /** RegularExpression Id. */
+  int IDENTIFIER = 89;
+  /** RegularExpression Id. */
+  int LETTER = 90;
+  /** RegularExpression Id. */
+  int PART_LETTER = 91;
+  /** RegularExpression Id. */
+  int LPAREN = 92;
+  /** RegularExpression Id. */
+  int RPAREN = 93;
+  /** RegularExpression Id. */
+  int LBRACE = 94;
+  /** RegularExpression Id. */
+  int RBRACE = 95;
+  /** RegularExpression Id. */
+  int LBRACKET = 96;
+  /** RegularExpression Id. */
+  int RBRACKET = 97;
+  /** RegularExpression Id. */
+  int SEMICOLON = 98;
+  /** RegularExpression Id. */
+  int COMMA = 99;
+  /** RegularExpression Id. */
+  int DOT = 100;
+  /** RegularExpression Id. */
+  int AT = 101;
+  /** RegularExpression Id. */
+  int ASSIGN = 102;
+  /** RegularExpression Id. */
+  int LT = 103;
+  /** RegularExpression Id. */
+  int BANG = 104;
+  /** RegularExpression Id. */
+  int TILDE = 105;
+  /** RegularExpression Id. */
+  int HOOK = 106;
+  /** RegularExpression Id. */
+  int COLON = 107;
+  /** RegularExpression Id. */
+  int EQ = 108;
+  /** RegularExpression Id. */
+  int LE = 109;
+  /** RegularExpression Id. */
+  int GE = 110;
+  /** RegularExpression Id. */
+  int NE = 111;
+  /** RegularExpression Id. */
+  int SC_OR = 112;
+  /** RegularExpression Id. */
+  int SC_AND = 113;
+  /** RegularExpression Id. */
+  int INCR = 114;
+  /** RegularExpression Id. */
+  int DECR = 115;
+  /** RegularExpression Id. */
+  int PLUS = 116;
+  /** RegularExpression Id. */
+  int MINUS = 117;
+  /** RegularExpression Id. */
+  int STAR = 118;
+  /** RegularExpression Id. */
+  int SLASH = 119;
+  /** RegularExpression Id. */
+  int BIT_AND = 120;
+  /** RegularExpression Id. */
+  int BIT_OR = 121;
+  /** RegularExpression Id. */
+  int XOR = 122;
+  /** RegularExpression Id. */
+  int REM = 123;
+  /** RegularExpression Id. */
+  int LSHIFT = 124;
+  /** RegularExpression Id. */
+  int PLUSASSIGN = 125;
+  /** RegularExpression Id. */
+  int MINUSASSIGN = 126;
+  /** RegularExpression Id. */
+  int STARASSIGN = 127;
+  /** RegularExpression Id. */
+  int SLASHASSIGN = 128;
+  /** RegularExpression Id. */
+  int ANDASSIGN = 129;
+  /** RegularExpression Id. */
+  int ORASSIGN = 130;
+  /** RegularExpression Id. */
+  int XORASSIGN = 131;
+  /** RegularExpression Id. */
+  int REMASSIGN = 132;
+  /** RegularExpression Id. */
+  int LSHIFTASSIGN = 133;
+  /** RegularExpression Id. */
+  int RSIGNEDSHIFTASSIGN = 134;
+  /** RegularExpression Id. */
+  int RUNSIGNEDSHIFTASSIGN = 135;
+  /** RegularExpression Id. */
+  int ELLIPSIS = 136;
+  /** RegularExpression Id. */
+  int ARROW = 137;
+  /** RegularExpression Id. */
+  int DOUBLECOLON = 138;
+  /** RegularExpression Id. */
+  int RUNSIGNEDSHIFT = 139;
+  /** RegularExpression Id. */
+  int RSIGNEDSHIFT = 140;
+  /** RegularExpression Id. */
+  int GT = 141;
+  /** RegularExpression Id. */
+  int CTRL_Z = 142;
+
+  /** Lexical state. */
+  int DEFAULT = 0;
+  /** Lexical state. */
+  int IN_JAVADOC_COMMENT = 1;
+  /** Lexical state. */
+  int IN_MULTI_LINE_COMMENT = 2;
+
+  /** Literal token values. */
+  String[] tokenImage = {
+    "<EOF>",
+    "<SPACE>",
+    "\"\\r\\n\"",
+    "\"\\n\"",
+    "\"\\r\"",
+    "<SINGLE_LINE_COMMENT>",
+    "<ENTER_JAVADOC_COMMENT>",
+    "\"/*\"",
+    "\"*/\"",
+    "\"*/\"",
+    "<COMMENT_CONTENT>",
+    "\"abstract\"",
+    "\"assert\"",
+    "\"boolean\"",
+    "\"break\"",
+    "\"byte\"",
+    "\"case\"",
+    "\"catch\"",
+    "\"char\"",
+    "\"class\"",
+    "\"const\"",
+    "\"continue\"",
+    "\"default\"",
+    "\"do\"",
+    "\"double\"",
+    "\"else\"",
+    "\"enum\"",
+    "\"extends\"",
+    "\"false\"",
+    "\"final\"",
+    "\"finally\"",
+    "\"float\"",
+    "\"for\"",
+    "\"goto\"",
+    "\"if\"",
+    "\"implements\"",
+    "\"import\"",
+    "\"instanceof\"",
+    "\"int\"",
+    "\"interface\"",
+    "\"long\"",
+    "\"native\"",
+    "\"new\"",
+    "\"null\"",
+    "\"package\"",
+    "\"private\"",
+    "\"protected\"",
+    "\"public\"",
+    "\"return\"",
+    "\"short\"",
+    "\"static\"",
+    "\"strictfp\"",
+    "\"super\"",
+    "\"switch\"",
+    "\"synchronized\"",
+    "\"this\"",
+    "\"throw\"",
+    "\"throws\"",
+    "\"transient\"",
+    "\"true\"",
+    "\"try\"",
+    "\"void\"",
+    "\"volatile\"",
+    "\"while\"",
+    "\"requires\"",
+    "\"to\"",
+    "\"with\"",
+    "\"open\"",
+    "\"opens\"",
+    "\"uses\"",
+    "\"module\"",
+    "\"exports\"",
+    "\"provides\"",
+    "\"transitive\"",
+    "<LONG_LITERAL>",
+    "<INTEGER_LITERAL>",
+    "<DECIMAL_LITERAL>",
+    "<HEX_LITERAL>",
+    "<OCTAL_LITERAL>",
+    "<BINARY_LITERAL>",
+    "<FLOATING_POINT_LITERAL>",
+    "<DECIMAL_FLOATING_POINT_LITERAL>",
+    "<DECIMAL_EXPONENT>",
+    "<HEXADECIMAL_FLOATING_POINT_LITERAL>",
+    "<HEXADECIMAL_EXPONENT>",
+    "<HEX_DIGITS>",
+    "<UNICODE_ESCAPE>",
+    "<CHARACTER_LITERAL>",
+    "<STRING_LITERAL>",
+    "<IDENTIFIER>",
+    "<LETTER>",
+    "<PART_LETTER>",
+    "\"(\"",
+    "\")\"",
+    "\"{\"",
+    "\"}\"",
+    "\"[\"",
+    "\"]\"",
+    "\";\"",
+    "\",\"",
+    "\".\"",
+    "\"@\"",
+    "\"=\"",
+    "\"<\"",
+    "\"!\"",
+    "\"~\"",
+    "\"?\"",
+    "\":\"",
+    "\"==\"",
+    "\"<=\"",
+    "\">=\"",
+    "\"!=\"",
+    "\"||\"",
+    "\"&&\"",
+    "\"++\"",
+    "\"--\"",
+    "\"+\"",
+    "\"-\"",
+    "\"*\"",
+    "\"/\"",
+    "\"&\"",
+    "\"|\"",
+    "\"^\"",
+    "\"%\"",
+    "\"<<\"",
+    "\"+=\"",
+    "\"-=\"",
+    "\"*=\"",
+    "\"/=\"",
+    "\"&=\"",
+    "\"|=\"",
+    "\"^=\"",
+    "\"%=\"",
+    "\"<<=\"",
+    "\">>=\"",
+    "\">>>=\"",
+    "\"...\"",
+    "\"->\"",
+    "\"::\"",
+    "\">>>\"",
+    "\">>\"",
+    "\">\"",
+    "\"\\u001a\"",
+  };
+
+}
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java
new file mode 100644
index 000000000..93f340897
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/GeneratedJavaParserTokenManager.java
@@ -0,0 +1,2966 @@
+/* GeneratedJavaParserTokenManager.java */
+/* Generated By:JavaCC: Do not edit this line. GeneratedJavaParserTokenManager.java */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+import java.io.*;
+import java.util.*;
+import com.github.javaparser.ast.*;
+import com.github.javaparser.ast.body.*;
+import com.github.javaparser.ast.comments.*;
+import com.github.javaparser.ast.modules.*;
+import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.ast.stmt.*;
+import com.github.javaparser.ast.type.*;
+import com.github.javaparser.utils.*;
+import javax.annotation.Generated;
+import static com.github.javaparser.JavaToken.INVALID;
+import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE;
+import static com.github.javaparser.utils.Utils.*;
+import static com.github.javaparser.ast.NodeList.*;
+import static com.github.javaparser.GeneratedJavaParser.*;
+import static com.github.javaparser.Range.*;
+import static com.github.javaparser.Position.*;
+import static com.github.javaparser.ast.type.ArrayType.*;
+import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*;
+
+/** Token Manager. */
+public class GeneratedJavaParserTokenManager implements GeneratedJavaParserConstants {
+    private List<JavaToken> tokens = new ArrayList<JavaToken>();
+    private CommentsCollection commentsCollection = new CommentsCollection();
+    private JavaToken homeToken;
+    private Stack<Token> tokenWorkStack = new Stack<Token>();
+    private boolean storeTokens;
+
+    void reset() {
+        tokens = new ArrayList<JavaToken>();
+        commentsCollection = new CommentsCollection();
+        homeToken = null;
+    }
+
+    List<JavaToken> getTokens() {
+        if(storeTokens) {
+            return tokens;
+        }
+        return null;
+    }
+
+    CommentsCollection getCommentsCollection() {
+        return commentsCollection;
+    }
+
+    /* Get the very first token in the file */
+    JavaToken getHomeToken() {
+        return homeToken;
+    }
+
+    /* Makes the parser keep a list of tokens */
+    public void setStoreTokens(boolean storeTokens) {
+        this.storeTokens = storeTokens;
+    }
+
+    private void CommonTokenAction(Token token) {
+        // Use an intermediary stack to avoid recursion, see issue 1003
+        do {
+            tokenWorkStack.push(token);
+            token = token.specialToken;
+        } while (token != null);
+
+        // The stack is now filled with tokens in left-to-right order. Process them.
+        while(!tokenWorkStack.empty()) {
+            token = tokenWorkStack.pop();
+            token.javaToken = new JavaToken(token, tokens);
+
+            if(storeTokens) {
+                tokens.add(token.javaToken);
+            }
+
+            if (homeToken == null) {
+                homeToken = token.javaToken;
+            }
+
+            if(TokenTypes.isComment(token.kind)) {
+                Comment comment = createCommentFromToken(token);
+                commentsCollection.addComment(comment);
+            }
+        }
+    }
+
+  /** Debug output. */
+  public  java.io.PrintStream debugStream = System.out;
+  /** Set debug output. */
+  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2){
+   switch (pos)
+   {
+      case 0:
+         if ((active1 & 0x1000000000L) != 0L || (active2 & 0x100L) != 0L)
+            return 2;
+         if ((active0 & 0xfffffffffffff800L) != 0L || (active1 & 0x3ffL) != 0L)
+         {
+            jjmatchedKind = 89;
+            return 144;
+         }
+         if ((active0 & 0x80L) != 0L || (active1 & 0x80000000000000L) != 0L || (active2 & 0x1L) != 0L)
+            return 56;
+         return -1;
+      case 1:
+         if ((active0 & 0x80L) != 0L)
+            return 61;
+         if ((active0 & 0xfffffffbfe7ff800L) != 0L || (active1 & 0x3fdL) != 0L)
+         {
+            if (jjmatchedPos != 1)
+            {
+               jjmatchedKind = 89;
+               jjmatchedPos = 1;
+            }
+            return 144;
+         }
+         if ((active0 & 0x401800000L) != 0L || (active1 & 0x2L) != 0L)
+            return 144;
+         return -1;
+      case 2:
+         if ((active0 & 0x100004c100000000L) != 0L)
+            return 144;
+         if ((active0 & 0xeffffb3aff7ff800L) != 0L || (active1 & 0x3fdL) != 0L)
+         {
+            if (jjmatchedPos != 2)
+            {
+               jjmatchedKind = 89;
+               jjmatchedPos = 2;
+            }
+            return 144;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x2880090206058000L) != 0L || (active1 & 0x3cL) != 0L)
+            return 144;
+         if ((active0 & 0xc77ff2b8f97a7800L) != 0L || (active1 & 0x3c1L) != 0L)
+         {
+            if (jjmatchedPos != 3)
+            {
+               jjmatchedKind = 89;
+               jjmatchedPos = 3;
+            }
+            return 144;
+         }
+         return -1;
+      case 4:
+         if ((active0 & 0x446df2b809603800L) != 0L || (active1 & 0x3c1L) != 0L)
+         {
+            if (jjmatchedPos != 4)
+            {
+               jjmatchedKind = 89;
+               jjmatchedPos = 4;
+            }
+            return 144;
+         }
+         if ((active0 & 0x83120000f01a4000L) != 0L || (active1 & 0x10L) != 0L)
+            return 144;
+         return -1;
+      case 5:
+         if ((active0 & 0x225821001001000L) != 0L || (active1 & 0x40L) != 0L)
+            return 144;
+         if ((active0 & 0x444870a848602800L) != 0L || (active1 & 0x381L) != 0L)
+         {
+            jjmatchedKind = 89;
+            jjmatchedPos = 5;
+            return 144;
+         }
+         return -1;
+      case 6:
+         if ((active0 & 0x300048402000L) != 0L || (active1 & 0x80L) != 0L)
+            return 144;
+         if ((active0 & 0x444840a800200800L) != 0L || (active1 & 0x301L) != 0L)
+         {
+            jjmatchedKind = 89;
+            jjmatchedPos = 6;
+            return 144;
+         }
+         return -1;
+      case 7:
+         if ((active0 & 0x44040a800000000L) != 0L || (active1 & 0x200L) != 0L)
+         {
+            jjmatchedKind = 89;
+            jjmatchedPos = 7;
+            return 144;
+         }
+         if ((active0 & 0x4008000000200800L) != 0L || (active1 & 0x101L) != 0L)
+            return 144;
+         return -1;
+      case 8:
+         if ((active0 & 0x400408000000000L) != 0L)
+            return 144;
+         if ((active0 & 0x40002800000000L) != 0L || (active1 & 0x200L) != 0L)
+         {
+            jjmatchedKind = 89;
+            jjmatchedPos = 8;
+            return 144;
+         }
+         return -1;
+      case 9:
+         if ((active0 & 0x2800000000L) != 0L || (active1 & 0x200L) != 0L)
+            return 144;
+         if ((active0 & 0x40000000000000L) != 0L)
+         {
+            jjmatchedKind = 89;
+            jjmatchedPos = 9;
+            return 144;
+         }
+         return -1;
+      case 10:
+         if ((active0 & 0x40000000000000L) != 0L)
+         {
+            jjmatchedKind = 89;
+            jjmatchedPos = 10;
+            return 144;
+         }
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_0(int pos, long active0, long active1, long active2){
+   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
+}
+private int jjStopAtPos(int pos, int kind)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   return pos + 1;
+}
+private int jjMoveStringLiteralDfa0_0(){
+   switch(curChar)
+   {
+      case 10:
+         return jjStopAtPos(0, 3);
+      case 13:
+         jjmatchedKind = 4;
+         return jjMoveStringLiteralDfa1_0(0x4L, 0x0L, 0x0L);
+      case 26:
+         return jjStopAtPos(0, 142);
+      case 33:
+         jjmatchedKind = 104;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L, 0x0L);
+      case 37:
+         jjmatchedKind = 123;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10L);
+      case 38:
+         jjmatchedKind = 120;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L, 0x2L);
+      case 40:
+         return jjStopAtPos(0, 92);
+      case 41:
+         return jjStopAtPos(0, 93);
+      case 42:
+         jjmatchedKind = 118;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L, 0x0L);
+      case 43:
+         jjmatchedKind = 116;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2004000000000000L, 0x0L);
+      case 44:
+         return jjStopAtPos(0, 99);
+      case 45:
+         jjmatchedKind = 117;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x4008000000000000L, 0x200L);
+      case 46:
+         jjmatchedKind = 100;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x100L);
+      case 47:
+         jjmatchedKind = 119;
+         return jjMoveStringLiteralDfa1_0(0x80L, 0x0L, 0x1L);
+      case 58:
+         jjmatchedKind = 107;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x400L);
+      case 59:
+         return jjStopAtPos(0, 98);
+      case 60:
+         jjmatchedKind = 103;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000200000000000L, 0x20L);
+      case 61:
+         jjmatchedKind = 102;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000L, 0x0L);
+      case 62:
+         jjmatchedKind = 141;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L, 0x18c0L);
+      case 63:
+         return jjStopAtPos(0, 106);
+      case 64:
+         return jjStopAtPos(0, 101);
+      case 91:
+         return jjStopAtPos(0, 96);
+      case 93:
+         return jjStopAtPos(0, 97);
+      case 94:
+         jjmatchedKind = 122;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x8L);
+      case 97:
+         return jjMoveStringLiteralDfa1_0(0x1800L, 0x0L, 0x0L);
+      case 98:
+         return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L, 0x0L);
+      case 99:
+         return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L, 0x0L);
+      case 100:
+         return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L, 0x0L);
+      case 101:
+         return jjMoveStringLiteralDfa1_0(0xe000000L, 0x80L, 0x0L);
+      case 102:
+         return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L, 0x0L);
+      case 103:
+         return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L, 0x0L);
+      case 105:
+         return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L, 0x0L);
+      case 108:
+         return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L);
+      case 109:
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x40L, 0x0L);
+      case 110:
+         return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L, 0x0L);
+      case 111:
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x18L, 0x0L);
+      case 112:
+         return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x100L, 0x0L);
+      case 114:
+         return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x1L, 0x0L);
+      case 115:
+         return jjMoveStringLiteralDfa1_0(0x7e000000000000L, 0x0L, 0x0L);
+      case 116:
+         return jjMoveStringLiteralDfa1_0(0x1f80000000000000L, 0x202L, 0x0L);
+      case 117:
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x20L, 0x0L);
+      case 118:
+         return jjMoveStringLiteralDfa1_0(0x6000000000000000L, 0x0L, 0x0L);
+      case 119:
+         return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x4L, 0x0L);
+      case 123:
+         return jjStopAtPos(0, 94);
+      case 124:
+         jjmatchedKind = 121;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L, 0x4L);
+      case 125:
+         return jjStopAtPos(0, 95);
+      case 126:
+         return jjStopAtPos(0, 105);
+      default :
+         return jjMoveNfa_0(0, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(0, active0, active1, active2);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 10:
+         if ((active0 & 0x4L) != 0L)
+            return jjStopAtPos(1, 2);
+         break;
+      case 38:
+         if ((active1 & 0x2000000000000L) != 0L)
+            return jjStopAtPos(1, 113);
+         break;
+      case 42:
+         if ((active0 & 0x80L) != 0L)
+            return jjStartNfaWithStates_0(1, 7, 61);
+         break;
+      case 43:
+         if ((active1 & 0x4000000000000L) != 0L)
+            return jjStopAtPos(1, 114);
+         break;
+      case 45:
+         if ((active1 & 0x8000000000000L) != 0L)
+            return jjStopAtPos(1, 115);
+         break;
+      case 46:
+         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x100L);
+      case 58:
+         if ((active2 & 0x400L) != 0L)
+            return jjStopAtPos(1, 138);
+         break;
+      case 60:
+         if ((active1 & 0x1000000000000000L) != 0L)
+         {
+            jjmatchedKind = 124;
+            jjmatchedPos = 1;
+         }
+         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x20L);
+      case 61:
+         if ((active1 & 0x100000000000L) != 0L)
+            return jjStopAtPos(1, 108);
+         else if ((active1 & 0x200000000000L) != 0L)
+            return jjStopAtPos(1, 109);
+         else if ((active1 & 0x400000000000L) != 0L)
+            return jjStopAtPos(1, 110);
+         else if ((active1 & 0x800000000000L) != 0L)
+            return jjStopAtPos(1, 111);
+         else if ((active1 & 0x2000000000000000L) != 0L)
+            return jjStopAtPos(1, 125);
+         else if ((active1 & 0x4000000000000000L) != 0L)
+            return jjStopAtPos(1, 126);
+         else if ((active1 & 0x8000000000000000L) != 0L)
+            return jjStopAtPos(1, 127);
+         else if ((active2 & 0x1L) != 0L)
+            return jjStopAtPos(1, 128);
+         else if ((active2 & 0x2L) != 0L)
+            return jjStopAtPos(1, 129);
+         else if ((active2 & 0x4L) != 0L)
+            return jjStopAtPos(1, 130);
+         else if ((active2 & 0x8L) != 0L)
+            return jjStopAtPos(1, 131);
+         else if ((active2 & 0x10L) != 0L)
+            return jjStopAtPos(1, 132);
+         break;
+      case 62:
+         if ((active2 & 0x200L) != 0L)
+            return jjStopAtPos(1, 137);
+         else if ((active2 & 0x1000L) != 0L)
+         {
+            jjmatchedKind = 140;
+            jjmatchedPos = 1;
+         }
+         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x8c0L);
+      case 97:
+         return jjMoveStringLiteralDfa2_0(active0, 0x120010030000L, active1, 0L, active2, 0L);
+      case 98:
+         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0L, active2, 0L);
+      case 101:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1040000400000L, active1, 0x1L, active2, 0L);
+      case 102:
+         if ((active0 & 0x400000000L) != 0L)
+            return jjStartNfaWithStates_0(1, 34, 144);
+         break;
+      case 104:
+         return jjMoveStringLiteralDfa2_0(active0, 0x8382000000040000L, active1, 0L, active2, 0L);
+      case 105:
+         return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0x4L, active2, 0L);
+      case 108:
+         return jjMoveStringLiteralDfa2_0(active0, 0x82080000L, active1, 0L, active2, 0L);
+      case 109:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L, active2, 0L);
+      case 110:
+         return jjMoveStringLiteralDfa2_0(active0, 0xe004000000L, active1, 0L, active2, 0L);
+      case 111:
+         if ((active0 & 0x800000L) != 0L)
+         {
+            jjmatchedKind = 23;
+            jjmatchedPos = 1;
+         }
+         else if ((active1 & 0x2L) != 0L)
+            return jjStartNfaWithStates_0(1, 65, 144);
+         return jjMoveStringLiteralDfa2_0(active0, 0x6000010301302000L, active1, 0x40L, active2, 0L);
+      case 112:
+         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x18L, active2, 0L);
+      case 114:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1c00600000004000L, active1, 0x300L, active2, 0L);
+      case 115:
+         return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0x20L, active2, 0L);
+      case 116:
+         return jjMoveStringLiteralDfa2_0(active0, 0xc000000000000L, active1, 0L, active2, 0L);
+      case 117:
+         return jjMoveStringLiteralDfa2_0(active0, 0x10880000000000L, active1, 0L, active2, 0L);
+      case 119:
+         return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0L, active2, 0L);
+      case 120:
+         return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0x80L, active2, 0L);
+      case 121:
+         return jjMoveStringLiteralDfa2_0(active0, 0x40000000008000L, active1, 0L, active2, 0L);
+      case 124:
+         if ((active1 & 0x1000000000000L) != 0L)
+            return jjStopAtPos(1, 112);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(0, active0, active1, active2);
+}
+private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2){
+   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
+      return jjStartNfa_0(0, old0, old1, old2);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(1, active0, active1, active2);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 46:
+         if ((active2 & 0x100L) != 0L)
+            return jjStopAtPos(2, 136);
+         break;
+      case 61:
+         if ((active2 & 0x20L) != 0L)
+            return jjStopAtPos(2, 133);
+         else if ((active2 & 0x40L) != 0L)
+            return jjStopAtPos(2, 134);
+         break;
+      case 62:
+         if ((active2 & 0x800L) != 0L)
+         {
+            jjmatchedKind = 139;
+            jjmatchedPos = 2;
+         }
+         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x80L);
+      case 97:
+         return jjMoveStringLiteralDfa3_0(active0, 0x4040000000c0000L, active1, 0x200L, active2, 0L);
+      case 98:
+         return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L, active2, 0L);
+      case 99:
+         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L, active2, 0L);
+      case 100:
+         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40L, active2, 0L);
+      case 101:
+         return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0x38L, active2, 0L);
+      case 102:
+         return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L, active2, 0L);
+      case 105:
+         return jjMoveStringLiteralDfa3_0(active0, 0xa0a0200000000000L, active1, 0L, active2, 0L);
+      case 108:
+         return jjMoveStringLiteralDfa3_0(active0, 0x4000080010000000L, active1, 0L, active2, 0L);
+      case 110:
+         return jjMoveStringLiteralDfa3_0(active0, 0x40010060300000L, active1, 0L, active2, 0L);
+      case 111:
+         return jjMoveStringLiteralDfa3_0(active0, 0x2400080002000L, active1, 0x100L, active2, 0L);
+      case 112:
+         return jjMoveStringLiteralDfa3_0(active0, 0x10001800000000L, active1, 0x80L, active2, 0L);
+      case 113:
+         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1L, active2, 0L);
+      case 114:
+         if ((active0 & 0x100000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 32, 144);
+         return jjMoveStringLiteralDfa3_0(active0, 0x308000000000000L, active1, 0L, active2, 0L);
+      case 115:
+         return jjMoveStringLiteralDfa3_0(active0, 0x2002011800L, active1, 0L, active2, 0L);
+      case 116:
+         if ((active0 & 0x4000000000L) != 0L)
+         {
+            jjmatchedKind = 38;
+            jjmatchedPos = 2;
+         }
+         return jjMoveStringLiteralDfa3_0(active0, 0x1028208028000L, active1, 0x4L, active2, 0L);
+      case 117:
+         return jjMoveStringLiteralDfa3_0(active0, 0x800000005000000L, active1, 0L, active2, 0L);
+      case 119:
+         if ((active0 & 0x40000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 42, 144);
+         break;
+      case 121:
+         if ((active0 & 0x1000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(2, 60, 144);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(1, active0, active1, active2);
+}
+private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2){
+   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
+      return jjStartNfa_0(1, old0, old1, old2);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(2, active0, active1, active2);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 61:
+         if ((active2 & 0x80L) != 0L)
+            return jjStopAtPos(3, 135);
+         break;
+      case 97:
+         return jjMoveStringLiteralDfa4_0(active0, 0x40000000e0404000L, active1, 0L, active2, 0L);
+      case 98:
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L, active2, 0L);
+      case 99:
+         return jjMoveStringLiteralDfa4_0(active0, 0x40000000020000L, active1, 0L, active2, 0L);
+      case 100:
+         if ((active0 & 0x2000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 61, 144);
+         break;
+      case 101:
+         if ((active0 & 0x8000L) != 0L)
+            return jjStartNfaWithStates_0(3, 15, 144);
+         else if ((active0 & 0x10000L) != 0L)
+            return jjStartNfaWithStates_0(3, 16, 144);
+         else if ((active0 & 0x2000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 25, 144);
+         else if ((active0 & 0x800000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 59, 144);
+         return jjMoveStringLiteralDfa4_0(active0, 0x10008008001000L, active1, 0L, active2, 0L);
+      case 103:
+         if ((active0 & 0x10000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 40, 144);
+         break;
+      case 104:
+         if ((active1 & 0x4L) != 0L)
+            return jjStartNfaWithStates_0(3, 66, 144);
+         break;
+      case 105:
+         return jjMoveStringLiteralDfa4_0(active0, 0x8020000000000L, active1, 0L, active2, 0L);
+      case 107:
+         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L, active2, 0L);
+      case 108:
+         if ((active0 & 0x80000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 43, 144);
+         return jjMoveStringLiteralDfa4_0(active0, 0x8000800800002000L, active1, 0L, active2, 0L);
+      case 109:
+         if ((active0 & 0x4000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 26, 144);
+         break;
+      case 110:
+         if ((active1 & 0x8L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 3;
+         }
+         return jjMoveStringLiteralDfa4_0(active0, 0x400000000000000L, active1, 0x210L, active2, 0L);
+      case 111:
+         if ((active0 & 0x200000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 33, 144);
+         return jjMoveStringLiteralDfa4_0(active0, 0x300001000000000L, active1, 0x80L, active2, 0L);
+      case 114:
+         if ((active0 & 0x40000L) != 0L)
+            return jjStartNfaWithStates_0(3, 18, 144);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L, active2, 0L);
+      case 115:
+         if ((active0 & 0x80000000000000L) != 0L)
+            return jjStartNfaWithStates_0(3, 55, 144);
+         else if ((active1 & 0x20L) != 0L)
+            return jjStartNfaWithStates_0(3, 69, 144);
+         return jjMoveStringLiteralDfa4_0(active0, 0x10180000L, active1, 0L, active2, 0L);
+      case 116:
+         return jjMoveStringLiteralDfa4_0(active0, 0x24402000200800L, active1, 0L, active2, 0L);
+      case 117:
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x41L, active2, 0L);
+      case 118:
+         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x100L, active2, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(2, active0, active1, active2);
+}
+private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2){
+   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
+      return jjStartNfa_0(2, old0, old1, old2);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(3, active0, active1, 0L);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0L);
+      case 99:
+         return jjMoveStringLiteralDfa5_0(active0, 0x28000000000000L, active1, 0L);
+      case 101:
+         if ((active0 & 0x10000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 28, 144);
+         else if ((active0 & 0x8000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 63, 144);
+         return jjMoveStringLiteralDfa5_0(active0, 0x400800002000L, active1, 0L);
+      case 104:
+         if ((active0 & 0x20000L) != 0L)
+            return jjStartNfaWithStates_0(4, 17, 144);
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0L);
+      case 105:
+         return jjMoveStringLiteralDfa5_0(active0, 0x4800000200000L, active1, 0x101L);
+      case 107:
+         if ((active0 & 0x4000L) != 0L)
+            return jjStartNfaWithStates_0(4, 14, 144);
+         break;
+      case 108:
+         if ((active0 & 0x20000000L) != 0L)
+         {
+            jjmatchedKind = 29;
+            jjmatchedPos = 4;
+         }
+         return jjMoveStringLiteralDfa5_0(active0, 0x41000000L, active1, 0x40L);
+      case 110:
+         return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L);
+      case 114:
+         if ((active0 & 0x10000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 52, 144);
+         return jjMoveStringLiteralDfa5_0(active0, 0x1009000001800L, active1, 0x80L);
+      case 115:
+         if ((active0 & 0x80000L) != 0L)
+            return jjStartNfaWithStates_0(4, 19, 144);
+         else if ((active1 & 0x10L) != 0L)
+            return jjStartNfaWithStates_0(4, 68, 144);
+         return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0x200L);
+      case 116:
+         if ((active0 & 0x100000L) != 0L)
+            return jjStartNfaWithStates_0(4, 20, 144);
+         else if ((active0 & 0x80000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 31, 144);
+         else if ((active0 & 0x2000000000000L) != 0L)
+            return jjStartNfaWithStates_0(4, 49, 144);
+         return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000000L, active1, 0L);
+      case 117:
+         return jjMoveStringLiteralDfa5_0(active0, 0x400000L, active1, 0L);
+      case 118:
+         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L);
+      case 119:
+         if ((active0 & 0x100000000000000L) != 0L)
+         {
+            jjmatchedKind = 56;
+            jjmatchedPos = 4;
+         }
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(3, active0, active1, 0L);
+}
+private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1){
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(3, old0, old1, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(4, active0, active1, 0L);
+      return 5;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa6_0(active0, 0x2800L, active1, 0L);
+      case 99:
+         if ((active0 & 0x800000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 47, 144);
+         else if ((active0 & 0x4000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 50, 144);
+         return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
+      case 100:
+         return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0x100L);
+      case 101:
+         if ((active0 & 0x1000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 24, 144);
+         else if ((active0 & 0x20000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 41, 144);
+         else if ((active1 & 0x40L) != 0L)
+            return jjStartNfaWithStates_0(5, 70, 144);
+         break;
+      case 102:
+         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
+      case 103:
+         return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L);
+      case 104:
+         if ((active0 & 0x20000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 53, 144);
+         break;
+      case 105:
+         return jjMoveStringLiteralDfa6_0(active0, 0x4400000000000000L, active1, 0x200L);
+      case 108:
+         return jjMoveStringLiteralDfa6_0(active0, 0x40400000L, active1, 0L);
+      case 109:
+         return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L);
+      case 110:
+         if ((active0 & 0x1000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 48, 144);
+         return jjMoveStringLiteralDfa6_0(active0, 0x2000200000L, active1, 0L);
+      case 114:
+         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000000L, active1, 0x1L);
+      case 115:
+         if ((active0 & 0x200000000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 57, 144);
+         break;
+      case 116:
+         if ((active0 & 0x1000L) != 0L)
+            return jjStartNfaWithStates_0(5, 12, 144);
+         else if ((active0 & 0x1000000000L) != 0L)
+            return jjStartNfaWithStates_0(5, 36, 144);
+         return jjMoveStringLiteralDfa6_0(active0, 0x8200000000000L, active1, 0x80L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(4, active0, active1, 0L);
+}
+private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1){
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(4, old0, old1, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(5, active0, active1, 0L);
+      return 6;
+   }
+   switch(curChar)
+   {
+      case 97:
+         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0L);
+      case 99:
+         return jjMoveStringLiteralDfa7_0(active0, 0x2000000800L, active1, 0L);
+      case 101:
+         if ((active0 & 0x100000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 44, 144);
+         else if ((active0 & 0x200000000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 45, 144);
+         return jjMoveStringLiteralDfa7_0(active0, 0x400000800000000L, active1, 0x101L);
+      case 102:
+         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0L);
+      case 108:
+         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L, active1, 0L);
+      case 110:
+         if ((active0 & 0x2000L) != 0L)
+            return jjStartNfaWithStates_0(6, 13, 144);
+         break;
+      case 111:
+         return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000L, active1, 0L);
+      case 115:
+         if ((active0 & 0x8000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 27, 144);
+         else if ((active1 & 0x80L) != 0L)
+            return jjStartNfaWithStates_0(6, 71, 144);
+         break;
+      case 116:
+         if ((active0 & 0x400000L) != 0L)
+            return jjStartNfaWithStates_0(6, 22, 144);
+         return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x200L);
+      case 117:
+         return jjMoveStringLiteralDfa7_0(active0, 0x200000L, active1, 0L);
+      case 121:
+         if ((active0 & 0x40000000L) != 0L)
+            return jjStartNfaWithStates_0(6, 30, 144);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(5, active0, active1, 0L);
+}
+private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1){
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(5, old0, old1, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(6, active0, active1, 0L);
+      return 7;
+   }
+   switch(curChar)
+   {
+      case 99:
+         return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0L);
+      case 101:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStartNfaWithStates_0(7, 21, 144);
+         else if ((active0 & 0x4000000000000000L) != 0L)
+            return jjStartNfaWithStates_0(7, 62, 144);
+         return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L, active1, 0L);
+      case 105:
+         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x200L);
+      case 110:
+         return jjMoveStringLiteralDfa8_0(active0, 0x440000800000000L, active1, 0L);
+      case 112:
+         if ((active0 & 0x8000000000000L) != 0L)
+            return jjStartNfaWithStates_0(7, 51, 144);
+         break;
+      case 115:
+         if ((active1 & 0x1L) != 0L)
+            return jjStartNfaWithStates_0(7, 64, 144);
+         else if ((active1 & 0x100L) != 0L)
+            return jjStartNfaWithStates_0(7, 72, 144);
+         break;
+      case 116:
+         if ((active0 & 0x800L) != 0L)
+            return jjStartNfaWithStates_0(7, 11, 144);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(6, active0, active1, 0L);
+}
+private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1){
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(6, old0, old1, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(7, active0, active1, 0L);
+      return 8;
+   }
+   switch(curChar)
+   {
+      case 100:
+         if ((active0 & 0x400000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 46, 144);
+         break;
+      case 101:
+         if ((active0 & 0x8000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 39, 144);
+         break;
+      case 105:
+         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0L);
+      case 111:
+         return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L, active1, 0L);
+      case 116:
+         if ((active0 & 0x400000000000000L) != 0L)
+            return jjStartNfaWithStates_0(8, 58, 144);
+         return jjMoveStringLiteralDfa9_0(active0, 0x800000000L, active1, 0L);
+      case 118:
+         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x200L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(7, active0, active1, 0L);
+}
+private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1){
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(7, old0, old1, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(8, active0, active1, 0L);
+      return 9;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active1 & 0x200L) != 0L)
+            return jjStartNfaWithStates_0(9, 73, 144);
+         break;
+      case 102:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStartNfaWithStates_0(9, 37, 144);
+         break;
+      case 115:
+         if ((active0 & 0x800000000L) != 0L)
+            return jjStartNfaWithStates_0(9, 35, 144);
+         break;
+      case 122:
+         return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L, active1, 0L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(8, active0, active1, 0L);
+}
+private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1){
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_0(8, old0, old1, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(9, active0, 0L, 0L);
+      return 10;
+   }
+   switch(curChar)
+   {
+      case 101:
+         return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(9, active0, 0L, 0L);
+}
+private int jjMoveStringLiteralDfa11_0(long old0, long active0){
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(9, old0, 0L, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(10, active0, 0L, 0L);
+      return 11;
+   }
+   switch(curChar)
+   {
+      case 100:
+         if ((active0 & 0x40000000000000L) != 0L)
+            return jjStartNfaWithStates_0(11, 54, 144);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(10, active0, 0L, 0L);
+}
+private int jjStartNfaWithStates_0(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_0(state, pos + 1);
+}
+static final long[] jjbitVec0 = {
+   0x0L, 0x0L, 0x100000020L, 0x0L
+};
+static final long[] jjbitVec1 = {
+   0x0L, 0x0L, 0x1L, 0x0L
+};
+static final long[] jjbitVec2 = {
+   0x4000L, 0x0L, 0x0L, 0x0L
+};
+static final long[] jjbitVec3 = {
+   0x830000003fffL, 0x180000000L, 0x0L, 0x0L
+};
+static final long[] jjbitVec4 = {
+   0x1L, 0x0L, 0x0L, 0x0L
+};
+static final long[] jjbitVec5 = {
+   0x0L, 0x0L, 0x0L, 0x8000000000000000L
+};
+static final long[] jjbitVec6 = {
+   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+static final long[] jjbitVec8 = {
+   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+static final long[] jjbitVec9 = {
+   0xfff0000040220002L, 0xffffffffffffdfffL, 0xfffff02f7fffffffL, 0x12000000ff7fffffL
+};
+static final long[] jjbitVec10 = {
+   0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
+};
+static final long[] jjbitVec11 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x501f0003ffc3L
+};
+static final long[] jjbitVec12 = {
+   0x0L, 0x3cdf000000000000L, 0xfffffffbffffd740L, 0xffbfffffffffffffL
+};
+static final long[] jjbitVec13 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffc03L, 0xffffffffffffffffL
+};
+static final long[] jjbitVec14 = {
+   0xfffe00ffffffffffL, 0xfffffffe027fffffL, 0x80ffL, 0x707ffffff0000L
+};
+static final long[] jjbitVec15 = {
+   0xffffffff00000800L, 0xfffec000000007ffL, 0xffffffffffffffffL, 0x9c00c060002fffffL
+};
+static final long[] jjbitVec16 = {
+   0xfffffffd0000L, 0xffffffffffffe000L, 0x2003fffffffffL, 0x43007fffffffc00L
+};
+static final long[] jjbitVec17 = {
+   0x110043fffffL, 0x1ffffffL, 0x1ffd00000000L, 0x0L
+};
+static final long[] jjbitVec18 = {
+   0x23fffffffffffff0L, 0xfefe0003ff010000L, 0x23c5fdfffff99fe0L, 0x80f0003b0004000L
+};
+static final long[] jjbitVec19 = {
+   0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbbfe0L, 0x2000300010000L
+};
+static final long[] jjbitVec20 = {
+   0x23edfdfffff99fe0L, 0x20003b0000000L, 0x3ffc718d63dc7e8L, 0x200000000010000L
+};
+static final long[] jjbitVec21 = {
+   0x23effdfffffddfe0L, 0x303000000L, 0x23effdfffffddfe0L, 0x6000340000000L
+};
+static final long[] jjbitVec22 = {
+   0x27fffffffffddfe0L, 0xfc00000300004000L, 0x2ffbfffffc7fffe0L, 0x7fL
+};
+static final long[] jjbitVec23 = {
+   0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0xf000005fL
+};
+static final long[] jjbitVec24 = {
+   0x1L, 0x1ffffffffeffL, 0x1f00L, 0x0L
+};
+static final long[] jjbitVec25 = {
+   0x800007ffffffffffL, 0xffe1c0623c3f0000L, 0xffffffff00004003L, 0xf7ffffffffff20bfL
+};
+static final long[] jjbitVec26 = {
+   0xffffffffffffffffL, 0xffffffff3d7f3dffL, 0x7f3dffffffff3dffL, 0xffffffffff7fff3dL
+};
+static final long[] jjbitVec27 = {
+   0xffffffffff3dffffL, 0x7ffffffL, 0xffffffff0000ffffL, 0x1fffffffffffffL
+};
+static final long[] jjbitVec28 = {
+   0xffffffffffffffffL, 0xffff9fffffffffffL, 0xffffffff07fffffeL, 0x1c7ffffffffffL
+};
+static final long[] jjbitVec29 = {
+   0x3ffff0003dfffL, 0x1dfff0003ffffL, 0xfffffffffffffL, 0x18800000L
+};
+static final long[] jjbitVec30 = {
+   0xffffffff00000000L, 0xffffffffffffffL, 0xffff05ffffffffffL, 0x3fffffffffffffL
+};
+static final long[] jjbitVec31 = {
+   0x1fffffffL, 0x1f3fffffff0000L, 0xfffffffffffL, 0xfeL
+};
+static final long[] jjbitVec32 = {
+   0xffffffff007fffffL, 0x1fffffL, 0x8000000000L, 0x0L
+};
+static final long[] jjbitVec33 = {
+   0xfffffffffffe0L, 0xfe0L, 0xfc00c001fffffff8L, 0x3fffffffffL
+};
+static final long[] jjbitVec34 = {
+   0xfffffffffL, 0x3ffffffffc00e000L, 0x0L, 0x63de0000000000L
+};
+static final long[] jjbitVec35 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L
+};
+static final long[] jjbitVec36 = {
+   0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
+};
+static final long[] jjbitVec37 = {
+   0x8000000000000000L, 0x8002000000100001L, 0x7ffffff1fff0000L, 0x0L
+};
+static final long[] jjbitVec38 = {
+   0xf3ffbd503e2ffc84L, 0xffffffff000043e0L, 0x1ffL, 0x0L
+};
+static final long[] jjbitVec39 = {
+   0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xc781fffffffffL
+};
+static final long[] jjbitVec40 = {
+   0xffff20bfffffffffL, 0x80ffffffffffL, 0x7f7f7f7f007fffffL, 0x7f7f7f7fL
+};
+static final long[] jjbitVec41 = {
+   0x800000000000L, 0x0L, 0x0L, 0x0L
+};
+static final long[] jjbitVec42 = {
+   0x1f3e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffee07fffffL, 0xf7ffffffffffffffL
+};
+static final long[] jjbitVec43 = {
+   0xfffe3fffffffffe0L, 0xffffffffffffffffL, 0x7ffffff00007fffL, 0xffff000000000000L
+};
+static final long[] jjbitVec44 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
+};
+static final long[] jjbitVec45 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL
+};
+static final long[] jjbitVec46 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x3fffffffffff0000L
+};
+static final long[] jjbitVec47 = {
+   0xc00ffff1fffL, 0x80007fffffffffffL, 0xffffffff00ffffffL, 0xffffffffffffL
+};
+static final long[] jjbitVec48 = {
+   0xfffffffcff800000L, 0xffffffffffffffffL, 0x7ff000f79ffL, 0xff00000000000000L
+};
+static final long[] jjbitVec49 = {
+   0x1000007fffff7bbL, 0xfffffffffffffL, 0xffffffffffffcL, 0x8fc000000000000L
+};
+static final long[] jjbitVec50 = {
+   0xffff003ffffffc00L, 0x1fffffff0000007fL, 0x7fffffffffff0L, 0x8000L
+};
+static final long[] jjbitVec51 = {
+   0x1ffffffffffL, 0x47fffff00000ff7L, 0x3e62ffffffffffffL, 0x1c07ff38000005L
+};
+static final long[] jjbitVec52 = {
+   0x7f7f007e7e7eL, 0x0L, 0x0L, 0x7ffffffffL
+};
+static final long[] jjbitVec53 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffff000fffffffffL, 0xffffffffffff87fL
+};
+static final long[] jjbitVec54 = {
+   0xffffffffffffffffL, 0xffff3fffffffffffL, 0xffffffffffffffffL, 0x3ffffffL
+};
+static final long[] jjbitVec55 = {
+   0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
+};
+static final long[] jjbitVec56 = {
+   0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0x1fff0000000000ffL
+};
+static final long[] jjbitVec57 = {
+   0x18000000000000L, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
+};
+static final long[] jjbitVec58 = {
+   0x87fffffe00000010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
+};
+static final long[] jjbitVec59 = {
+   0x0L, 0x0L, 0x420243cffffffffL, 0xff7fffffff7fffffL
+};
+static final long[] jjbitVec60 = {
+   0xffffffffffffffffL, 0x3cdfffffffffffffL, 0xfffffffbffffd740L, 0xffbfffffffffffffL
+};
+static final long[] jjbitVec61 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffcfbL, 0xffffffffffffffffL
+};
+static final long[] jjbitVec62 = {
+   0xfffe00ffffffffffL, 0xfffffffe027fffffL, 0xbffffffffffe80ffL, 0x707ffffff00b6L
+};
+static final long[] jjbitVec63 = {
+   0xffffffff07ff081fL, 0xffffc3ffffffffffL, 0xffffffffffffffffL, 0x9ffffdffbfefffffL
+};
+static final long[] jjbitVec64 = {
+   0xffffffffffff8000L, 0xffffffffffffe7ffL, 0x3ffffffffffffL, 0x43fffffffffffffL
+};
+static final long[] jjbitVec65 = {
+   0x3fffffffffffL, 0xfffffffL, 0x1ffd00000000L, 0x7ffffff000000000L
+};
+static final long[] jjbitVec66 = {
+   0xffffffffffffffffL, 0xfefeffcfffffffffL, 0xf3c5fdfffff99feeL, 0x80fffcfb080799fL
+};
+static final long[] jjbitVec67 = {
+   0xd36dfdfffff987eeL, 0x3fffc05e023987L, 0xf3edfdfffffbbfeeL, 0x2ffcf00013bbfL
+};
+static final long[] jjbitVec68 = {
+   0xf3edfdfffff99feeL, 0x2ffcfb0c0399fL, 0xc3ffc718d63dc7ecL, 0x200ffc000813dc7L
+};
+static final long[] jjbitVec69 = {
+   0xe3effdfffffddfeeL, 0xffcf03603ddfL, 0xf3effdfffffddfecL, 0x6ffcf40603ddfL
+};
+static final long[] jjbitVec70 = {
+   0xe7fffffffffddfecL, 0xfc00ffcf00807ddfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
+};
+static final long[] jjbitVec71 = {
+   0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0xf3ff3f5fL
+};
+static final long[] jjbitVec72 = {
+   0xc2a003ff03000001L, 0xfffe1ffffffffeffL, 0x1ffffffffeffffdfL, 0x40L
+};
+static final long[] jjbitVec73 = {
+   0xffffffffffffffffL, 0xffffffffffff03ffL, 0xffffffff3fffffffL, 0xf7ffffffffff20bfL
+};
+static final long[] jjbitVec74 = {
+   0xffffffffff3dffffL, 0xe7ffffffL, 0xffffffff0000ffffL, 0x1fffffffffffffL
+};
+static final long[] jjbitVec75 = {
+   0x1fffff001fdfffL, 0xddfff000fffffL, 0xffffffffffffffffL, 0x3ff388fffffL
+};
+static final long[] jjbitVec76 = {
+   0xffffffff03ff3800L, 0xffffffffffffffL, 0xffff07ffffffffffL, 0x3fffffffffffffL
+};
+static final long[] jjbitVec77 = {
+   0xfff0fff1fffffffL, 0x1f3fffffffffc0L, 0xffff0fffffffffffL, 0x3ff03ffL
+};
+static final long[] jjbitVec78 = {
+   0xffffffff0fffffffL, 0x9fffffff7fffffffL, 0x8003ff03ffL, 0x0L
+};
+static final long[] jjbitVec79 = {
+   0xffffffffffffffffL, 0xff80003ff0fffL, 0xffffffffffffffffL, 0xfffffffffffffL
+};
+static final long[] jjbitVec80 = {
+   0xffffffffffffffL, 0x3fffffffffffe3ffL, 0x0L, 0x7ffffffff70000L
+};
+static final long[] jjbitVec81 = {
+   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xf000007fffffffffL
+};
+static final long[] jjbitVec82 = {
+   0x80007c000000f800L, 0x8002fc1f00100001L, 0x7ffffff1fff0000L, 0x1ffe21fff0000L
+};
+static final long[] jjbitVec83 = {
+   0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xff81fffffffffL
+};
+static final long[] jjbitVec84 = {
+   0xffff20bfffffffffL, 0x800080ffffffffffL, 0x7f7f7f7f007fffffL, 0xffffffff7f7f7f7fL
+};
+static final long[] jjbitVec85 = {
+   0x1f3efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffee67fffffL, 0xf7ffffffffffffffL
+};
+static final long[] jjbitVec86 = {
+   0xfffffff1fffL, 0xbff0ffffffffffffL, 0xffffffff80ffffffL, 0x3ffffffffffffL
+};
+static final long[] jjbitVec87 = {
+   0x10000ffffffffffL, 0xfffffffffffffL, 0xffffffffffffffffL, 0x8ffffff03ff001fL
+};
+static final long[] jjbitVec88 = {
+   0xffff3fffffffffffL, 0x1fffffff000fffffL, 0xffffffffffffffffL, 0x3ff8001L
+};
+static final long[] jjbitVec89 = {
+   0x7fffffffffffffL, 0xc7fffff03ff3fffL, 0xffffffffffffffffL, 0x7cffff38000007L
+};
+static final long[] jjbitVec90 = {
+   0x7f7f007e7e7eL, 0x0L, 0x0L, 0x3ff37ffffffffffL
+};
+static final long[] jjbitVec91 = {
+   0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
+};
+static final long[] jjbitVec92 = {
+   0x18007f0000ffffL, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
+};
+static final long[] jjbitVec93 = {
+   0x87fffffe03ff0010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
+};
+private int jjMoveNfa_0(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 144;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 144:
+               case 43:
+                  if ((0x3ff00100fffc1ffL & l) == 0L)
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 56:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 61;
+                  else if (curChar == 47)
+                  {
+                     if (kind > 5)
+                        kind = 5;
+                     { jjCheckNAddStates(0, 2); }
+                  }
+                  break;
+               case 0:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 75)
+                        kind = 75;
+                     { jjCheckNAddStates(3, 17); }
+                  }
+                  else if ((0x100001200L & l) != 0L)
+                  {
+                     if (kind > 1)
+                        kind = 1;
+                  }
+                  else if (curChar == 47)
+                     { jjAddStates(18, 19); }
+                  else if (curChar == 36)
+                  {
+                     if (kind > 89)
+                        kind = 89;
+                     { jjCheckNAddTwoStates(43, 49); }
+                  }
+                  else if (curChar == 34)
+                     { jjCheckNAddStates(20, 23); }
+                  else if (curChar == 39)
+                     { jjAddStates(24, 26); }
+                  else if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  if (curChar == 48)
+                     { jjAddStates(27, 34); }
+                  break;
+               case 1:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 2:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(35, 38); }
+                  break;
+               case 3:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(3, 4); }
+                  break;
+               case 4:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddTwoStates(5, 10); }
+                  break;
+               case 6:
+                  if ((0x280000000000L & l) != 0L)
+                     { jjCheckNAdd(7); }
+                  break;
+               case 7:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(39, 41); }
+                  break;
+               case 8:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(8, 9); }
+                  break;
+               case 9:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddTwoStates(7, 10); }
+                  break;
+               case 11:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(42, 45); }
+                  break;
+               case 12:
+                  if (curChar == 39)
+                     { jjAddStates(24, 26); }
+                  break;
+               case 13:
+                  if ((0xffffff7fffffdbffL & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 14:
+                  if (curChar == 39 && kind > 87)
+                     kind = 87;
+                  break;
+               case 16:
+                  if ((0x8400000000L & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 17:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(18, 14); }
+                  break;
+               case 18:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 19:
+                  if ((0xf000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 20:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAdd(18); }
+                  break;
+               case 22:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 24:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 25;
+                  break;
+               case 25:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 27:
+                  if (curChar == 34)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 28:
+                  if ((0xfffffffbffffdbffL & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 30:
+                  if ((0x8400000000L & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 32:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 33;
+                  break;
+               case 33:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  break;
+               case 34:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 35;
+                  break;
+               case 35:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 37:
+                  if (curChar == 34 && kind > 88)
+                     kind = 88;
+                  break;
+               case 38:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(46, 50); }
+                  break;
+               case 39:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 40:
+                  if ((0xf000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  break;
+               case 41:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAdd(39); }
+                  break;
+               case 42:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 45:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 46;
+                  break;
+               case 46:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  break;
+               case 47:
+               case 53:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(48); }
+                  break;
+               case 48:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 51:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 52;
+                  break;
+               case 52:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 55:
+                  if (curChar == 47)
+                     { jjAddStates(18, 19); }
+                  break;
+               case 57:
+                  if ((0xffffffffffffdbffL & l) == 0L)
+                     break;
+                  if (kind > 5)
+                     kind = 5;
+                  { jjCheckNAddStates(0, 2); }
+                  break;
+               case 58:
+                  if ((0x2400L & l) != 0L && kind > 5)
+                     kind = 5;
+                  break;
+               case 59:
+                  if (curChar == 10 && kind > 5)
+                     kind = 5;
+                  break;
+               case 60:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 59;
+                  break;
+               case 61:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 62;
+                  break;
+               case 62:
+                  if ((0xffff7fffffffffffL & l) != 0L && kind > 6)
+                     kind = 6;
+                  break;
+               case 63:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 61;
+                  break;
+               case 64:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 75)
+                     kind = 75;
+                  { jjCheckNAddStates(3, 17); }
+                  break;
+               case 65:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(65, 66); }
+                  break;
+               case 66:
+               case 102:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(67); }
+                  break;
+               case 68:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(68, 69); }
+                  break;
+               case 69:
+               case 113:
+                  if ((0x3ff000000000000L & l) != 0L && kind > 75)
+                     kind = 75;
+                  break;
+               case 70:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(70, 71); }
+                  break;
+               case 71:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(72, 10); }
+                  break;
+               case 73:
+                  if ((0x280000000000L & l) != 0L)
+                     { jjCheckNAdd(74); }
+                  break;
+               case 74:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(51, 53); }
+                  break;
+               case 75:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(75, 76); }
+                  break;
+               case 76:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(74, 10); }
+                  break;
+               case 77:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(54, 57); }
+                  break;
+               case 78:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(78, 79); }
+                  break;
+               case 79:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(80); }
+                  break;
+               case 81:
+                  if ((0x280000000000L & l) != 0L)
+                     { jjCheckNAdd(82); }
+                  break;
+               case 82:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(58, 60); }
+                  break;
+               case 83:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(83, 84); }
+                  break;
+               case 84:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddTwoStates(82, 10); }
+                  break;
+               case 85:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(61, 64); }
+                  break;
+               case 86:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(86, 87); }
+                  break;
+               case 87:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(88); }
+                  break;
+               case 88:
+                  if (curChar != 46)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(65, 67); }
+                  break;
+               case 89:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(68, 71); }
+                  break;
+               case 90:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(90, 91); }
+                  break;
+               case 91:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddTwoStates(92, 10); }
+                  break;
+               case 93:
+                  if ((0x280000000000L & l) != 0L)
+                     { jjCheckNAdd(94); }
+                  break;
+               case 94:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(72, 74); }
+                  break;
+               case 95:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(95, 96); }
+                  break;
+               case 96:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddTwoStates(94, 10); }
+                  break;
+               case 97:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(75, 78); }
+                  break;
+               case 98:
+                  if (curChar == 48)
+                     { jjAddStates(27, 34); }
+                  break;
+               case 100:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(79, 81); }
+                  break;
+               case 101:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(101, 102); }
+                  break;
+               case 103:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(82, 84); }
+                  break;
+               case 104:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(104, 105); }
+                  break;
+               case 105:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAdd(67); }
+                  break;
+               case 107:
+                  if ((0x3000000000000L & l) != 0L)
+                     { jjCheckNAddStates(85, 87); }
+                  break;
+               case 108:
+                  if ((0x3000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(108, 109); }
+                  break;
+               case 109:
+                  if ((0x3000000000000L & l) != 0L)
+                     { jjCheckNAdd(67); }
+                  break;
+               case 111:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 75)
+                     kind = 75;
+                  { jjCheckNAddTwoStates(112, 113); }
+                  break;
+               case 112:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(112, 113); }
+                  break;
+               case 114:
+                  if ((0xff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 75)
+                     kind = 75;
+                  { jjCheckNAddTwoStates(115, 116); }
+                  break;
+               case 115:
+                  if ((0xff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(115, 116); }
+                  break;
+               case 116:
+                  if ((0xff000000000000L & l) != 0L && kind > 75)
+                     kind = 75;
+                  break;
+               case 118:
+                  if ((0x3000000000000L & l) == 0L)
+                     break;
+                  if (kind > 75)
+                     kind = 75;
+                  { jjCheckNAddTwoStates(119, 120); }
+                  break;
+               case 119:
+                  if ((0x3000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(119, 120); }
+                  break;
+               case 120:
+                  if ((0x3000000000000L & l) != 0L && kind > 75)
+                     kind = 75;
+                  break;
+               case 122:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(88, 90); }
+                  break;
+               case 123:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(123, 124); }
+                  break;
+               case 124:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(125); }
+                  break;
+               case 125:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 126;
+                  break;
+               case 126:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(91, 93); }
+                  break;
+               case 127:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(127, 128); }
+                  break;
+               case 128:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAdd(129); }
+                  break;
+               case 130:
+                  if ((0x280000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 131;
+                  break;
+               case 131:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(94, 96); }
+                  break;
+               case 132:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(132, 133); }
+                  break;
+               case 133:
+               case 143:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAdd(10); }
+                  break;
+               case 135:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddStates(97, 100); }
+                  break;
+               case 136:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(136, 137); }
+                  break;
+               case 137:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(138, 139); }
+                  break;
+               case 138:
+                  if (curChar == 46)
+                     { jjCheckNAdd(139); }
+                  break;
+               case 140:
+                  if ((0x280000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 141;
+                  break;
+               case 141:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 80)
+                     kind = 80;
+                  { jjCheckNAddStates(101, 103); }
+                  break;
+               case 142:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(142, 143); }
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 144:
+                  if ((0x87fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 89)
+                        kind = 89;
+                     { jjCheckNAddTwoStates(43, 49); }
+                  }
+                  else if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  break;
+               case 0:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 89)
+                        kind = 89;
+                     { jjCheckNAddTwoStates(43, 49); }
+                  }
+                  else if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 50;
+                  break;
+               case 3:
+                  if (curChar == 95)
+                     { jjAddStates(104, 105); }
+                  break;
+               case 5:
+                  if ((0x2000000020L & l) != 0L)
+                     { jjAddStates(106, 107); }
+                  break;
+               case 8:
+                  if (curChar == 95)
+                     { jjAddStates(108, 109); }
+                  break;
+               case 10:
+                  if ((0x5000000050L & l) != 0L && kind > 80)
+                     kind = 80;
+                  break;
+               case 13:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 15:
+                  if (curChar == 92)
+                     { jjAddStates(110, 112); }
+                  break;
+               case 16:
+                  if ((0x14404410000000L & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 21:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 24:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 25;
+                  break;
+               case 25:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAdd(14); }
+                  break;
+               case 26:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 28:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 29:
+                  if (curChar == 92)
+                     { jjAddStates(113, 115); }
+                  break;
+               case 30:
+                  if ((0x14404410000000L & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 31:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 32;
+                  break;
+               case 32:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 33;
+                  break;
+               case 33:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  break;
+               case 34:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 35;
+                  break;
+               case 35:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAddStates(20, 23); }
+                  break;
+               case 36:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 31;
+                  break;
+               case 42:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 43:
+                  if ((0x87fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 44:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 45;
+                  break;
+               case 45:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 46;
+                  break;
+               case 46:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  break;
+               case 47:
+               case 53:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAdd(48); }
+                  break;
+               case 48:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 49:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  break;
+               case 50:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  break;
+               case 51:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 52;
+                  break;
+               case 52:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 54:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 50;
+                  break;
+               case 57:
+                  if (kind > 5)
+                     kind = 5;
+                  { jjAddStates(0, 2); }
+                  break;
+               case 62:
+                  if (kind > 6)
+                     kind = 6;
+                  break;
+               case 65:
+                  if (curChar == 95)
+                     { jjAddStates(116, 117); }
+                  break;
+               case 67:
+                  if ((0x100000001000L & l) != 0L && kind > 74)
+                     kind = 74;
+                  break;
+               case 68:
+                  if (curChar == 95)
+                     { jjAddStates(118, 119); }
+                  break;
+               case 70:
+                  if (curChar == 95)
+                     { jjAddStates(120, 121); }
+                  break;
+               case 72:
+                  if ((0x2000000020L & l) != 0L)
+                     { jjAddStates(122, 123); }
+                  break;
+               case 75:
+                  if (curChar == 95)
+                     { jjAddStates(124, 125); }
+                  break;
+               case 78:
+                  if (curChar == 95)
+                     { jjAddStates(126, 127); }
+                  break;
+               case 80:
+                  if ((0x2000000020L & l) != 0L)
+                     { jjAddStates(128, 129); }
+                  break;
+               case 83:
+                  if (curChar == 95)
+                     { jjAddStates(130, 131); }
+                  break;
+               case 86:
+                  if (curChar == 95)
+                     { jjAddStates(132, 133); }
+                  break;
+               case 90:
+                  if (curChar == 95)
+                     { jjAddStates(134, 135); }
+                  break;
+               case 92:
+                  if ((0x2000000020L & l) != 0L)
+                     { jjAddStates(136, 137); }
+                  break;
+               case 95:
+                  if (curChar == 95)
+                     { jjAddStates(138, 139); }
+                  break;
+               case 99:
+                  if ((0x100000001000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 100;
+                  break;
+               case 100:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAddStates(79, 81); }
+                  break;
+               case 101:
+                  if ((0x7e8000007eL & l) != 0L)
+                     { jjCheckNAddTwoStates(101, 102); }
+                  break;
+               case 102:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAdd(67); }
+                  break;
+               case 104:
+                  if (curChar == 95)
+                     { jjAddStates(140, 141); }
+                  break;
+               case 106:
+                  if ((0x400000004L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 107;
+                  break;
+               case 108:
+                  if (curChar == 95)
+                     { jjAddStates(142, 143); }
+                  break;
+               case 110:
+                  if ((0x100000001000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 111;
+                  break;
+               case 111:
+                  if ((0x7e0000007eL & l) == 0L)
+                     break;
+                  if (kind > 75)
+                     kind = 75;
+                  { jjCheckNAddTwoStates(112, 113); }
+                  break;
+               case 112:
+                  if ((0x7e8000007eL & l) != 0L)
+                     { jjCheckNAddTwoStates(112, 113); }
+                  break;
+               case 113:
+                  if ((0x7e0000007eL & l) != 0L && kind > 75)
+                     kind = 75;
+                  break;
+               case 115:
+                  if (curChar == 95)
+                     { jjAddStates(144, 145); }
+                  break;
+               case 117:
+                  if ((0x400000004L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 118;
+                  break;
+               case 119:
+                  if (curChar == 95)
+                     { jjAddStates(146, 147); }
+                  break;
+               case 121:
+                  if ((0x100000001000000L & l) != 0L)
+                     { jjCheckNAddTwoStates(122, 125); }
+                  break;
+               case 122:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAddStates(88, 90); }
+                  break;
+               case 123:
+                  if ((0x7e8000007eL & l) != 0L)
+                     { jjCheckNAddTwoStates(123, 124); }
+                  break;
+               case 124:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAdd(125); }
+                  break;
+               case 126:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAddStates(91, 93); }
+                  break;
+               case 127:
+                  if ((0x7e8000007eL & l) != 0L)
+                     { jjCheckNAddTwoStates(127, 128); }
+                  break;
+               case 128:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAdd(129); }
+                  break;
+               case 129:
+                  if ((0x1000000010000L & l) != 0L)
+                     { jjAddStates(148, 149); }
+                  break;
+               case 132:
+                  if (curChar == 95)
+                     { jjAddStates(150, 151); }
+                  break;
+               case 134:
+                  if ((0x100000001000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 135;
+                  break;
+               case 135:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAddStates(97, 100); }
+                  break;
+               case 136:
+                  if ((0x7e8000007eL & l) != 0L)
+                     { jjCheckNAddTwoStates(136, 137); }
+                  break;
+               case 137:
+                  if ((0x7e0000007eL & l) != 0L)
+                     { jjCheckNAddTwoStates(138, 139); }
+                  break;
+               case 139:
+                  if ((0x1000000010000L & l) != 0L)
+                     { jjAddStates(152, 153); }
+                  break;
+               case 142:
+                  if (curChar == 95)
+                     { jjAddStates(154, 155); }
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 144:
+               case 43:
+                  if (!jjCanMove_3(hiByte, i1, i2, l1, l2))
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 0:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                  {
+                     if (kind > 1)
+                        kind = 1;
+                  }
+                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
+                  {
+                     if (kind > 89)
+                        kind = 89;
+                     { jjCheckNAddTwoStates(43, 49); }
+                  }
+                  break;
+               case 13:
+                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
+                     jjstateSet[jjnewStateCnt++] = 14;
+                  break;
+               case 28:
+                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
+                     { jjAddStates(20, 23); }
+                  break;
+               case 42:
+                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
+                     break;
+                  if (kind > 89)
+                     kind = 89;
+                  { jjCheckNAddTwoStates(43, 49); }
+                  break;
+               case 57:
+                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
+                     break;
+                  if (kind > 5)
+                     kind = 5;
+                  { jjAddStates(0, 2); }
+                  break;
+               case 62:
+                  if (jjCanMove_1(hiByte, i1, i2, l1, l2) && kind > 6)
+                     kind = 6;
+                  break;
+               default : if (i1 == 0 || l1 == 0 || i2 == 0 ||  l2 == 0) break; else break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 144 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private int jjMoveStringLiteralDfa0_2(){
+   switch(curChar)
+   {
+      case 42:
+         return jjMoveStringLiteralDfa1_2(0x200L);
+      default :
+         return 1;
+   }
+}
+private int jjMoveStringLiteralDfa1_2(long active0){
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 47:
+         if ((active0 & 0x200L) != 0L)
+            return jjStopAtPos(1, 9);
+         break;
+      default :
+         return 2;
+   }
+   return 2;
+}
+private int jjMoveStringLiteralDfa0_1(){
+   switch(curChar)
+   {
+      case 42:
+         return jjMoveStringLiteralDfa1_1(0x100L);
+      default :
+         return 1;
+   }
+}
+private int jjMoveStringLiteralDfa1_1(long active0){
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 47:
+         if ((active0 & 0x100L) != 0L)
+            return jjStopAtPos(1, 8);
+         break;
+      default :
+         return 2;
+   }
+   return 2;
+}
+
+/** Token literal values. */
+public static final String[] jjstrLiteralImages = {
+"", null, null, null, null, null, null, null, null, null, null, 
+"\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156", 
+"\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", 
+"\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164", 
+"\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", 
+"\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145", 
+"\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", 
+"\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163", 
+"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", 
+"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167", 
+"\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", 
+"\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", 
+"\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", 
+"\163\165\160\145\162", "\163\167\151\164\143\150", 
+"\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163", 
+"\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144", 
+"\166\157\154\141\164\151\154\145", "\167\150\151\154\145", "\162\145\161\165\151\162\145\163", "\164\157", 
+"\167\151\164\150", "\157\160\145\156", "\157\160\145\156\163", "\165\163\145\163", 
+"\155\157\144\165\154\145", "\145\170\160\157\162\164\163", "\160\162\157\166\151\144\145\163", 
+"\164\162\141\156\163\151\164\151\166\145", null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", 
+"\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 
+"\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 
+"\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", 
+"\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", 
+"\76\76\76\75", "\56\56\56", "\55\76", "\72\72", "\76\76\76", "\76\76", "\76", "\32", };
+protected Token jjFillToken()
+{
+   final Token t;
+   final String curTokenImage;
+   final int beginLine;
+   final int endLine;
+   final int beginColumn;
+   final int endColumn;
+   String im = jjstrLiteralImages[jjmatchedKind];
+   curTokenImage = (im == null) ? input_stream.GetImage() : im;
+   beginLine = input_stream.getBeginLine();
+   beginColumn = input_stream.getBeginColumn();
+   endLine = input_stream.getEndLine();
+   endColumn = input_stream.getEndColumn();
+   t = Token.newToken(jjmatchedKind);
+   t.kind = jjmatchedKind;
+   t.image = curTokenImage;
+
+   t.beginLine = beginLine;
+   t.endLine = endLine;
+   t.beginColumn = beginColumn;
+   t.endColumn = endColumn;
+
+   return t;
+}
+static final int[] jjnextStates = {
+   57, 58, 60, 65, 66, 67, 68, 69, 70, 71, 72, 10, 78, 79, 80, 86, 
+   87, 88, 56, 63, 28, 29, 36, 37, 13, 15, 26, 99, 103, 106, 110, 114, 
+   117, 121, 134, 3, 4, 5, 10, 8, 10, 11, 7, 8, 10, 11, 28, 29, 
+   39, 36, 37, 75, 10, 77, 74, 75, 10, 77, 83, 10, 85, 82, 83, 10, 
+   85, 89, 92, 10, 90, 91, 92, 10, 95, 10, 97, 94, 95, 10, 97, 101, 
+   102, 67, 104, 105, 67, 108, 109, 67, 123, 124, 125, 127, 128, 129, 132, 133, 
+   10, 136, 137, 138, 139, 142, 143, 10, 3, 4, 6, 7, 8, 9, 16, 17, 
+   19, 30, 38, 40, 65, 66, 68, 69, 70, 71, 73, 74, 75, 76, 78, 79, 
+   81, 82, 83, 84, 86, 87, 90, 91, 93, 94, 95, 96, 104, 105, 108, 109, 
+   115, 116, 119, 120, 130, 131, 132, 133, 140, 141, 142, 143, 
+};
+private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
+{
+   switch(hiByte)
+   {
+      case 0:
+         return ((jjbitVec0[i2] & l2) != 0L);
+      case 22:
+         return ((jjbitVec1[i2] & l2) != 0L);
+      case 24:
+         return ((jjbitVec2[i2] & l2) != 0L);
+      case 32:
+         return ((jjbitVec3[i2] & l2) != 0L);
+      case 48:
+         return ((jjbitVec4[i2] & l2) != 0L);
+      case 254:
+         return ((jjbitVec5[i2] & l2) != 0L);
+      default :
+         return false;
+   }
+}
+private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
+{
+   switch(hiByte)
+   {
+      case 0:
+         return ((jjbitVec8[i2] & l2) != 0L);
+      default :
+         if ((jjbitVec6[i1] & l1) != 0L)
+            return true;
+         return false;
+   }
+}
+private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
+{
+   switch(hiByte)
+   {
+      case 0:
+         return ((jjbitVec10[i2] & l2) != 0L);
+      case 2:
+         return ((jjbitVec11[i2] & l2) != 0L);
+      case 3:
+         return ((jjbitVec12[i2] & l2) != 0L);
+      case 4:
+         return ((jjbitVec13[i2] & l2) != 0L);
+      case 5:
+         return ((jjbitVec14[i2] & l2) != 0L);
+      case 6:
+         return ((jjbitVec15[i2] & l2) != 0L);
+      case 7:
+         return ((jjbitVec16[i2] & l2) != 0L);
+      case 8:
+         return ((jjbitVec17[i2] & l2) != 0L);
+      case 9:
+         return ((jjbitVec18[i2] & l2) != 0L);
+      case 10:
+         return ((jjbitVec19[i2] & l2) != 0L);
+      case 11:
+         return ((jjbitVec20[i2] & l2) != 0L);
+      case 12:
+         return ((jjbitVec21[i2] & l2) != 0L);
+      case 13:
+         return ((jjbitVec22[i2] & l2) != 0L);
+      case 14:
+         return ((jjbitVec23[i2] & l2) != 0L);
+      case 15:
+         return ((jjbitVec24[i2] & l2) != 0L);
+      case 16:
+         return ((jjbitVec25[i2] & l2) != 0L);
+      case 18:
+         return ((jjbitVec26[i2] & l2) != 0L);
+      case 19:
+         return ((jjbitVec27[i2] & l2) != 0L);
+      case 20:
+         return ((jjbitVec6[i2] & l2) != 0L);
+      case 22:
+         return ((jjbitVec28[i2] & l2) != 0L);
+      case 23:
+         return ((jjbitVec29[i2] & l2) != 0L);
+      case 24:
+         return ((jjbitVec30[i2] & l2) != 0L);
+      case 25:
+         return ((jjbitVec31[i2] & l2) != 0L);
+      case 26:
+         return ((jjbitVec32[i2] & l2) != 0L);
+      case 27:
+         return ((jjbitVec33[i2] & l2) != 0L);
+      case 28:
+         return ((jjbitVec34[i2] & l2) != 0L);
+      case 29:
+         return ((jjbitVec35[i2] & l2) != 0L);
+      case 31:
+         return ((jjbitVec36[i2] & l2) != 0L);
+      case 32:
+         return ((jjbitVec37[i2] & l2) != 0L);
+      case 33:
+         return ((jjbitVec38[i2] & l2) != 0L);
+      case 44:
+         return ((jjbitVec39[i2] & l2) != 0L);
+      case 45:
+         return ((jjbitVec40[i2] & l2) != 0L);
+      case 46:
+         return ((jjbitVec41[i2] & l2) != 0L);
+      case 48:
+         return ((jjbitVec42[i2] & l2) != 0L);
+      case 49:
+         return ((jjbitVec43[i2] & l2) != 0L);
+      case 77:
+         return ((jjbitVec44[i2] & l2) != 0L);
+      case 159:
+         return ((jjbitVec45[i2] & l2) != 0L);
+      case 164:
+         return ((jjbitVec46[i2] & l2) != 0L);
+      case 166:
+         return ((jjbitVec47[i2] & l2) != 0L);
+      case 167:
+         return ((jjbitVec48[i2] & l2) != 0L);
+      case 168:
+         return ((jjbitVec49[i2] & l2) != 0L);
+      case 169:
+         return ((jjbitVec50[i2] & l2) != 0L);
+      case 170:
+         return ((jjbitVec51[i2] & l2) != 0L);
+      case 171:
+         return ((jjbitVec52[i2] & l2) != 0L);
+      case 215:
+         return ((jjbitVec53[i2] & l2) != 0L);
+      case 250:
+         return ((jjbitVec54[i2] & l2) != 0L);
+      case 251:
+         return ((jjbitVec55[i2] & l2) != 0L);
+      case 253:
+         return ((jjbitVec56[i2] & l2) != 0L);
+      case 254:
+         return ((jjbitVec57[i2] & l2) != 0L);
+      case 255:
+         return ((jjbitVec58[i2] & l2) != 0L);
+      default :
+         if ((jjbitVec9[i1] & l1) != 0L)
+            return true;
+         return false;
+   }
+}
+private static final boolean jjCanMove_3(int hiByte, int i1, int i2, long l1, long l2)
+{
+   switch(hiByte)
+   {
+      case 0:
+         return ((jjbitVec59[i2] & l2) != 0L);
+      case 2:
+         return ((jjbitVec11[i2] & l2) != 0L);
+      case 3:
+         return ((jjbitVec60[i2] & l2) != 0L);
+      case 4:
+         return ((jjbitVec61[i2] & l2) != 0L);
+      case 5:
+         return ((jjbitVec62[i2] & l2) != 0L);
+      case 6:
+         return ((jjbitVec63[i2] & l2) != 0L);
+      case 7:
+         return ((jjbitVec64[i2] & l2) != 0L);
+      case 8:
+         return ((jjbitVec65[i2] & l2) != 0L);
+      case 9:
+         return ((jjbitVec66[i2] & l2) != 0L);
+      case 10:
+         return ((jjbitVec67[i2] & l2) != 0L);
+      case 11:
+         return ((jjbitVec68[i2] & l2) != 0L);
+      case 12:
+         return ((jjbitVec69[i2] & l2) != 0L);
+      case 13:
+         return ((jjbitVec70[i2] & l2) != 0L);
+      case 14:
+         return ((jjbitVec71[i2] & l2) != 0L);
+      case 15:
+         return ((jjbitVec72[i2] & l2) != 0L);
+      case 16:
+         return ((jjbitVec73[i2] & l2) != 0L);
+      case 18:
+         return ((jjbitVec26[i2] & l2) != 0L);
+      case 19:
+         return ((jjbitVec74[i2] & l2) != 0L);
+      case 20:
+         return ((jjbitVec6[i2] & l2) != 0L);
+      case 22:
+         return ((jjbitVec28[i2] & l2) != 0L);
+      case 23:
+         return ((jjbitVec75[i2] & l2) != 0L);
+      case 24:
+         return ((jjbitVec76[i2] & l2) != 0L);
+      case 25:
+         return ((jjbitVec77[i2] & l2) != 0L);
+      case 26:
+         return ((jjbitVec78[i2] & l2) != 0L);
+      case 27:
+         return ((jjbitVec79[i2] & l2) != 0L);
+      case 28:
+         return ((jjbitVec80[i2] & l2) != 0L);
+      case 29:
+         return ((jjbitVec81[i2] & l2) != 0L);
+      case 31:
+         return ((jjbitVec36[i2] & l2) != 0L);
+      case 32:
+         return ((jjbitVec82[i2] & l2) != 0L);
+      case 33:
+         return ((jjbitVec38[i2] & l2) != 0L);
+      case 44:
+         return ((jjbitVec83[i2] & l2) != 0L);
+      case 45:
+         return ((jjbitVec84[i2] & l2) != 0L);
+      case 46:
+         return ((jjbitVec41[i2] & l2) != 0L);
+      case 48:
+         return ((jjbitVec85[i2] & l2) != 0L);
+      case 49:
+         return ((jjbitVec43[i2] & l2) != 0L);
+      case 77:
+         return ((jjbitVec44[i2] & l2) != 0L);
+      case 159:
+         return ((jjbitVec45[i2] & l2) != 0L);
+      case 164:
+         return ((jjbitVec46[i2] & l2) != 0L);
+      case 166:
+         return ((jjbitVec86[i2] & l2) != 0L);
+      case 167:
+         return ((jjbitVec48[i2] & l2) != 0L);
+      case 168:
+         return ((jjbitVec87[i2] & l2) != 0L);
+      case 169:
+         return ((jjbitVec88[i2] & l2) != 0L);
+      case 170:
+         return ((jjbitVec89[i2] & l2) != 0L);
+      case 171:
+         return ((jjbitVec90[i2] & l2) != 0L);
+      case 215:
+         return ((jjbitVec53[i2] & l2) != 0L);
+      case 250:
+         return ((jjbitVec54[i2] & l2) != 0L);
+      case 251:
+         return ((jjbitVec91[i2] & l2) != 0L);
+      case 253:
+         return ((jjbitVec56[i2] & l2) != 0L);
+      case 254:
+         return ((jjbitVec92[i2] & l2) != 0L);
+      case 255:
+         return ((jjbitVec93[i2] & l2) != 0L);
+      default :
+         if ((jjbitVec9[i1] & l1) != 0L)
+            return true;
+         return false;
+   }
+}
+
+int curLexState = 0;
+int defaultLexState = 0;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+/** Get the next Token. */
+public Token getNextToken() 
+{
+  Token specialToken = null;
+  Token matchedToken;
+  int curPos = 0;
+
+  EOFLoop :
+  for (;;)
+  {
+   try
+   {
+      curChar = input_stream.BeginToken();
+   }
+   catch(Exception e)
+   {
+      jjmatchedKind = 0;
+      jjmatchedPos = -1;
+      matchedToken = jjFillToken();
+      matchedToken.specialToken = specialToken;
+      CommonTokenAction(matchedToken);
+      return matchedToken;
+   }
+   image = jjimage;
+   image.setLength(0);
+   jjimageLen = 0;
+
+   for (;;)
+   {
+     switch(curLexState)
+     {
+       case 0:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_0();
+         break;
+       case 1:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_1();
+         if (jjmatchedPos == 0 && jjmatchedKind > 10)
+         {
+            jjmatchedKind = 10;
+         }
+         break;
+       case 2:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_2();
+         if (jjmatchedPos == 0 && jjmatchedKind > 10)
+         {
+            jjmatchedKind = 10;
+         }
+         break;
+     }
+     if (jjmatchedKind != 0x7fffffff)
+     {
+        if (jjmatchedPos + 1 < curPos)
+           input_stream.backup(curPos - jjmatchedPos - 1);
+        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+        {
+           matchedToken = jjFillToken();
+           matchedToken.specialToken = specialToken;
+           TokenLexicalActions(matchedToken);
+       if (jjnewLexState[jjmatchedKind] != -1)
+         curLexState = jjnewLexState[jjmatchedKind];
+           CommonTokenAction(matchedToken);
+           return matchedToken;
+        }
+        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+        {
+           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+           {
+              matchedToken = jjFillToken();
+              if (specialToken == null)
+                 specialToken = matchedToken;
+              else
+              {
+                 matchedToken.specialToken = specialToken;
+                 specialToken = (specialToken.next = matchedToken);
+              }
+              SkipLexicalActions(matchedToken);
+           }
+           else
+              SkipLexicalActions(null);
+         if (jjnewLexState[jjmatchedKind] != -1)
+           curLexState = jjnewLexState[jjmatchedKind];
+           continue EOFLoop;
+        }
+        MoreLexicalActions();
+      if (jjnewLexState[jjmatchedKind] != -1)
+        curLexState = jjnewLexState[jjmatchedKind];
+        curPos = 0;
+        jjmatchedKind = 0x7fffffff;
+        try {
+           curChar = input_stream.readChar();
+           continue;
+        }
+        catch (java.io.IOException e1) { }
+     }
+     int error_line = input_stream.getEndLine();
+     int error_column = input_stream.getEndColumn();
+     String error_after = null;
+     boolean EOFSeen = false;
+     try { input_stream.readChar(); input_stream.backup(1); }
+     catch (java.io.IOException e1) {
+        EOFSeen = true;
+        error_after = curPos <= 1 ? "" : input_stream.GetImage();
+        if (curChar == '\n' || curChar == '\r') {
+           error_line++;
+           error_column = 0;
+        }
+        else
+           error_column++;
+     }
+     if (!EOFSeen) {
+        input_stream.backup(1);
+        error_after = curPos <= 1 ? "" : input_stream.GetImage();
+     }
+     throw new TokenMgrException(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrException.LEXICAL_ERROR);
+   }
+  }
+}
+
+void SkipLexicalActions(Token matchedToken)
+{
+   switch(jjmatchedKind)
+   {
+      default :
+         break;
+   }
+}
+void MoreLexicalActions()
+{
+   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
+   switch(jjmatchedKind)
+   {
+      case 6 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+                                          input_stream.backup(1);
+         break;
+      default :
+         break;
+   }
+}
+void TokenLexicalActions(Token matchedToken)
+{
+   switch(jjmatchedKind)
+   {
+      case 139 :
+        image.append(jjstrLiteralImages[139]);
+        lengthOfMatch = jjstrLiteralImages[139].length();
+     matchedToken.kind = GT;
+     matchedToken.realKind = RUNSIGNEDSHIFT;
+     input_stream.backup(2);
+         break;
+      case 140 :
+        image.append(jjstrLiteralImages[140]);
+        lengthOfMatch = jjstrLiteralImages[140].length();
+     matchedToken.kind = GT;
+     matchedToken.realKind = RSIGNEDSHIFT;
+     input_stream.backup(1);
+         break;
+      default :
+         break;
+   }
+}
+private void jjCheckNAdd(int state)
+{
+   if (jjrounds[state] != jjround)
+   {
+      jjstateSet[jjnewStateCnt++] = state;
+      jjrounds[state] = jjround;
+   }
+}
+private void jjAddStates(int start, int end)
+{
+   do {
+      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+   } while (start++ != end);
+}
+private void jjCheckNAddTwoStates(int state1, int state2)
+{
+   jjCheckNAdd(state1);
+   jjCheckNAdd(state2);
+}
+
+private void jjCheckNAddStates(int start, int end)
+{
+   do {
+      jjCheckNAdd(jjnextStates[start]);
+   } while (start++ != end);
+}
+
+    /** Constructor. */
+    public GeneratedJavaParserTokenManager(SimpleCharStream stream){
+
+      if (SimpleCharStream.staticFlag)
+            throw new RuntimeException("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
+
+    input_stream = stream;
+  }
+
+  /** Constructor. */
+  public GeneratedJavaParserTokenManager (SimpleCharStream stream, int lexState){
+    ReInit(stream);
+    SwitchTo(lexState);
+  }
+
+  /** Reinitialise parser. */
+  
+  public void ReInit(SimpleCharStream stream)
+  {
+
+
+    jjmatchedPos =
+    jjnewStateCnt =
+    0;
+    curLexState = defaultLexState;
+    input_stream = stream;
+    ReInitRounds();
+  }
+
+  private void ReInitRounds()
+  {
+    int i;
+    jjround = 0x80000001;
+    for (i = 144; i-- > 0;)
+      jjrounds[i] = 0x80000000;
+  }
+
+  /** Reinitialise parser. */
+  public void ReInit(SimpleCharStream stream, int lexState)
+  
+  {
+    ReInit(stream);
+    SwitchTo(lexState);
+  }
+
+  /** Switch to specified lex state. */
+  public void SwitchTo(int lexState)
+  {
+    if (lexState >= 3 || lexState < 0)
+      throw new TokenMgrException("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrException.INVALID_LEXICAL_STATE);
+    else
+      curLexState = lexState;
+  }
+
+
+/** Lexer state names. */
+public static final String[] lexStateNames = {
+   "DEFAULT",
+   "IN_JAVADOC_COMMENT",
+   "IN_MULTI_LINE_COMMENT",
+};
+
+/** Lex State array. */
+public static final int[] jjnewLexState = {
+   -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+};
+static final long[] jjtoToken = {
+   0xfffffffffffff801L, 0xfffffffff3810fffL, 0x7fffL, 
+};
+static final long[] jjtoSkip = {
+   0x33eL, 0x0L, 0x0L, 
+};
+static final long[] jjtoSpecial = {
+   0x33eL, 0x0L, 0x0L, 
+};
+static final long[] jjtoMore = {
+   0x4c0L, 0x0L, 0x0L, 
+};
+    protected SimpleCharStream  input_stream;
+
+    private final int[] jjrounds = new int[144];
+    private final int[] jjstateSet = new int[2 * 144];
+    private final StringBuilder jjimage = new StringBuilder();
+    private StringBuilder image = jjimage;
+    private int jjimageLen;
+    private int lengthOfMatch;
+    protected int curChar;
+}
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java
new file mode 100644
index 000000000..5d25eae39
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/ParseException.java
@@ -0,0 +1,235 @@
+/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 7.0 */
+/* JavaCCOptions:KEEP_LINE_COLUMN=true */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+/**
+ * This exception is thrown when parse errors are encountered.
+ * You can explicitly create objects of this exception type by
+ * calling the method generateParseException in the generated
+ * parser.
+ *
+ * You can modify this class to customize your error reporting
+ * mechanisms so long as you retain the public fields.
+ */
+public class ParseException extends Exception {
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  private static final String INDENT = "    ";
+  
+  /**
+   * The end of line string (we do not use System.getProperty("") so that we are compatible with Android/GWT);
+   */
+  protected static String EOL = "\n";
+
+  
+  public ParseException(Token currentTokenVal,
+          int[][] expectedTokenSequencesVal,
+          String[] tokenImageVal
+         )
+	{
+	  this (currentTokenVal, expectedTokenSequencesVal, tokenImageVal, null);
+	}
+  
+  
+  /**
+   * This constructor is used by the method "generateParseException"
+   * in the generated parser.  Calling this constructor generates
+   * a new object of this type with the fields "currentToken",
+   * "expectedTokenSequences", and "tokenImage" set.
+   */
+  public ParseException(Token currentTokenVal,
+                        int[][] expectedTokenSequencesVal,
+                        String[] tokenImageVal,
+                        String lexicalStateName
+                       )
+  {
+    super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal, lexicalStateName));
+    currentToken = currentTokenVal;
+    expectedTokenSequences = expectedTokenSequencesVal;
+    tokenImage = tokenImageVal;
+  }
+
+  /**
+   * The following constructors are for use by you for whatever
+   * purpose you can think of.  Constructing the exception in this
+   * manner makes the exception behave in the normal way - i.e., as
+   * documented in the class "Throwable".  The fields "errorToken",
+   * "expectedTokenSequences", and "tokenImage" do not contain
+   * relevant information.  The JavaCC generated code does not use
+   * these constructors.
+   */
+
+  public ParseException() {
+    super();
+  }
+
+  /** Constructor with message. */
+  public ParseException(String message) {
+    super(message);
+  }
+
+
+  /**
+   * This is the last token that has been consumed successfully.  If
+   * this object has been created due to a parse error, the token
+   * followng this token will (therefore) be the first error token.
+   */
+  public Token currentToken;
+
+  /**
+   * Each entry in this array is an array of integers.  Each array
+   * of integers represents a sequence of tokens (by their ordinal
+   * values) that is expected at this point of the parse.
+   */
+  public int[][] expectedTokenSequences;
+
+  /**
+   * This is a reference to the "tokenImage" array of the generated
+   * parser within which the parse error occurred.  This array is
+   * defined in the generated ...Constants interface.
+   */
+  public String[] tokenImage;
+
+  /**
+   * It uses "currentToken" and "expectedTokenSequences" to generate a parse
+   * error message and returns it.  If this object has been created
+   * due to a parse error, and you do not catch it (it gets thrown
+   * from the parser) the correct error message
+   * gets displayed.
+   */
+  private static String initialise(Token currentToken,
+                           int[][] expectedTokenSequences,
+                           String[] tokenImage,
+                           String lexicalStateName) {
+	StringBuilder sb = new StringBuilder();
+    StringBuffer expected = new StringBuffer();
+    
+    int maxSize = 0;
+    java.util.TreeSet<String> sortedOptions = new java.util.TreeSet<String>();
+    for (int i = 0; i < expectedTokenSequences.length; i++) {
+      if (maxSize < expectedTokenSequences[i].length) {
+        maxSize = expectedTokenSequences[i].length;
+      }
+      for (int j = 0; j < expectedTokenSequences[i].length; j++) {
+    	  sortedOptions.add(tokenImage[expectedTokenSequences[i][j]]);
+      }
+    }
+    
+    for (String option : sortedOptions) {
+        expected.append(INDENT).append(option).append(EOL);
+      }
+    
+    sb.append("Encountered unexpected token:");
+    
+    Token tok = currentToken.next;
+    for (int i = 0; i < maxSize; i++) {
+      String tokenText = tok.image;
+  	  String escapedTokenText = add_escapes(tokenText);
+      if (i != 0) {
+      	sb.append(" ");
+      }
+      if (tok.kind == 0) {
+      	sb.append(tokenImage[0]);
+        break;
+      }
+      sb.append(" \"");
+	  sb.append(escapedTokenText);
+      sb.append("\"");
+      sb.append(" " + tokenImage[tok.kind]);
+      tok = tok.next;
+    }
+	sb.append(EOL).append(INDENT).append("at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn);
+	sb.append(".").append(EOL);
+    
+    if (expectedTokenSequences.length == 0) {
+        // Nothing to add here
+    } else {
+    	int numExpectedTokens = expectedTokenSequences.length;
+    	sb.append(EOL).append("Was expecting"+ (numExpectedTokens == 1 ? ":" : " one of:") + EOL + EOL);
+    	sb.append(expected.toString());
+    }
+    // 2013/07/30 --> Seems to be inaccurate as represents the readahead state, not the lexical state BEFORE the unknown token
+//    if (lexicalStateName != null) {
+//    	sb.append(EOL).append("** Lexical State : ").append(lexicalStateName).append(EOL).append(EOL);
+//    }
+    
+    return sb.toString();
+  }
+
+
+  /**
+   * Used to convert raw characters to their escaped version
+   * when these raw version cannot be used as part of an ASCII
+   * string literal.
+   */
+  static String add_escapes(String str) {
+      StringBuffer retval = new StringBuffer();
+      char ch;
+      for (int i = 0; i < str.length(); i++) {
+        switch (str.charAt(i))
+        {
+           case '\b':
+              retval.append("\\b");
+              continue;
+           case '\t':
+              retval.append("\\t");
+              continue;
+           case '\n':
+              retval.append("\\n");
+              continue;
+           case '\f':
+              retval.append("\\f");
+              continue;
+           case '\r':
+              retval.append("\\r");
+              continue;
+           case '\"':
+              retval.append("\\\"");
+              continue;
+           case '\'':
+              retval.append("\\\'");
+              continue;
+           case '\\':
+              retval.append("\\\\");
+              continue;
+           default:
+              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+                 String s = "0000" + Integer.toString(ch, 16);
+                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+              } else {
+                 retval.append(ch);
+              }
+              continue;
+        }
+      }
+      return retval.toString();
+   }
+
+}
+/* JavaCC - OriginalChecksum=f4d1610e84d3d5884564259f96f1c24b (do not edit this line) */
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java
new file mode 100644
index 000000000..6dcbfb3e8
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/Provider.java
@@ -0,0 +1,47 @@
+/* Generated By:JavaCC: Do not edit this line. Provider.java Version 7.0 */
+/* JavaCCOptions:KEEP_LINE_COLUMN=true */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+
+import java.io.IOException;
+
+public interface Provider {
+    /**
+     * Reads characters into an array
+     * @param buffer  Destination buffer
+     * @param offset   Offset at which to start storing characters
+     * @param length   The maximum possible number of characters to read
+     * @return The number of characters read, or -1 if all read
+     * @exception  IOException
+     */
+    public int read(char buffer[], int offset, int len) throws IOException;
+    
+    /**
+     * Closes the stream and releases any system resources associated with
+     * it.
+     * @exception IOException
+     */
+     public void close() throws IOException;
+    
+}
+/* JavaCC - OriginalChecksum=2a9bd492caf4b9d28bb7522391baadbc (do not edit this line) */
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java
new file mode 100644
index 000000000..8f2bd2295
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/SimpleCharStream.java
@@ -0,0 +1,419 @@
+/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 7.0 */
+/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+/**
+ * An implementation of interface CharStream, where the stream is assumed to
+ * contain only ASCII characters (without unicode processing).
+ */
+
+public class SimpleCharStream
+{
+/** Whether parser is static. */
+  public static final boolean staticFlag = false;
+  int bufsize;
+  int available;
+  int tokenBegin;
+/** Position in buffer. */
+  public int bufpos = -1;
+  protected int bufline[];
+  protected int bufcolumn[];
+
+  protected int column = 0;
+  protected int line = 1;
+
+  protected boolean prevCharIsCR = false;
+  protected boolean prevCharIsLF = false;
+
+  protected Provider inputStream;
+
+  protected char[] buffer;
+  protected int maxNextCharInd = 0;
+  protected int inBuf = 0;
+  protected int tabSize = 1;
+  protected boolean trackLineColumn = true;
+
+  public void setTabSize(int i) { tabSize = i; }
+  public int getTabSize() { return tabSize; }
+
+
+
+  protected void ExpandBuff(boolean wrapAround)
+  {
+    char[] newbuffer = new char[bufsize + 2048];
+    int newbufline[] = new int[bufsize + 2048];
+    int newbufcolumn[] = new int[bufsize + 2048];
+
+    try
+    {
+      if (wrapAround)
+      {
+        System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+        System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
+        buffer = newbuffer;
+
+        System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+        System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
+        bufline = newbufline;
+
+        System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+        System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
+        bufcolumn = newbufcolumn;
+
+        maxNextCharInd = (bufpos += (bufsize - tokenBegin));
+      }
+      else
+      {
+        System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+        buffer = newbuffer;
+
+        System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+        bufline = newbufline;
+
+        System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+        bufcolumn = newbufcolumn;
+
+        maxNextCharInd = (bufpos -= tokenBegin);
+      }
+    }
+    catch (Throwable t)
+    {
+      throw new RuntimeException(t.getMessage());
+    }
+
+
+    bufsize += 2048;
+    available = bufsize;
+    tokenBegin = 0;
+  }
+
+  protected void FillBuff() throws java.io.IOException
+  {
+    if (maxNextCharInd == available)
+    {
+      if (available == bufsize)
+      {
+        if (tokenBegin > 2048)
+        {
+          bufpos = maxNextCharInd = 0;
+          available = tokenBegin;
+        }
+        else if (tokenBegin < 0)
+          bufpos = maxNextCharInd = 0;
+        else
+          ExpandBuff(false);
+      }
+      else if (available > tokenBegin)
+        available = bufsize;
+      else if ((tokenBegin - available) < 2048)
+        ExpandBuff(true);
+      else
+        available = tokenBegin;
+    }
+
+    int i;
+    try {
+      if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1)
+      {
+        inputStream.close();
+        throw new java.io.IOException();
+      }
+      else
+        maxNextCharInd += i;
+      return;
+    }
+    catch(java.io.IOException e) {
+      --bufpos;
+      backup(0);
+      if (tokenBegin == -1)
+        tokenBegin = bufpos;
+      throw e;
+    }
+  }
+
+/** Start. */
+  public char BeginToken() throws java.io.IOException
+  {
+    tokenBegin = -1;
+    char c = readChar();
+    tokenBegin = bufpos;
+
+    return c;
+  }
+
+  protected void UpdateLineColumn(char c)
+  {
+    column++;
+
+    if (prevCharIsLF)
+    {
+      prevCharIsLF = false;
+      line += (column = 1);
+    }
+    else if (prevCharIsCR)
+    {
+      prevCharIsCR = false;
+      if (c == '\n')
+      {
+        prevCharIsLF = true;
+      }
+      else
+        line += (column = 1);
+    }
+
+    switch (c)
+    {
+      case '\r' :
+        prevCharIsCR = true;
+        break;
+      case '\n' :
+        prevCharIsLF = true;
+        break;
+      case '\t' :
+        column--;
+        column += (tabSize - (column % tabSize));
+        break;
+      default :
+        break;
+    }
+
+    bufline[bufpos] = line;
+    bufcolumn[bufpos] = column;
+  }
+
+/** Read a character. */
+  public char readChar() throws java.io.IOException
+  {
+    if (inBuf > 0)
+    {
+      --inBuf;
+
+      if (++bufpos == bufsize)
+        bufpos = 0;
+
+      return buffer[bufpos];
+    }
+
+    if (++bufpos >= maxNextCharInd)
+      FillBuff();
+
+    char c = buffer[bufpos];
+
+    UpdateLineColumn(c);
+    return c;
+  }
+
+  @Deprecated
+  /**
+   * @deprecated
+   * @see #getEndColumn
+   */
+
+  public int getColumn() {
+    return bufcolumn[bufpos];
+  }
+
+  @Deprecated
+  /**
+   * @deprecated
+   * @see #getEndLine
+   */
+
+  public int getLine() {
+    return bufline[bufpos];
+  }
+
+  /** Get token end column number. */
+  public int getEndColumn() {
+    return bufcolumn[bufpos];
+  }
+
+  /** Get token end line number. */
+  public int getEndLine() {
+     return bufline[bufpos];
+  }
+
+  /** Get token beginning column number. */
+  public int getBeginColumn() {
+    return bufcolumn[tokenBegin];
+  }
+
+  /** Get token beginning line number. */
+  public int getBeginLine() {
+    return bufline[tokenBegin];
+  }
+
+/** Backup a number of characters. */
+  public void backup(int amount) {
+
+    inBuf += amount;
+    if ((bufpos -= amount) < 0)
+      bufpos += bufsize;
+  }
+
+  /** Constructor. */
+  public SimpleCharStream(Provider dstream, int startline,
+  int startcolumn, int buffersize)
+  {
+    inputStream = dstream;
+    line = startline;
+    column = startcolumn - 1;
+
+    available = bufsize = buffersize;
+    buffer = new char[buffersize];
+    bufline = new int[buffersize];
+    bufcolumn = new int[buffersize];
+  }
+
+  /** Constructor. */
+  public SimpleCharStream(Provider dstream, int startline,
+                          int startcolumn)
+  {
+    this(dstream, startline, startcolumn, 4096);
+  }
+
+  /** Constructor. */
+  public SimpleCharStream(Provider dstream)
+  {
+    this(dstream, 1, 1, 4096);
+  }
+
+  /** Reinitialise. */
+  public void ReInit(Provider dstream, int startline,
+  int startcolumn, int buffersize)
+  {
+    inputStream = dstream;
+    line = startline;
+    column = startcolumn - 1;
+
+    if (buffer == null || buffersize != buffer.length)
+    {
+      available = bufsize = buffersize;
+      buffer = new char[buffersize];
+      bufline = new int[buffersize];
+      bufcolumn = new int[buffersize];
+    }
+    prevCharIsLF = prevCharIsCR = false;
+    tokenBegin = inBuf = maxNextCharInd = 0;
+    bufpos = -1;
+  }
+
+  /** Reinitialise. */
+  public void ReInit(Provider dstream, int startline,
+                     int startcolumn)
+  {
+    ReInit(dstream, startline, startcolumn, 4096);
+  }
+
+  /** Reinitialise. */
+  public void ReInit(Provider dstream)
+  {
+    ReInit(dstream, 1, 1, 4096);
+  }
+ 
+
+  /** Get token literal value. */
+  public String GetImage()
+  {
+    if (bufpos >= tokenBegin)
+      return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
+    else
+      return new String(buffer, tokenBegin, bufsize - tokenBegin) +
+                            new String(buffer, 0, bufpos + 1);
+  }
+
+  /** Get the suffix. */
+  public char[] GetSuffix(int len)
+  {
+    char[] ret = new char[len];
+
+    if ((bufpos + 1) >= len)
+      System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
+    else
+    {
+      System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
+                                                        len - bufpos - 1);
+      System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
+    }
+
+    return ret;
+  }
+
+  /** Reset buffer when finished. */
+  public void Done()
+  {
+    buffer = null;
+    bufline = null;
+    bufcolumn = null;
+  }
+
+  /**
+   * Method to adjust line and column numbers for the start of a token.
+   */
+  public void adjustBeginLineColumn(int newLine, int newCol)
+  {
+    int start = tokenBegin;
+    int len;
+
+    if (bufpos >= tokenBegin)
+    {
+      len = bufpos - tokenBegin + inBuf + 1;
+    }
+    else
+    {
+      len = bufsize - tokenBegin + bufpos + 1 + inBuf;
+    }
+
+    int i = 0, j = 0, k = 0;
+    int nextColDiff = 0, columnDiff = 0;
+
+    while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
+    {
+      bufline[j] = newLine;
+      nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
+      bufcolumn[j] = newCol + columnDiff;
+      columnDiff = nextColDiff;
+      i++;
+    }
+
+    if (i < len)
+    {
+      bufline[j] = newLine++;
+      bufcolumn[j] = newCol + columnDiff;
+
+      while (i++ < len)
+      {
+        if (bufline[j = start % bufsize] != bufline[++start % bufsize])
+          bufline[j] = newLine++;
+        else
+          bufline[j] = newLine;
+      }
+    }
+
+    line = bufline[j];
+    column = bufcolumn[j];
+  }
+  boolean getTrackLineColumn() { return trackLineColumn; }
+  void setTrackLineColumn(boolean tlc) { trackLineColumn = tlc; }
+}
+/* JavaCC - OriginalChecksum=426048510a1ecd9a28c73d4def7423eb (do not edit this line) */
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java
new file mode 100644
index 000000000..b3b3416ca
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/StreamProvider.java
@@ -0,0 +1,78 @@
+/* Generated By:JavaCC: Do not edit this line. StreamProvider.java Version 7.0 */
+/* JavaCCOptions:KEEP_LINE_COLUMN=true */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+
+/**
+ * NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead)
+ */
+public class StreamProvider implements Provider {
+
+	Reader _reader;
+
+	public StreamProvider(Reader reader) {
+		_reader = reader;
+	}
+	
+	public StreamProvider(InputStream stream) throws IOException {
+		_reader = new BufferedReader(new InputStreamReader(stream));
+	}
+	
+	public StreamProvider(InputStream stream, String charsetName) throws IOException {
+		_reader = new BufferedReader(new InputStreamReader(stream, charsetName));
+	}
+
+	@Override
+	public int read(char[] buffer, int off, int len) throws IOException {
+	   int result = _reader.read(buffer, off, len);
+
+	   /* CBA -- Added 2014/03/29 -- 
+	             This logic allows the generated Java code to be easily translated to C# (via sharpen) -
+	             as in C# 0 represents end of file, and in Java, -1 represents end of file
+	             See : http://msdn.microsoft.com/en-us/library/9kstw824(v=vs.110).aspx
+	             ** Technically, this is not required for java but the overhead is extremely low compared to the code generation benefits.
+	   */
+	   
+	   if (result == 0) {
+	      if (off < buffer.length && len > 0) {
+	        result = -1;
+	      }
+	   }
+	   
+		return result;
+	}
+
+	@Override
+	public void close() throws IOException {
+		_reader.close();
+	}
+
+}
+
+/* JavaCC - OriginalChecksum=bc0ddea608a1ea01a8e32fee4c628d00 (do not edit this line) */
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java
new file mode 100644
index 000000000..14c7d6dd1
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/StringProvider.java
@@ -0,0 +1,68 @@
+/* Generated By:JavaCC: Do not edit this line. StringProvider.java Version 7.0 */
+/* JavaCCOptions:KEEP_LINE_COLUMN=true */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+	
+	import java.io.IOException;
+	
+	public class StringProvider implements Provider {
+
+		String _string;
+		int _position = 0;
+		int _size;
+		
+		public StringProvider(String string) {
+			_string = string;
+			_size = string.length();
+		}
+		
+		@Override
+		public int read(char[] cbuf, int off, int len) throws IOException {
+			int numCharsOutstandingInString = _size - _position;
+			
+			if (numCharsOutstandingInString == 0) {
+				return -1;
+			}
+			
+			int numBytesInBuffer = cbuf.length;
+			int numBytesToRead = numBytesInBuffer -off;
+			numBytesToRead = numBytesToRead > len ? len : numBytesToRead;
+			
+			if (numBytesToRead > numCharsOutstandingInString) {
+				numBytesToRead = numCharsOutstandingInString;
+			}
+			
+			_string.getChars(_position, _position + numBytesToRead, cbuf, off);
+			
+			_position += numBytesToRead;
+			
+			return numBytesToRead;
+		}
+
+		@Override
+		public void close() throws IOException {
+			_string = null;
+		}
+		
+	}
+/* JavaCC - OriginalChecksum=38052dc5b81585946987664a01065e9e (do not edit this line) */
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java
new file mode 100644
index 000000000..b8764d415
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/Token.java
@@ -0,0 +1,152 @@
+/* Generated By:JavaCC: Do not edit this line. Token.java Version 7.0 */
+/* JavaCCOptions:TOKEN_EXTENDS=TokenBase,KEEP_LINE_COLUMN=true,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+/**
+ * Describes the input token stream.
+ */
+
+public class Token extends TokenBase implements java.io.Serializable {
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * An integer that describes the kind of this token.  This numbering
+   * system is determined by JavaCCParser, and a table of these numbers is
+   * stored in the file ...Constants.java.
+   */
+  public int kind;
+
+  /** The line number of the first character of this Token. */
+  public int beginLine;
+  /** The column number of the first character of this Token. */
+  public int beginColumn;
+  /** The line number of the last character of this Token. */
+  public int endLine;
+  /** The column number of the last character of this Token. */
+  public int endColumn;
+
+  /**
+   * The string image of the token.
+   */
+  public String image;
+
+  /**
+   * A reference to the next regular (non-special) token from the input
+   * stream.  If this is the last token from the input stream, or if the
+   * token manager has not read tokens beyond this one, this field is
+   * set to null.  This is true only if this token is also a regular
+   * token.  Otherwise, see below for a description of the contents of
+   * this field.
+   */
+  public Token next;
+
+  /**
+   * This field is used to access special tokens that occur prior to this
+   * token, but after the immediately preceding regular (non-special) token.
+   * If there are no such special tokens, this field is set to null.
+   * When there are more than one such special token, this field refers
+   * to the last of these special tokens, which in turn refers to the next
+   * previous special token through its specialToken field, and so on
+   * until the first special token (whose specialToken field is null).
+   * The next fields of special tokens refer to other special tokens that
+   * immediately follow it (without an intervening regular token).  If there
+   * is no such token, this field is null.
+   */
+  public Token specialToken;
+
+  /**
+   * An optional attribute value of the Token.
+   * Tokens which are not used as syntactic sugar will often contain
+   * meaningful values that will be used later on by the compiler or
+   * interpreter. This attribute value is often different from the image.
+   * Any subclass of Token that actually wants to return a non-null value can
+   * override this method as appropriate.
+   */
+  public Object getValue() {
+    return null;
+  }
+
+  /**
+   * No-argument constructor
+   */
+  public Token() {}
+
+  /**
+   * Constructs a new token for the specified Image.
+   */
+  public Token(int kind)
+  {
+    this(kind, null);
+  }
+
+  /**
+   * Constructs a new token for the specified Image and Kind.
+   */
+  public Token(int kind, String image)
+  {
+    this.kind = kind;
+    this.image = image;
+  }
+
+  /**
+   * Returns the image.
+   */
+  @Override
+  public String toString()
+  {
+    return image;
+  }
+
+  /**
+   * Returns a new Token object, by default. However, if you want, you
+   * can create and return subclass objects based on the value of ofKind.
+   * Simply add the cases to the switch for all those special cases.
+   * For example, if you have a subclass of Token called IDToken that
+   * you want to create if ofKind is ID, simply add something like :
+   *
+   *    case MyParserConstants.ID : return new IDToken(ofKind, image);
+   *
+   * to the following switch statement. Then you can cast matchedToken
+   * variable to the appropriate type and use sit in your lexical actions.
+   */
+  public static Token newToken(int ofKind, String image)
+  {
+    switch(ofKind)
+    {
+      default : return new Token(ofKind, image);
+    }
+  }
+
+  public static Token newToken(int ofKind)
+  {
+    return newToken(ofKind, null);
+  }
+
+}
+/* JavaCC - OriginalChecksum=4dee3ecb0b873195e388b52791f0170e (do not edit this line) */
diff --git a/javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java b/javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java
new file mode 100644
index 000000000..a34079b7a
--- /dev/null
+++ b/javaparser-core/generated-sources/javacc/com/github/javaparser/TokenMgrException.java
@@ -0,0 +1,167 @@
+/* Generated By:JavaCC: Do not edit this line. TokenMgrException.java Version 7.0 */
+/* JavaCCOptions: */
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2016 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ *
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+package com.github.javaparser;
+
+/** Token Manager Error. */
+public class TokenMgrException extends RuntimeException
+{
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  /*
+   * Ordinals for various reasons why an Error of this type can be thrown.
+   */
+
+  /**
+   * Lexical error occurred.
+   */
+  public static final int LEXICAL_ERROR = 0;
+
+  /**
+   * An attempt was made to create a second instance of a static token manager.
+   */
+  public static final int STATIC_LEXER_ERROR = 1;
+
+  /**
+   * Tried to change to an invalid lexical state.
+   */
+  public static final int INVALID_LEXICAL_STATE = 2;
+
+  /**
+   * Detected (and bailed out of) an infinite loop in the token manager.
+   */
+  public static final int LOOP_DETECTED = 3;
+
+  /**
+   * Indicates the reason why the exception is thrown. It will have
+   * one of the above 4 values.
+   */
+  int errorCode;
+
+  /**
+   * Replaces unprintable characters by their escaped (or unicode escaped)
+   * equivalents in the given string
+   */
+  protected static final String addEscapes(String str) {
+    StringBuffer retval = new StringBuffer();
+    char ch;
+    for (int i = 0; i < str.length(); i++) {
+      switch (str.charAt(i))
+      {
+        case '\b':
+          retval.append("\\b");
+          continue;
+        case '\t':
+          retval.append("\\t");
+          continue;
+        case '\n':
+          retval.append("\\n");
+          continue;
+        case '\f':
+          retval.append("\\f");
+          continue;
+        case '\r':
+          retval.append("\\r");
+          continue;
+        case '\"':
+          retval.append("\\\"");
+          continue;
+        case '\'':
+          retval.append("\\\'");
+          continue;
+        case '\\':
+          retval.append("\\\\");
+          continue;
+        default:
+          if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+            String s = "0000" + Integer.toString(ch, 16);
+            retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+          } else {
+            retval.append(ch);
+          }
+          continue;
+      }
+    }
+    return retval.toString();
+  }
+
+  /**
+   * Returns a detailed message for the Error when it is thrown by the
+   * token manager to indicate a lexical error.
+   * Parameters :
+   *    EOFSeen     : indicates if EOF caused the lexical error
+   *    curLexState : lexical state in which this error occurred
+   *    errorLine   : line number when the error occurred
+   *    errorColumn : column number when the error occurred
+   *    errorAfter  : prefix that was seen before this error occurred
+   *    curchar     : the offending character
+   * Note: You can customize the lexical error message by modifying this method.
+   */
+  protected static String LexicalErr(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, int curChar) {
+    char curChar1 = (char)curChar;
+    return("Lexical error at line " +
+          errorLine + ", column " +
+          errorColumn + ".  Encountered: " +
+          (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar1)) + "\"") + " (" + curChar + "), ") +
+          "after : \"" + addEscapes(errorAfter) + "\"");
+  }
+
+  /**
+   * You can also modify the body of this method to customize your error messages.
+   * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
+   * of end-users concern, so you can return something like :
+   *
+   *     "Internal Error : Please file a bug report .... "
+   *
+   * from this method for such cases in the release version of your parser.
+   */
+  @Override
+  public String getMessage() {
+    return super.getMessage();
+  }
+
+  /*
+   * Constructors of various flavors follow.
+   */
+
+  /** No arg constructor. */
+  public TokenMgrException() {
+  }
+
+  /** Constructor with message and reason. */
+  public TokenMgrException(String message, int reason) {
+    super(message);
+    errorCode = reason;
+  }
+
+  /** Full Constructor. */
+  public TokenMgrException(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, int curChar, int reason) {
+    this(LexicalErr(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
+  }
+}
+/* JavaCC - OriginalChecksum=a12f92ff78a572ce135bdb1f55ed69c1 (do not edit this line) */