From 277aaaaf0240e7a9ecfc02b13736d743c52bd518 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Wed, 22 Apr 2026 22:21:01 +0800
Subject: [PATCH 01/27] refactor: align BshLambda wrapper generation with
 upstream (17b38e7)

---
 .../src/main/java/bsh/BshLambda.java          | 240 +++++++-------
 .../src/main/java/bsh/Primitive.java          |   2 +
 .../src/main/java/bsh/Types.java              | 303 +++++++++++++++++-
 .../src/main/java/bsh/util/Util.java          |  64 ++++
 4 files changed, 485 insertions(+), 124 deletions(-)
 create mode 100644 bsh-lambda-300-eee36c8/src/main/java/bsh/util/Util.java

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java
index 9b7de4f..4bf02be 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java
@@ -5,6 +5,8 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
+import java.lang.reflect.Type;
+import java.util.Arrays;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
@@ -16,7 +18,7 @@
 import bsh.org.objectweb.asm.FieldVisitor;
 import bsh.org.objectweb.asm.MethodVisitor;
 import bsh.org.objectweb.asm.Opcodes;
-import bsh.org.objectweb.asm.Type;
+import bsh.util.Util;
 
 /**
  * It's the instance of lambdas written in code.
@@ -52,10 +54,25 @@ private static Class<?> generateDummyType() {
     /** Method with the real implementation to eval the code written */
     protected abstract Object invokeImpl(Object[] args) throws UtilEvalError, EvalError, TargetError;
 
-    /** Method to invoke the lambda and deal with the expected exceptions */
-    public final Object invoke(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
+    /**
+     * Method to invoke this lambda where the return must be an Object of a specific Class<?>
+     * @param args The args to give to the lambda
+     * @param exceptionTypes An array of accepted exceptions that can be throw when invoking this lambda
+     * @param returnType This specify of what type must be the return
+     * @return An value that is assignable to <code>returnType</code>. Note: whether <code>returnType</code> is a primitive ( e.g., int ) the return will be a wrapper instance ( e.g., Integer )
+     */
+    public final <T> T invoke(Object[] args, Class<?>[] exceptionTypes, Class<T> returnType) throws Throwable {
         try {
-            return Primitive.unwrap(this.invokeImpl(args));
+            final Object result = returnType.isPrimitive() ? Primitive.unwrap(this.invokeImpl(args)) : this.invokeImpl(args);
+            if (returnType == void.class) return null;
+
+            try {
+                return (T) Primitive.unwrap(Types.castObject(result, returnType, Types.ASSIGNMENT));
+            } catch (Throwable t) {
+                final String msg = String.format("Can't assign %s to %s", Types.prettyName(Types.getType(result)), Types.prettyName(returnType));
+                throw new RuntimeEvalError(msg, expressionNode, null);
+            }
+
         } catch (TargetError e) {
             for (Class<?> exceptionType: exceptionTypes)
                 if (exceptionType.isInstance(e.getTarget()))
@@ -68,73 +85,6 @@ public final Object invoke(Object[] args, Class<?>[] exceptionTypes) throws Thro
         }
     }
 
-    /** Method to invoke the lambda where the return must be a char */
-    public final char invokeChar(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Character) return ((Character) result).charValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to char", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be a boolean */
-    public final boolean invokeBoolean(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Boolean) return ((Boolean) result).booleanValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to boolean", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be a byte */
-    public final byte invokeByte(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Number) return ((Number) result).byteValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to byte", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be a boolean */
-    public final short invokeShort(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Number) return ((Number) result).shortValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to short", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be an int */
-    public final int invokeInt(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Number) return ((Number) result).intValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to int", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be a long */
-    public final long invokeLong(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Number) return ((Number) result).longValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to long", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be a float */
-    public final float invokeFloat(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Number) return ((Number) result).floatValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to float", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be a double */
-    public final double invokeDouble(Object[] args, Class<?>[] exceptionTypes) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result instanceof Number) return ((Number) result).doubleValue();
-        throw new RuntimeEvalError("Can't convert " + StringUtil.typeString(result) + " to double", expressionNode, null);
-    }
-
-    /** Method to invoke the lambda where the return must be an Object of a specific Class<?> */
-    public final <T> T invokeObject(Object[] args, Class<?>[] exceptionTypes, Class<T> returnType) throws Throwable {
-        Object result = this.invoke(args, exceptionTypes);
-        if (result == null) return null;
-        try {
-            return (T) Types.castObject(result, returnType, Types.ASSIGNMENT);
-        } catch (UtilEvalError e) {
-            throw new RuntimeEvalError(e.toEvalError(expressionNode, null));
-        }
-    }
-
     /** Creates a lambda from a lambda expression, used by {@link BSHLambdaExpression} */
     protected static BshLambda fromLambdaExpression(Node expressionNode, NameSpace declaringNameSpace, Modifiers[] paramsModifiers, Class<?>[] paramsTypes, String[] paramsNames, Node bodyNode) {
         return new BshLambdaFromLambdaExpression(expressionNode, declaringNameSpace, paramsModifiers, paramsTypes, paramsNames, bodyNode);
@@ -253,7 +203,7 @@ private NameSpace initNameSpace(Object[] args) throws UtilEvalError {
         }
 
         protected boolean isAssignable(Method to, int round) {
-            Class<?>[] toParamsTypes = to.getParameterTypes();
+            Type[] toParamsTypes = to.getGenericParameterTypes();
             if (this.paramsTypes.length != toParamsTypes.length) return false;
 
             // TODO: validate the return type of 'this.bodyNode' ???
@@ -267,48 +217,87 @@ private static class BshLambdaFromMethodReference extends BshLambda {
         private final Object thisArg;
         private final String methodName;
 
+        // Util variables
+        private final boolean staticRef;
+        private final Class<?> _class;
+        private final Method[] methods;
+
         public BshLambdaFromMethodReference(Node expressionNode, Object thisArg, String methodName) {
             super(expressionNode);
             this.thisArg = thisArg;
             this.methodName = methodName;
+            this.staticRef = this.thisArg instanceof ClassIdentifier;
+            this._class = this.staticRef ? ((ClassIdentifier) this.thisArg).clas : this.thisArg.getClass();
+            this.methods = this._class.isInterface()
+                                ? Util.concatArrays(this._class.getMethods(), Object.class.getMethods())
+                                : this._class.getMethods();
         }
 
         protected final Object invokeImpl(Object[] args) throws UtilEvalError, EvalError, TargetError {
             try {
-                NameSpace nameSpace = new NameSpace("MethodReferenceLambda");
-                CallStack callStack = new CallStack(nameSpace);
-                Interpreter interpreter = new Interpreter(nameSpace);
-
-                if (thisArg instanceof ClassIdentifier) {
-                    Class<?> _class = ((ClassIdentifier) thisArg).clas;
-                    return methodName.equals("new")
-                            ? Reflect.constructObject(_class, args)
-                            : Reflect.invokeStaticMethod(nameSpace.getClassManager(), _class, methodName, args, expressionNode);
+                final NameSpace nameSpace = new NameSpace("MethodReferenceLambda");
+                final CallStack callStack = new CallStack(nameSpace);
+                final Interpreter interpreter = new Interpreter(nameSpace);
+
+                if (!this.staticRef) return Reflect.invokeObjectMethod(this.thisArg, this.methodName, args, interpreter, callStack, this.expressionNode);
+                if (this.methodName.equals("new")) return Reflect.constructObject(this._class, args);
+                if (args.length == 0 || !this._class.isInstance(args[0])) return Reflect.invokeStaticMethod(nameSpace.getClassManager(), this._class, this.methodName, args, this.expressionNode);
+
+                final Class<?>[] argsTypes = Types.getTypes(args);
+                final Class<?>[] nonStaticArgsTypes = Arrays.copyOfRange(argsTypes, 1, argsTypes.length);
+
+                for (Method method: this.methods) {
+                    if (!this.methodName.equals(method.getName())) continue;
+
+                    try {
+                        if (Reflect.isStatic(method)) { // Static reference to static method
+                            if (Types.isSignatureAssignable(argsTypes, method.getGenericParameterTypes(), Types.JAVA_BASE_ASSIGNABLE))
+                                return method.invoke(null, args);
+                        } else { // Static reference to non static method
+                            if (Types.isSignatureAssignable(nonStaticArgsTypes, method.getGenericParameterTypes(), Types.JAVA_BASE_ASSIGNABLE))
+                                return method.invoke(args[0], Arrays.copyOfRange(args, 1, args.length));
+                        }
+                    } catch (IllegalAccessException e) {}
                 }
-                return Reflect.invokeObjectMethod(this.thisArg, methodName, args, interpreter, callStack, expressionNode);
+
+                throw new UtilEvalError("Can't invoke lambda made from method reference!");
             } catch (InvocationTargetException e) {
                 throw new TargetError(e.getTargetException(), expressionNode, null);
             }
         }
 
         protected boolean isAssignable(Method to, int round) {
-            boolean staticMethod = this.thisArg instanceof ClassIdentifier;
-            Class<?> _class = this.thisArg instanceof ClassIdentifier ? ((ClassIdentifier) this.thisArg).clas : this.thisArg.getClass();
+            if (!this.staticRef) { // Non-Static references
+                for (Method method: _class.getMethods()) {
+                    if (!this.methodName.equals(method.getName())) continue;
+                    if (Reflect.isStatic(method)) continue;
+                    if (!Types.isSignatureAssignable(method.getParameterTypes(), to.getGenericParameterTypes(), round)) continue;
+                    if (!Types.isAssignable(method.getReturnType(), to.getGenericReturnType(), round)) continue;
+                    return true;
+                }
+                return false;
+            }
 
-            if (this.thisArg instanceof ClassIdentifier && this.methodName.equals("new")) {
+            if (this.methodName.equals("new")) { // Constructor reference
                 for (Constructor<?> constructor: _class.getConstructors()) {
-                    if (!Types.isSignatureAssignable(constructor.getParameterTypes(), to.getParameterTypes(), round)) continue;
-                    if (!Types.isAssignable(_class, to.getReturnType(), round)) continue;
+                    if (!Types.isSignatureAssignable(constructor.getParameterTypes(), to.getGenericParameterTypes(), round)) continue;
+                    if (!Types.isAssignable(_class, to.getGenericReturnType(), round)) continue;
                     return true;
                 }
                 return false;
             }
 
-            for (Method method: _class.getMethods()) {
+            // Static reference
+            for (Method method: this.methods) {
                 if (!this.methodName.equals(method.getName())) continue;
-                if (Reflect.isStatic(method) != staticMethod) continue;
-                if (!Types.isSignatureAssignable(method.getParameterTypes(), to.getParameterTypes(), round)) continue;
-                if (!Types.isAssignable(method.getReturnType(), to.getReturnType(), round)) continue;
+                if (Reflect.isStatic(method)) { // Static reference to static method
+                    if (!Types.isSignatureAssignable(method.getParameterTypes(), to.getGenericParameterTypes(), round)) continue;
+                    if (!Types.isAssignable(method.getReturnType(), to.getGenericReturnType(), round)) continue;
+                } else { // Static reference to non static method
+                    final Class<?>[] paramTypes = Util.concatArrays(new Class<?>[] { this._class }, method.getParameterTypes());
+                    if (!Types.isSignatureAssignable(paramTypes, to.getGenericParameterTypes(), round)) continue;
+                    if (!Types.isAssignable(method.getReturnType(), to.getGenericReturnType(), round)) continue;
+                }
                 return true;
             }
             return false;
@@ -328,28 +317,23 @@ public Class<?> classFromBytes(String className, byte[] classBytes) {
      */
     private static class WrapperGenerator {
 
-        private static String[] getInternalNames(Class<?>[] types) {
-            final String[] internalNames = new String[types.length];
-            for (int i = 0; i < types.length; i++) internalNames[i] = Type.getInternalName(types[i]);
-            return internalNames;
-        }
-
+        // TODO: get the FunctionalInterface args names too!
         /**
          * Return a new generated class that wraps a bshLambda. Example of a class that is generated:
          *
          * <p>
          *
-         * <pre>
+         * <pre>{@code
          * import java.util.function.Function;
          *
-         * public class MyClass implements Function {
+         * public class MyClass<T, R> implements Function<T, R> {
          *  private BshLambda bshLambda;
          *
          *  public MyClass(BshLambda bshLambda) {
          *      this.bshLambda = bshLambda;
          *  }
          *
-         *  public Object apply(Object arg1) {
+         *  public R apply(T arg1) {
          *      return this.bshLambda.invokeObject(new Object[] { arg1 }, new Class[0], Object.class);
          *  }
          * }
@@ -386,12 +370,14 @@ protected static <T> Class<T> generateClass(Class<T> functionalInterface) {
         private static byte[] generateClassBytes(String className, Class<?> functionalInterface) {
             ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
-            final String[] interfacesPrimitiveNames = { Type.getInternalName(functionalInterface) };
+            final String[] interfacesPrimitiveNames = { Types.getInternalName(functionalInterface) };
             final String superPrimitiveName = "java/lang/Object";
-            cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, null, superPrimitiveName, interfacesPrimitiveNames);
+            final String signature =  generateClassSignature(functionalInterface);
+
+            cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, className, signature, superPrimitiveName, interfacesPrimitiveNames);
 
             // Declare the 'bshLambda' field
-            FieldVisitor fieldVisitor = cw.visitField(Opcodes.ACC_PRIVATE, "bshLambda", Type.getDescriptor(BshLambda.class), null, null);
+            FieldVisitor fieldVisitor = cw.visitField(Opcodes.ACC_PRIVATE, "bshLambda", Types.getDescriptor(BshLambda.class), null, null);
             fieldVisitor.visitEnd();
 
             WrapperGenerator.writeConstructor(cw, className);
@@ -403,6 +389,13 @@ private static byte[] generateClassBytes(String className, Class<?> functionalIn
             return cw.toByteArray();
         }
 
+        private static String generateClassSignature(Class<?> functionalInterface) {
+            Type _interface = functionalInterface.getTypeParameters().length != 0
+                                                    ? Types.createParameterizedType(functionalInterface, functionalInterface.getTypeParameters())
+                                                    : functionalInterface;
+            return Types.getASMClassSignature(functionalInterface.getTypeParameters(), Object.class, _interface);
+        }
+
         /**
          * Just write the constructor in the ClassWriter. Example of a class with the constructor that is written with this method:
          *
@@ -420,7 +413,7 @@ private static byte[] generateClassBytes(String className, Class<?> functionalIn
          */
         private static void writeConstructor(ClassWriter cw, String className) {
             // Add a default constructor
-            final String constructorDescriptor = Type.getMethodDescriptor(Type.getType(void.class), Type.getType(BshLambda.class));
+            final String constructorDescriptor = Types.getMethodDescriptor(void.class, BshLambda.class);
             MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", constructorDescriptor, null, null);
             constructor.visitCode();
 
@@ -431,7 +424,7 @@ private static void writeConstructor(ClassWriter cw, String className) {
             // Write the implementation: this.bshLambda = bshLambda;
             constructor.visitVarInsn(Opcodes.ALOAD, 0); // Load this
             constructor.visitVarInsn(Opcodes.ALOAD, 1); // Load the first arg
-            constructor.visitFieldInsn(Opcodes.PUTFIELD, className, "bshLambda", Type.getDescriptor(BshLambda.class)); // Set the 'bshLambda' field
+            constructor.visitFieldInsn(Opcodes.PUTFIELD, className, "bshLambda", Types.getDescriptor(BshLambda.class)); // Set the 'bshLambda' field
 
             // Default end
             constructor.visitInsn(Opcodes.RETURN); // Return void
@@ -495,15 +488,15 @@ private static void writeConstructor(ClassWriter cw, String className) {
          * </pre>
          */
         private static void writeMethod(ClassWriter cw, String className, Method method) {
-            final String BSH_LAMBDA_NAME = Type.getInternalName(BshLambda.class);
+            final String BSH_LAMBDA_NAME = Types.getInternalName(BshLambda.class);
             final Parameter[] params = method.getParameters();
             final Class<?>[] exceptionTypes = method.getExceptionTypes();
 
-            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, method.getName(), Type.getMethodDescriptor(method), null, getInternalNames(exceptionTypes));
+            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, method.getName(), Types.getMethodDescriptor(method), Types.getASMMethodSignature(method), Types.getInternalNames(exceptionTypes));
             mv.visitCode();
 
             mv.visitVarInsn(Opcodes.ALOAD, 0); // Load 'this' onto the stack
-            mv.visitFieldInsn(Opcodes.GETFIELD, className, "bshLambda", Type.getDescriptor(BshLambda.class)); // Get the field value
+            mv.visitFieldInsn(Opcodes.GETFIELD, className, "bshLambda", Types.getDescriptor(BshLambda.class)); // Get the field value
 
             // Define and create the Object[] array to store the 'args'
             mv.visitLdcInsn(params.length); // Size of the array
@@ -562,42 +555,49 @@ private static void writeMethod(ClassWriter cw, String className, Method method)
                 Class<?> exceptionType = exceptionTypes[i];
                 mv.visitInsn(Opcodes.DUP);
                 mv.visitLdcInsn(i);
-                mv.visitLdcInsn(Type.getType(exceptionType));
+                mv.visitLdcInsn(Types.getASMType(exceptionType));
                 mv.visitInsn(Opcodes.AASTORE);
             }
 
             final Class<?> returnType = method.getReturnType();
+            final Class<?> invokeReturnType = returnType.isPrimitive() ? Primitive.boxType(returnType) : returnType;
+
+            if (returnType.isPrimitive())
+                mv.visitFieldInsn(Opcodes.GETSTATIC, Types.getInternalName(invokeReturnType), "TYPE", "Ljava/lang/Class;"); // Primitive type
+            else
+                mv.visitLdcInsn(Types.getASMType(returnType)); // Other types, just load it :P
+
+            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invoke", "([Ljava/lang/Object;[Ljava/lang/Class;Ljava/lang/Class;)Ljava/lang/Object;", false);
+            mv.visitTypeInsn(Opcodes.CHECKCAST, Types.getInternalName(invokeReturnType));
+
             if (returnType == void.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invoke", "([Ljava/lang/Object;[Ljava/lang/Class;)Ljava/lang/Object;", false);
                 mv.visitInsn(Opcodes.POP);
                 mv.visitInsn(Opcodes.RETURN);
             } else if (returnType == boolean.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeBoolean", "([Ljava/lang/Object;[Ljava/lang/Class;)Z", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
                 mv.visitInsn(Opcodes.IRETURN);
             } else if (returnType == char.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeChar", "([Ljava/lang/Object;[Ljava/lang/Class;)C", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C", false);
                 mv.visitInsn(Opcodes.IRETURN);
             } else if (returnType == byte.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeByte", "([Ljava/lang/Object;[Ljava/lang/Class;)B", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);
                 mv.visitInsn(Opcodes.IRETURN);
             } else if (returnType == short.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeShort", "([Ljava/lang/Object;[Ljava/lang/Class;)S", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Short", "shortValue", "()S", false);
                 mv.visitInsn(Opcodes.IRETURN);
             } else if (returnType == int.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeInt", "([Ljava/lang/Object;[Ljava/lang/Class;)I", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false);
                 mv.visitInsn(Opcodes.IRETURN);
             } else if (returnType == long.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeLong", "([Ljava/lang/Object;[Ljava/lang/Class;)J", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Long", "longValue", "()J", false);
                 mv.visitInsn(Opcodes.LRETURN);
             } else if (returnType == float.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeFloat", "([Ljava/lang/Object;[Ljava/lang/Class;)F", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Float", "floatValue", "()F", false);
                 mv.visitInsn(Opcodes.FRETURN);
             } else if (returnType == double.class) {
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeDouble", "([Ljava/lang/Object;[Ljava/lang/Class;)D", false);
+                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Double", "doubleValue", "()D", false);
                 mv.visitInsn(Opcodes.DRETURN);
             } else {
-                mv.visitLdcInsn(Type.getType(returnType));
-                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, BSH_LAMBDA_NAME, "invokeObject", "([Ljava/lang/Object;[Ljava/lang/Class;Ljava/lang/Class;)Ljava/lang/Object;", false);
                 mv.visitInsn(Opcodes.ARETURN);
             }
 
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Primitive.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Primitive.java
index d5d83e7..1e4834f 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Primitive.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Primitive.java
@@ -54,6 +54,7 @@ public final class Primitive implements Serializable {
 
     static final Map<Class<?>, Class<?>> wrapperMap = new HashMap<>();
     static {
+        wrapperMap.put( Void.TYPE, Void.class );
         wrapperMap.put( Boolean.TYPE, Boolean.class );
         wrapperMap.put( Byte.TYPE, Byte.class );
         wrapperMap.put( Short.TYPE, Short.class );
@@ -62,6 +63,7 @@ public final class Primitive implements Serializable {
         wrapperMap.put( Long.TYPE, Long.class );
         wrapperMap.put( Float.TYPE, Float.class );
         wrapperMap.put( Double.TYPE, Double.class );
+        wrapperMap.put( Void.class, Void.TYPE );
         wrapperMap.put( Boolean.class, Boolean.TYPE );
         wrapperMap.put( Byte.class, Byte.TYPE );
         wrapperMap.put( Short.class, Short.TYPE );
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Types.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Types.java
index f8fa5ca..870ba2e 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Types.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Types.java
@@ -28,7 +28,11 @@
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.AbstractMap.SimpleEntry;
@@ -208,6 +212,64 @@ static boolean isAssignable(Class<?> from, Class<?> to, int round) {
         }
     }
 
+    static boolean isAssignable(Class<?> from, Type to, int round) {
+        if (to instanceof Class<?>) // Handle a simple type ( like void or Integer )
+            return isAssignable(from, (Class<?>) to, round);
+
+        if (to instanceof ParameterizedType) // Handle parameterized types (like List<T>)
+            return isAssignable(from, ((ParameterizedType) to).getRawType(), round);
+
+        if (to instanceof TypeVariable<?>) { // Handle type variables (like T or R)
+            TypeVariable<?> typeVar = (TypeVariable<?>) to;
+            for (Type bound: typeVar.getBounds())
+                if (!isAssignable(from, bound, round))
+                    return false;
+            return true;
+        }
+
+        if (to instanceof WildcardType) { // Handle wildcards (like ? extends Number)
+            WildcardType wildcardType = (WildcardType) to;
+            for (Type bound: wildcardType.getUpperBounds())
+                if (!isAssignable(from, bound, round))
+                    return false;
+            for (Type bound: wildcardType.getLowerBounds())
+                if (!isAssignable(bound, from, round))
+                    return false;
+            return true;
+        }
+
+        return to == null;
+    }
+
+    static boolean isAssignable(Type from, Class<?> to, int round) {
+        if (from instanceof Class<?>) // Handle a simple type ( like void or Integer )
+            return isAssignable(from, (Class<?>) to, round);
+
+        if (from instanceof ParameterizedType) // Handle parameterized types (like List<T>)
+            return isAssignable(((ParameterizedType) from).getRawType(), to, round);
+
+        if (from instanceof TypeVariable<?>) { // Handle type variables (like T or R)
+            TypeVariable<?> typeVar = (TypeVariable<?>) from;
+            for (Type bound: typeVar.getBounds())
+                if (!isAssignable(bound, to, round))
+                    return false;
+            return true;
+        }
+
+        if (from instanceof WildcardType) { // Handle wildcards (like ? extends Number)
+            WildcardType wildcardType = (WildcardType) from;
+            for (Type bound: wildcardType.getUpperBounds())
+                if (!isAssignable(bound, to, round))
+                    return false;
+            for (Type bound: wildcardType.getLowerBounds())
+                if (!isAssignable(to, bound, round))
+                    return false;
+            return true;
+        }
+
+        return to == null;
+    }
+
     /**
      Is the 'from' signature (argument types) assignable to the 'to'
      signature (candidate method types)
@@ -226,6 +288,17 @@ static boolean isSignatureAssignable( Class<?>[] from, Class<?>[] to, int round
         return true;
     }
 
+    static boolean isSignatureAssignable( Class<?>[] from, Type[] to, int round )
+    {
+        if ( round != JAVA_VARARGS_ASSIGNABLE && from.length != to.length )
+            return false;
+
+        for (int i = 0; i < from.length; i++)
+            if (!isAssignable(from[i], to[i], round))
+                return false;
+        return true;
+    }
+
     /**
      * Are the two signatures exactly equal? This is checked for a special
      * case in overload resolution.
@@ -763,6 +836,7 @@ public static boolean isCollectionType(Class<?> clas) {
      * </pre>
      */
     public static String prettyName(Class<?> clas) {
+        if (clas == null) return "null";
         if (!clas.isArray()) return clas.getName();
 
         // Return a string like "int[]", "double[]", "double[][]", etc...
@@ -770,6 +844,65 @@ public static String prettyName(Class<?> clas) {
         return prettyName(arrayType) + "[]";
     }
 
+    public static String[] prettyNames(Type[] types) {
+        String[] result = new String[types.length];
+        for (int i = 0; i < types.length; i++) result[i] = prettyName(types[i]);
+        return result;
+    }
+
+    public static String prettyName(Type type) {
+        return prettyName(type, true);
+    }
+
+    private static String prettyName(Type type, boolean showTypeVariableBounds) {
+        if (type instanceof Class<?>) // Handle a simple type ( like void or Integer )
+            return prettyName((Class<?>) type);
+
+        if (type instanceof ParameterizedType) { // Handle parameterized types (like List<T>)
+            ParameterizedType paramType = (ParameterizedType) type;
+            Type[] params = paramType.getActualTypeArguments();
+            String[] paramsNames = new String[params.length];
+            for (int i = 0; i < params.length; i++) paramsNames[i] = prettyName(params[i], false);
+            return String.format("%s<%s>", prettyName(paramType.getRawType()), String.join(", ", paramsNames));
+        }
+
+        if (type instanceof TypeVariable<?>) { // Handle type variables (like T or R)
+            TypeVariable<?> typeVar = (TypeVariable<?>) type;
+
+            Type[] bounds = typeVar.getBounds();
+            if (!showTypeVariableBounds || (bounds.length == 1 && bounds[0] == Object.class)) return typeVar.getName();
+
+            String[] boundsStr = new String[bounds.length];
+            for (int i = 0; i < bounds.length; i++) boundsStr[i] = prettyName(bounds[i]);
+
+            return String.format("%s extends %s", typeVar.getName(), String.join(" & ", boundsStr));
+        }
+
+        if (type instanceof WildcardType) { // Handle wildcards (like '? extends Number' and '? super Integer')
+            WildcardType wildcardType = (WildcardType) type;
+
+            Type[] upperBounds = wildcardType.getUpperBounds();
+            if (upperBounds[0] != Object.class) {
+                String[] upperBoundsStr = new String[upperBounds.length];
+                for (int i = 0; i < upperBounds.length; i++) upperBoundsStr[i] = prettyName(upperBounds[i]);
+                return String.format("? extends %s", String.join(" & ", upperBoundsStr));
+            }
+
+            Type[] lowerBounds = wildcardType.getLowerBounds();
+            if (lowerBounds.length != 0) {
+                String[] lowerBoundsStr = new String[lowerBounds.length];
+                for (int i = 0; i < lowerBounds.length; i++) lowerBoundsStr[i] = prettyName(lowerBounds[i]);
+                return String.format("? super %s", String.join(" & ", lowerBoundsStr));
+            }
+
+            return "?";
+        }
+
+        if (type == null) return "null";
+
+        throw new RuntimeException("Can't return a pretty name because the type is unknown!");
+    }
+
     public static boolean isObjectClassMethod(Method m) {
         try {
             Object.class.getMethod(m.getName(), m.getParameterTypes());
@@ -780,12 +913,12 @@ public static boolean isObjectClassMethod(Method m) {
     }
 
     /** Returns if a specific class is a functional interface */
-    public static boolean isFunctionalInterface(Class<?> clas) {
-        if (clas == null || !clas.isInterface()) return false;
-        if (clas.getAnnotation(FunctionalInterface.class) != null) return true;
+    public static boolean isFunctionalInterface(Class<?> _class) {
+        if (_class == null || !_class.isInterface()) return false;
+        if (_class.getAnnotation(FunctionalInterface.class) != null) return true;
 
         int abstractCount = 0;
-        for (Method m : clas.getMethods()) {
+        for (Method m : _class.getMethods()) {
             if ( Modifier.isAbstract(m.getModifiers())
                     && !m.isBridge()
                     && !m.isSynthetic()
@@ -794,4 +927,166 @@ public static boolean isFunctionalInterface(Class<?> clas) {
         }
         return abstractCount == 1;
     }
+
+    public static bsh.org.objectweb.asm.Type getASMType(Class<?> type) {
+        return bsh.org.objectweb.asm.Type.getType(type);
+    }
+
+    public static String getInternalName(Class<?> type) {
+        return bsh.org.objectweb.asm.Type.getInternalName(type);
+    }
+
+    public static String[] getInternalNames(Class<?>[] types) {
+        final String[] internalNames = new String[types.length];
+        for (int i = 0; i < types.length; i++) internalNames[i] = bsh.org.objectweb.asm.Type.getInternalName(types[i]);
+        return internalNames;
+    }
+
+    public static String getDescriptor(Class<?> type) {
+        return bsh.org.objectweb.asm.Type.getDescriptor(type);
+    }
+
+    public static String getMethodDescriptor(Method method) {
+        return bsh.org.objectweb.asm.Type.getMethodDescriptor(method);
+    }
+
+    public static String getMethodDescriptor(Class<?> returnType, Class<?>  ...argumentTypes) {
+        final bsh.org.objectweb.asm.Type[] _types = new bsh.org.objectweb.asm.Type[argumentTypes.length];
+        for (int i = 0; i < argumentTypes.length; i++) _types[i] = bsh.org.objectweb.asm.Type.getType(argumentTypes[i]);
+        return bsh.org.objectweb.asm.Type.getMethodDescriptor(bsh.org.objectweb.asm.Type.getType(returnType), _types);
+    }
+
+    // Helper method to convert Type to ASM style signature
+    /** Return the signature of a specific type to be used in ASM bytecodes */
+    public static String getASMSignature(Type type) {
+        if (type instanceof Class<?>) return bsh.org.objectweb.asm.Type.getDescriptor((Class<?>) type); // Handle a simple type ( like void or Integer )
+
+        if (type instanceof ParameterizedType) { // Handle parameterized types (like List<T>)
+            ParameterizedType paramType = (ParameterizedType) type;
+            StringBuilder paramSignature = new StringBuilder();
+            paramSignature.append("L" + bsh.org.objectweb.asm.Type.getInternalName((Class<?>) paramType.getRawType())); // Base type
+            paramSignature.append("<");
+            for (Type arg : paramType.getActualTypeArguments()) {
+                paramSignature.append(getASMSignature(arg));
+            }
+            paramSignature.append(">;");
+            return paramSignature.toString();
+        }
+
+        if (type instanceof TypeVariable<?>) // Handle type variables (like T or R)
+            return "T" + ((TypeVariable<?>) type).getName() + ";";
+
+        if (type instanceof WildcardType) { // Handle wildcards (like ? extends Number)
+            WildcardType wildcard = (WildcardType) type;
+            Type[] lowerBounds = wildcard.getLowerBounds();
+            return lowerBounds.length > 0
+                    ? "-" + bsh.org.objectweb.asm.Type.getDescriptor((Class<?>) lowerBounds[0])
+                    : "+" + bsh.org.objectweb.asm.Type.getDescriptor((Class<?>) wildcard.getUpperBounds()[0]);
+        }
+
+        throw new IllegalArgumentException("Can't get the signature of this type because its Class is unknown: " + (type != null ? type.getClass() : null));
+    }
+
+    // TODO: testes com enums, interfaces e classes
+    public static String getASMClassSignature(TypeVariable<?>[] types, Type superClass, Type ...interfaces) {
+        StringBuilder signature = new StringBuilder();
+
+        // 1. Extract type parameters (generics)
+        if (types.length != 0) {
+            signature.append("<");
+            for (TypeVariable<?> typeParam : types) {
+                signature.append(typeParam.getName()); // Add the type variable (e.g.: "T")
+
+                for (Type bound : typeParam.getBounds()) // Add the bound of the type variable (e.g.: 'extends Number' => ":Ljava/lang/Number;")
+                    signature.append(":").append(getASMSignature(bound));
+            }
+            signature.append(">");
+        }
+
+        // 2. Add the superclass in the signature
+        signature.append(getASMSignature(superClass)); // All wrapper classes doesn't have a superclass, thus extends Object
+
+        // 3. Add interfaces in the signature
+        for (Type interface_: interfaces) signature.append(getASMSignature(interface_));
+
+        return signature.toString();
+    }
+
+    // TODO: testes com vários métodos
+    public static String getASMMethodSignature(Method method) {
+        return getASMMethodSignature(method.getTypeParameters(), method.getGenericParameterTypes(), method.getGenericReturnType(), method.getGenericExceptionTypes());
+    }
+
+    public static String getASMMethodSignature(TypeVariable<?>[] types, Type[] params, Type returnType, Type[] exceptions) {
+        StringBuilder signature = new StringBuilder();
+
+        // 1. Handle generic type parameters (if any)
+        if (types.length > 0) {
+            signature.append("<");
+            for (TypeVariable<?> typeParam : types) {
+                signature.append(typeParam.getName()); // Add type variable (e.g., "T")
+                for (Type bound : typeParam.getBounds())
+                    signature.append(":").append(getASMSignature(bound)); // Add the bound
+            }
+            signature.append(">");
+        }
+
+        // 2. Add the method parameter types
+        signature.append("(");
+        for (Type param : params) signature.append(getASMSignature(param));
+        signature.append(")");
+
+        // 3. Add the return type
+        signature.append(getASMSignature(returnType));
+
+        // 4. Add the exception types (if any)
+        for (Type exceptionType : exceptions) signature.append("^").append(getASMSignature(exceptionType));
+
+        return signature.toString();
+    }
+
+    // if (type instanceof ParameterizedType) { // Handle parameterized types (like List<T>)
+    //     ParameterizedType paramType = (ParameterizedType) type;
+    //     StringBuilder paramSignature = new StringBuilder();
+    //     paramSignature.append("L" + bsh.org.objectweb.asm.Type.getInternalName((Class<?>) paramType.getRawType())); // Base type
+    //     paramSignature.append("<");
+    //     for (Type arg : paramType.getActualTypeArguments()) {
+    //         paramSignature.append(getASMSignature(arg));
+    //     }
+    //     paramSignature.append(">;");
+    //     return paramSignature.toString();
+    // }
+
+    // // if (type instanceof TypeVariable<?>) // Handle type variables (like T or R)
+    // //     return "T" + ((TypeVariable<?>) type).getName() + ";";
+    // public static TypeVariable<?> createTypeVariable(String name, Type[] bounds) {
+    //     // TODO: see it!
+    //     // bounds = bounds == null || bounds.length == 0 ? new Type[] { Object.class } : bounds;
+
+    //     return new TypeVariable<GenericDeclaration>() {
+    //         public String getName() { return name; }
+    //         public <T extends Annotation> T getAnnotation(Class<T> annotationClass) { return null; }
+    //         public Annotation[] getAnnotations() { return new Annotation[0]; }
+    //         public Annotation[] getDeclaredAnnotations() { return new Annotation[0]; }
+    //         public AnnotatedType[] getAnnotatedBounds() { throw new UnsupportedOperationException("Unimplemented method 'getAnnotatedBounds'"); }
+    //         public Type[] getBounds() { return bounds; }
+    //         public GenericDeclaration getGenericDeclaration() { throw new UnsupportedOperationException("Unimplemented method 'getGenericDeclaration'"); };
+    //     };
+    // }
+    public static ParameterizedType createParameterizedType(Type rawType, Type[] typeArguments) {
+        return new ParameterizedType() {
+            public Type[] getActualTypeArguments() { return typeArguments; }
+            public Type getRawType() { return rawType; }
+            public Type getOwnerType() { return null; }
+        };
+    }
+
+    // if (type instanceof WildcardType) { // Handle wildcards (like ? extends Number)
+    //     WildcardType wildcard = (WildcardType) type;
+    //     Type[] lowerBounds = wildcard.getLowerBounds();
+    //     return lowerBounds.length > 0
+    //             ? "-" + bsh.org.objectweb.asm.Type.getDescriptor((Class<?>) lowerBounds[0])
+    //             : "+" + bsh.org.objectweb.asm.Type.getDescriptor((Class<?>) wildcard.getUpperBounds()[0]);
+    // }
+
 }
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/util/Util.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/util/Util.java
new file mode 100644
index 0000000..fea9b18
--- /dev/null
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/util/Util.java
@@ -0,0 +1,64 @@
+/*****************************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one                *
+ * or more contributor license agreements.  See the NOTICE file              *
+ * distributed with this work for additional information                     *
+ * regarding copyright ownership.  The ASF licenses this file                *
+ * to you 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.                                                        *
+ *                                                                           *
+ *                                                                           *
+ * This file is part of the BeanShell Java Scripting distribution.           *
+ * Documentation and updates may be found at http://www.beanshell.org/       *
+ * Patrick Niemeyer (pat@pat.net)                                            *
+ * Author of Learning Java, O'Reilly & Associates                            *
+ *                                                                           *
+ *****************************************************************************/
+package bsh.util;
+
+import java.lang.reflect.Array;
+
+/**
+    Misc utilities for the bsh.util package.
+    Nothing in the core language (bsh package) should depend on this.
+    Note: that promise is currently broken... fix it.
+*/
+public class Util
+{
+    /** Just concat 2 arrays */
+    @SuppressWarnings("unchecked")
+    public static <T> T[] concatArrays(T[] ...arrays) {
+        if (arrays.length == 0) throw new NullPointerException("There is no arrays to concat!");
+        if (arrays.length == 1) return arrays[0];
+
+        int totalLength = 0;
+        for (T[] array: arrays) totalLength += array.length;
+
+        final Class<?> baseType = arrays[0].getClass().getComponentType();
+        T[] result = (T[]) Array.newInstance(baseType, totalLength);
+
+        int offset = 0;
+        for (T[] array: arrays) {
+            System.arraycopy(array, 0, result, offset, array.length);
+            offset += array.length;
+        }
+
+        // final Class<?> baseType = a.getClass().getComponentType();
+        // T[] result = (T[]) Array.newInstance(baseType, a.length + b.length);
+
+        // System.arraycopy(baseType, 0, result, 0, 0);
+        // for (int i = 0; i < a.length; i++) result[i] = a[i];
+        // for (int i = 0; i < b.length; i++) result[i + a.length] = b[i];
+
+        return result;
+    }
+}

From 7348bc8b45d108f39e2045fc42a6fa2d273741a2 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 23 Apr 2026 00:02:18 +0800
Subject: [PATCH 02/27] feat: ignore annotations while preserving @ operator
 aliases

---
 .../src/main/java/bsh/Interpreter.java        |   4 +-
 .../AnnotationIgnorePreprocess.java           | 259 ++++++++++++++++++
 2 files changed, 262 insertions(+), 1 deletion(-)
 create mode 100644 bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/AnnotationIgnorePreprocess.java

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
index 54b4158..df627ed 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
@@ -41,9 +41,10 @@
 import java.net.URL;
 import java.util.ResourceBundle;
 
+import bsh.preprocess.AnnotationIgnorePreprocess;
 import bsh.preprocess.DefaultArgsDesugar;
-import bsh.security.MainSecurityGuard;
 import bsh.preprocess.KtStringTemplate;
+import bsh.security.MainSecurityGuard;
 
 /**
     The BeanShell script interpreter.
@@ -845,6 +846,7 @@ private String readSource(Reader in, String sourceFileInfo) throws EvalError {
 
     private String preprocessScript(String source) {
         String rewritten = source;
+        rewritten = AnnotationIgnorePreprocess.rewrite(rewritten);
         rewritten = DefaultArgsDesugar.rewrite(rewritten);
         rewritten = KtStringTemplate.rewrite(rewritten);
         return rewritten;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/AnnotationIgnorePreprocess.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/AnnotationIgnorePreprocess.java
new file mode 100644
index 0000000..3a2e9d9
--- /dev/null
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/AnnotationIgnorePreprocess.java
@@ -0,0 +1,259 @@
+package bsh.preprocess;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Removes Java/Kotlin annotation usages from script text while preserving
+ * BeanShell @-operator aliases (e.g. @gt, @and, @pow_assign).
+ */
+public final class AnnotationIgnorePreprocess {
+    private static final Set<String> BSH_AT_OPERATORS = new HashSet<String>(Arrays.asList(
+            "gt", "lt", "lteq", "gteq", "or", "and",
+            "bitwise_and", "bitwise_or", "bitwise_xor",
+            "mod", "pow", "left_shift", "right_shift", "right_unsigned_shift",
+            "and_assign", "or_assign", "xor_assign", "mod_assign", "pow_assign",
+            "left_shift_assign", "right_shift_assign", "right_unsigned_shift_assign"
+    ));
+
+    private AnnotationIgnorePreprocess() {
+    }
+
+    public static String rewrite(String source) {
+        if (source == null || source.indexOf('@') < 0) {
+            return source;
+        }
+
+        final int len = source.length();
+        StringBuilder out = new StringBuilder(len);
+        int i = 0;
+
+        while (i < len) {
+            int skip = skipLiteralOrComment(source, i);
+            if (skip > i) {
+                out.append(source, i, skip);
+                i = skip;
+                continue;
+            }
+
+            if (source.charAt(i) != '@') {
+                out.append(source.charAt(i));
+                i++;
+                continue;
+            }
+
+            int operatorEnd = parseBshOperatorAlias(source, i);
+            if (operatorEnd > i) {
+                out.append(source, i, operatorEnd);
+                i = operatorEnd;
+                continue;
+            }
+
+            int annotationEnd = parseAnnotationEnd(source, i);
+            if (annotationEnd > i) {
+                // Keep line separators stable while removing annotation tokens.
+                for (int j = i; j < annotationEnd; j++) {
+                    char c = source.charAt(j);
+                    if (c == '\n' || c == '\r') {
+                        out.append(c);
+                    }
+                }
+                i = annotationEnd;
+                while (i < len && (source.charAt(i) == ' ' || source.charAt(i) == '\t')) {
+                    i++;
+                }
+                continue;
+            }
+
+            out.append('@');
+            i++;
+        }
+
+        return out.toString();
+    }
+
+    private static int parseBshOperatorAlias(String source, int atPos) {
+        int len = source.length();
+        int start = atPos + 1;
+        if (start >= len || !isAliasPart(source.charAt(start))) {
+            return -1;
+        }
+        int end = start;
+        while (end < len && isAliasPart(source.charAt(end))) {
+            end++;
+        }
+        String alias = source.substring(start, end);
+        if (!BSH_AT_OPERATORS.contains(alias)) {
+            return -1;
+        }
+        if (end < len && Character.isJavaIdentifierPart(source.charAt(end))) {
+            return -1;
+        }
+        return end;
+    }
+
+    private static int parseAnnotationEnd(String source, int atPos) {
+        int len = source.length();
+        int i = atPos + 1;
+        if (i >= len || !Character.isJavaIdentifierStart(source.charAt(i))) {
+            return -1;
+        }
+
+        while (i < len && Character.isJavaIdentifierPart(source.charAt(i))) {
+            i++;
+        }
+        if (source.substring(atPos + 1, i).equals("interface")) {
+            return -1;
+        }
+
+        while (i < len && source.charAt(i) == '.') {
+            int segStart = ++i;
+            if (segStart >= len || !Character.isJavaIdentifierStart(source.charAt(segStart))) {
+                return -1;
+            }
+            while (i < len && Character.isJavaIdentifierPart(source.charAt(i))) {
+                i++;
+            }
+        }
+
+        while (i < len && isInlineWhitespace(source.charAt(i))) {
+            i++;
+        }
+
+        if (i < len && source.charAt(i) == '(') {
+            int end = findMatchingParen(source, i);
+            if (end < 0) {
+                return -1;
+            }
+            i = end + 1;
+        }
+        return i;
+    }
+
+    private static int findMatchingParen(String source, int openPos) {
+        final int len = source.length();
+        int depth = 0;
+        for (int i = openPos; i < len; i++) {
+            int skip = skipLiteralOrComment(source, i);
+            if (skip > i) {
+                i = skip - 1;
+                continue;
+            }
+
+            char ch = source.charAt(i);
+            if (ch == '(') {
+                depth++;
+            } else if (ch == ')') {
+                depth--;
+                if (depth == 0) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private static int skipLiteralOrComment(String source, int i) {
+        final int len = source.length();
+        if (i >= len) {
+            return i;
+        }
+        char ch = source.charAt(i);
+
+        if (ch == '"') {
+            if (isTripleQuote(source, i)) {
+                int end = findTripleQuoteEnd(source, i + 3);
+                return end < 0 ? len : end + 3;
+            }
+            int end = findNormalStringEnd(source, i + 1);
+            return end < 0 ? len : end + 1;
+        }
+
+        if (ch == '\'') {
+            int end = findCharLiteralEnd(source, i + 1);
+            return end < 0 ? len : end + 1;
+        }
+
+        if (ch == '/' && i + 1 < len) {
+            char next = source.charAt(i + 1);
+            if (next == '/') {
+                int j = i + 2;
+                while (j < len && source.charAt(j) != '\n' && source.charAt(j) != '\r') {
+                    j++;
+                }
+                return j;
+            }
+            if (next == '*') {
+                int end = findBlockCommentEnd(source, i + 2);
+                return end < 0 ? len : end + 2;
+            }
+        }
+
+        return i;
+    }
+
+    private static int findNormalStringEnd(String text, int start) {
+        for (int i = start; i < text.length(); i++) {
+            char ch = text.charAt(i);
+            if (ch == '\\') {
+                i++;
+                continue;
+            }
+            if (ch == '"') {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static int findCharLiteralEnd(String text, int start) {
+        for (int i = start; i < text.length(); i++) {
+            char ch = text.charAt(i);
+            if (ch == '\\') {
+                i++;
+                continue;
+            }
+            if (ch == '\'') {
+                return i;
+            }
+            if (ch == '\n' || ch == '\r') {
+                return -1;
+            }
+        }
+        return -1;
+    }
+
+    private static int findBlockCommentEnd(String text, int start) {
+        for (int i = start; i + 1 < text.length(); i++) {
+            if (text.charAt(i) == '*' && text.charAt(i + 1) == '/') {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static boolean isTripleQuote(String text, int index) {
+        return index + 2 < text.length()
+                && text.charAt(index) == '"'
+                && text.charAt(index + 1) == '"'
+                && text.charAt(index + 2) == '"';
+    }
+
+    private static int findTripleQuoteEnd(String text, int start) {
+        for (int i = start; i + 2 < text.length(); i++) {
+            if (isTripleQuote(text, i)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static boolean isAliasPart(char ch) {
+        return ch == '_' || Character.isLetterOrDigit(ch);
+    }
+
+    private static boolean isInlineWhitespace(char ch) {
+        return ch == ' ' || ch == '\t' || ch == '\f';
+    }
+}

From c7fde8fce9fcb94bd62390c23fac5c18d25d5191 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 23 Apr 2026 10:01:07 +0800
Subject: [PATCH 03/27] perf: complete field set permission checks in security
 guard flow

---
 .../src/main/java/bsh/LHS.java                |  6 +++
 .../java/bsh/security/MainSecurityGuard.java  | 51 +++++++++++++++++++
 .../main/java/bsh/security/SecurityError.java | 31 +++++++++--
 .../main/java/bsh/security/SecurityGuard.java | 10 +++-
 4 files changed, 94 insertions(+), 4 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/LHS.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/LHS.java
index ae04af7..94a1f0d 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/LHS.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/LHS.java
@@ -275,6 +275,12 @@ public Object assign( Object val, boolean strictJava )
                 nameSpace.setVariableOrProperty( varName, val, strictJava );
             return getValueImpl();
         } else  if ( type == FIELD )  try {
+            // Validate if can set this field
+            if (Reflect.isStatic(field))
+                Interpreter.mainSecurityGuard.canSetStaticField(field.getDeclaringClass(), field.getName(), val);
+            else
+                Interpreter.mainSecurityGuard.canSetField(object, field.getName(), val);
+
             Objects.requireNonNull(field,
                 "assign value, field cannot be null").invoke( object, val);
             return getValueImpl();
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/security/MainSecurityGuard.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/security/MainSecurityGuard.java
index 0881751..b4a93d0 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/security/MainSecurityGuard.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/security/MainSecurityGuard.java
@@ -73,6 +73,7 @@ private void canInvokeStaticMethodImplToReflectionCanGetArrayLength(Class<?> _cl
     public void canInvokeMethod(Object thisArg, String methodName, Object[] args) throws SecurityError {
         final Object[] _args = Primitive.unwrap(args);
         this.canInvokeMethodImpl(thisArg, methodName, _args);
+        this.canInvokeMethodImplToReflectionCanSetField(thisArg, methodName, _args);
         this.canInvokeMethodImplToReflectionCanGetField(thisArg, methodName, _args);
         this.canInvokeMethodImplToReflectionCanConstruct(thisArg, methodName, _args);
         this.canInvokeMethodImplToReflectionCanInvokeMethod(thisArg, methodName, _args);
@@ -109,6 +110,31 @@ private final void canInvokeMethodImplToReflectionCanGetField(Object thisArg, St
         }
     }
 
+    /** Validate if can set a field when using Reflection API */
+    private final void canInvokeMethodImplToReflectionCanSetField(Object thisArg, String methodName, Object[] args) throws SecurityError {
+        if (!methodName.equals("set") || args.length != 2 || !(thisArg instanceof Field)) return;
+
+        Field field = (Field) thisArg;
+        String fieldName = field.getName();
+        Object value = args[1];
+
+        if (Reflect.isStatic(field)) {
+            Class<?> _class = field.getDeclaringClass();
+            try {
+                this.canSetStaticField(_class, fieldName, value);
+            } catch (SecurityError error) {
+                throw SecurityError.reflectCantSetStaticField(_class, fieldName, value);
+            }
+        } else {
+            Object _thisArg = args[0];
+            try {
+                this.canSetField(_thisArg, fieldName, value);
+            } catch (SecurityError error) {
+                throw SecurityError.reflectCantSetField(_thisArg, fieldName, value);
+            }
+        }
+    }
+
     /** Validate if can invoke a method when using Reflection API */
     private final void canInvokeMethodImplToReflectionCanInvokeMethod(Object thisArg, String methodName, Object[] args) throws SecurityError {
         if (!methodName.equals("invoke") || args.length == 0 || !(thisArg instanceof Method)) return;
@@ -170,6 +196,22 @@ public void canInvokeLocalMethod(String methodName, Object[] args) throws Securi
                 throw SecurityError.cantInvokeLocalMethod(methodName, _args);
     }
 
+    /** Validate if can set a field of a specific object */
+    public void canSetField(Object thisArg, String fieldName, Object value) throws SecurityError {
+        final Object _value = Primitive.unwrap(value);
+        for (SecurityGuard guard: this.securityGuards)
+            if (!guard.canSetField(thisArg, fieldName, _value))
+                throw SecurityError.cantSetField(thisArg, fieldName, _value);
+    }
+
+    /** Validate if can set a static field of a specific class */
+    public void canSetStaticField(Class<?> _class, String fieldName, Object value) throws SecurityError {
+        final Object _value = Primitive.unwrap(value);
+        for (SecurityGuard guard: this.securityGuards)
+            if (!guard.canSetStaticField(_class, fieldName, _value))
+                throw SecurityError.cantSetStaticField(_class, fieldName, _value);
+    }
+
     /** Validate if can get a field of a specific object */
     public void canGetField(Object thisArg, String fieldName) throws SecurityError {
         for (SecurityGuard guard: this.securityGuards)
@@ -211,6 +253,15 @@ public boolean canInvokeMethod(Object thisArg, String methodName, Object[] args)
             return !(thisArg instanceof MainSecurityGuard);
         }
 
+        public boolean canSetField(Object thisArg, String fieldName, Object value) {
+            return !(thisArg instanceof MainSecurityGuard);
+        }
+
+        public boolean canSetStaticField(Class<?> _class, String fieldName, Object value) {
+            if (_class == Interpreter.class && fieldName.equals("mainSecurityGuard")) return false;
+            return true;
+        }
+
         public boolean canGetStaticField(Class<?> _class, String fieldName) {
             if (_class == Interpreter.class && fieldName.equals("mainSecurityGuard")) return false;
             return true;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityError.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityError.java
index 5c17558..72a201c 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityError.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityError.java
@@ -1,8 +1,5 @@
 package bsh.security;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import bsh.CallStack;
 import bsh.EvalError;
 import bsh.Node;
@@ -78,6 +75,34 @@ static SecurityError cantInvokeLocalMethod(String methodName, Object[] args) {
         return new SecurityError(msg);
     }
 
+    /** Create a error for when can't set a field */
+    static SecurityError cantSetField(Object thisArg, String fieldName, Object value) {
+        String msg = String.format("Can't set this field: %s.%s (%s)",
+                thisArg.getClass().getTypeName(), fieldName, argsTypesString(new Object[] { value }));
+        return new SecurityError(msg);
+    }
+
+    /** Create a error for when can't set a field using reflection */
+    static SecurityError reflectCantSetField(Object thisArg, String fieldName, Object value) {
+        String msg = String.format("Can't set this field using reflection: %s.%s (%s)",
+                thisArg.getClass().getTypeName(), fieldName, argsTypesString(new Object[] { value }));
+        return new SecurityError(msg);
+    }
+
+    /** Create a error for when can't set a static field */
+    static SecurityError cantSetStaticField(Class<?> _class, String fieldName, Object value) {
+        String msg = String.format("Can't set this static field: %s.%s (%s)",
+                _class.getTypeName(), fieldName, argsTypesString(new Object[] { value }));
+        return new SecurityError(msg);
+    }
+
+    /** Create a error for when can't set a static field using reflection */
+    static SecurityError reflectCantSetStaticField(Class<?> _class, String fieldName, Object value) {
+        String msg = String.format("Can't set this static field using reflection: %s.%s (%s)",
+                _class.getTypeName(), fieldName, argsTypesString(new Object[] { value }));
+        return new SecurityError(msg);
+    }
+
     /** Create a error for when can't get a field */
     static SecurityError cantGetField(Object thisArg, String fieldName) {
         String msg = String.format("Can't get this field: %s.%s", thisArg.getClass().getTypeName(), fieldName);
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityGuard.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityGuard.java
index 219f6f3..de19545 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityGuard.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/security/SecurityGuard.java
@@ -27,7 +27,15 @@ public default boolean canInvokeLocalMethod(String methodName, Object[] args) {
         return true;
     }
 
-    // TODO: implement a 'canSetField' and 'canSetStaticField'
+    /** Validate and return if can set a field of a specific object */
+    public default boolean canSetField(Object thisArg, String fieldName, Object value) {
+        return true;
+    }
+
+    /** Validate and return if can set a static field of a specific class */
+    public default boolean canSetStaticField(Class<?> _class, String fieldName, Object value) {
+        return true;
+    }
 
     /** Validate and return if can get a field of a specific object */
     public default boolean canGetField(Object thisArg, String fieldName) {

From 39a9f820859e5088cd010d99324e855b5af83acc Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 23 Apr 2026 12:36:10 +0800
Subject: [PATCH 04/27] feat: support kotlin-style is type check operator

---
 README.md                                     |   5 +
 .../src/main/java/bsh/Parser.java             | 589 ++++++------
 .../src/main/java/bsh/ParserConstants.java    | 233 ++---
 .../src/main/java/bsh/ParserTokenManager.java | 882 +++++++++---------
 .../src/main/jjtree/bsh.jjt                   |   6 +-
 5 files changed, 874 insertions(+), 841 deletions(-)

diff --git a/README.md b/README.md
index 170fc65..c899fcf 100644
--- a/README.md
+++ b/README.md
@@ -115,6 +115,11 @@ void hi(String name, int age = 18) {
 }
 hi("user") // name: user, age: 18
 hi("user", 1) // name: user, age: 1
+
+// 类型判断
+print("abc" is String) // true
+print(123 is Number) // true
+print(null is Object) // false
 ```
 
 ## 致谢
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
index eb1acfc..d765b35 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
@@ -2049,35 +2049,49 @@ final public void ConditionalExpression() throws ParseException {
     }
 }
 
-  final public void InstanceOfExpression() throws ParseException {Token t = null;
+  final public void InstanceOfExpression() throws ParseException {
     RelationalExpression();
     switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
-    case INSTANCEOF:{
-      t = jj_consume_token(INSTANCEOF);
+    case INSTANCEOF:
+    case IS:{
+      switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
+      case INSTANCEOF:{
+        jj_consume_token(INSTANCEOF);
+        break;
+        }
+      case IS:{
+        jj_consume_token(IS);
+        break;
+        }
+      default:
+        jj_la1[51] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
       Type();
 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
-                             boolean jjtc001 = true;
-                             jjtree.openNodeScope(jjtn001);
-                             jjtreeOpenNodeScope(jjtn001);
+      boolean jjtc001 = true;
+      jjtree.openNodeScope(jjtn001);
+      jjtreeOpenNodeScope(jjtn001);
       try {
 jjtree.closeNodeScope(jjtn001,  2);
-                             jjtc001 = false;
-                             if (jjtree.nodeCreated()) {
-                              jjtreeCloseNodeScope(jjtn001);
-                             }
-jjtn001.kind = t.kind;
+      jjtc001 = false;
+      if (jjtree.nodeCreated()) {
+       jjtreeCloseNodeScope(jjtn001);
+      }
+jjtn001.kind = INSTANCEOF;
       } finally {
 if (jjtc001) {
-                               jjtree.closeNodeScope(jjtn001,  2);
-                               if (jjtree.nodeCreated()) {
-                                jjtreeCloseNodeScope(jjtn001);
-                               }
-                             }
+        jjtree.closeNodeScope(jjtn001,  2);
+        if (jjtree.nodeCreated()) {
+         jjtreeCloseNodeScope(jjtn001);
+        }
+      }
       }
       break;
       }
     default:
-      jj_la1[51] = jj_gen;
+      jj_la1[52] = jj_gen;
       ;
     }
 }
@@ -2098,7 +2112,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[52] = jj_gen;
+        jj_la1[53] = jj_gen;
         break label_18;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2135,7 +2149,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[53] = jj_gen;
+        jj_la1[54] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2176,7 +2190,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[54] = jj_gen;
+        jj_la1[55] = jj_gen;
         break label_19;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2205,7 +2219,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[55] = jj_gen;
+        jj_la1[56] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2242,7 +2256,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[56] = jj_gen;
+        jj_la1[57] = jj_gen;
         break label_20;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2255,7 +2269,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[57] = jj_gen;
+        jj_la1[58] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2294,7 +2308,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[58] = jj_gen;
+        jj_la1[59] = jj_gen;
         break label_21;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2315,7 +2329,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[59] = jj_gen;
+        jj_la1[60] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2352,7 +2366,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[60] = jj_gen;
+        jj_la1[61] = jj_gen;
         break label_22;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2365,7 +2379,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[61] = jj_gen;
+        jj_la1[62] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2416,7 +2430,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[62] = jj_gen;
+        jj_la1[63] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2454,7 +2468,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[63] = jj_gen;
+        jj_la1[64] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2481,7 +2495,7 @@ final public void ConditionalExpression() throws ParseException {
       break;
       }
     default:
-      jj_la1[66] = jj_gen;
+      jj_la1[67] = jj_gen;
       if (jj_2_10(2147483647)) {
         LambdaExpression();
       } else if (jj_2_11(2147483647)) {
@@ -2524,7 +2538,7 @@ final public void ConditionalExpression() throws ParseException {
               break;
               }
             default:
-              jj_la1[64] = jj_gen;
+              jj_la1[65] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -2550,13 +2564,13 @@ final public void ConditionalExpression() throws ParseException {
             break;
             }
           default:
-            jj_la1[65] = jj_gen;
+            jj_la1[66] = jj_gen;
             ;
           }
           break;
           }
         default:
-          jj_la1[67] = jj_gen;
+          jj_la1[68] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2685,7 +2699,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[68] = jj_gen;
+        jj_la1[69] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2727,7 +2741,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[69] = jj_gen;
+        jj_la1[70] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2788,7 +2802,7 @@ final public void PrimaryPrefix() throws ParseException {
       break;
       }
     default:
-      jj_la1[70] = jj_gen;
+      jj_la1[71] = jj_gen;
       if (jj_2_13(2147483647)) {
         MethodInvocation();
       } else if (jj_2_14(2147483647)) {
@@ -2800,7 +2814,7 @@ final public void PrimaryPrefix() throws ParseException {
           break;
           }
         default:
-          jj_la1[71] = jj_gen;
+          jj_la1[72] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2861,7 +2875,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
             break;
             }
           default:
-            jj_la1[72] = jj_gen;
+            jj_la1[73] = jj_gen;
             ;
           }
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2903,7 +2917,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[73] = jj_gen;
+                jj_la1[74] = jj_gen;
                 ;
               }
 jjtn000.slice = true; jjtn000.step = true;
@@ -2946,7 +2960,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[74] = jj_gen;
+                jj_la1[75] = jj_gen;
                 ;
               }
               switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2986,26 +3000,26 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                   break;
                   }
                 default:
-                  jj_la1[75] = jj_gen;
+                  jj_la1[76] = jj_gen;
                   ;
                 }
                 break;
                 }
               default:
-                jj_la1[76] = jj_gen;
+                jj_la1[77] = jj_gen;
                 ;
               }
               break;
               }
             default:
-              jj_la1[77] = jj_gen;
+              jj_la1[78] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
             break;
             }
           default:
-            jj_la1[78] = jj_gen;
+            jj_la1[79] = jj_gen;
             ;
           }
           jj_consume_token(RBRACKET);
@@ -3018,7 +3032,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
           break;
           }
         default:
-          jj_la1[82] = jj_gen;
+          jj_la1[83] = jj_gen;
           if (getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET) {
             jj_consume_token(COLON_COLON);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3031,7 +3045,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[79] = jj_gen;
+              jj_la1[80] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -3043,7 +3057,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
 jjtn000.operation = BSHPrimarySuffix.METHODREF;
     jjtn000.field = t.image;
           } else if (jj_2_16(2)) {
-            jj_consume_token(152);
+            jj_consume_token(153);
             t = jj_consume_token(IDENTIFIER);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
             case LPAREN:{
@@ -3051,7 +3065,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[80] = jj_gen;
+              jj_la1[81] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3071,7 +3085,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[81] = jj_gen;
+              jj_la1[82] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3096,7 +3110,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[83] = jj_gen;
+              jj_la1[84] = jj_gen;
               if (jj_2_18(2)) {
                 jj_consume_token(DOT);
                 AllocationExpression();
@@ -3265,7 +3279,7 @@ final public void Literal() throws ParseException {/*@bgen(jjtree) Literal */
         break;
         }
       default:
-        jj_la1[84] = jj_gen;
+        jj_la1[85] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3306,7 +3320,7 @@ final public boolean BooleanLiteral() throws ParseException {
       break;
       }
     default:
-      jj_la1[85] = jj_gen;
+      jj_la1[86] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
@@ -3361,7 +3375,7 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
         break;
         }
       default:
-        jj_la1[86] = jj_gen;
+        jj_la1[87] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -3399,7 +3413,7 @@ final public void ArgumentList() throws ParseException {
         break;
         }
       default:
-        jj_la1[87] = jj_gen;
+        jj_la1[88] = jj_gen;
         break label_24;
       }
       jj_consume_token(COMMA);
@@ -3447,7 +3461,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[88] = jj_gen;
+            jj_la1[89] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3459,7 +3473,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[89] = jj_gen;
+          jj_la1[90] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3471,7 +3485,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[90] = jj_gen;
+        jj_la1[91] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3540,7 +3554,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
               break;
               }
             default:
-              jj_la1[91] = jj_gen;
+              jj_la1[92] = jj_gen;
               break label_27;
             }
           }
@@ -3558,7 +3572,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
           break;
           }
         default:
-          jj_la1[92] = jj_gen;
+          jj_la1[93] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3651,7 +3665,7 @@ void Statement() throws ParseException {
         break;
         }
       default:
-        jj_la1[93] = jj_gen;
+        jj_la1[94] = jj_gen;
         if (isRegularForStatement()) {
           ForStatement();
         } else {
@@ -3685,7 +3699,7 @@ void Statement() throws ParseException {
             break;
             }
           default:
-            jj_la1[94] = jj_gen;
+            jj_la1[95] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3745,7 +3759,7 @@ final public void Block() throws ParseException {/*@bgen(jjtree) Block */
         break;
         }
       default:
-        jj_la1[95] = jj_gen;
+        jj_la1[96] = jj_gen;
         ;
       }
       jj_consume_token(LBRACE);
@@ -3811,7 +3825,7 @@ final public void BlockStatement() throws ParseException {
         break;
         }
       default:
-        jj_la1[96] = jj_gen;
+        jj_la1[97] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3829,7 +3843,7 @@ final public void MethodDeclTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[97] = jj_gen;
+      jj_la1[98] = jj_gen;
       if (isImplicitMethodTerminator()) {
 
       } else {
@@ -3846,7 +3860,7 @@ final public void StatementTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[98] = jj_gen;
+      jj_la1[99] = jj_gen;
       ;
     }
 }
@@ -3870,11 +3884,11 @@ final public void SwitchStatement() throws ParseException {/*@bgen(jjtree) Switc
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CASE:
-        case 153:{
+        case 154:{
           break;
           }
         default:
-          jj_la1[99] = jj_gen;
+          jj_la1[100] = jj_gen;
           break label_29;
         }
         SwitchLabel();
@@ -3925,8 +3939,8 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         jj_consume_token(COLON);
         break;
         }
-      case 153:{
-        jj_consume_token(153);
+      case 154:{
+        jj_consume_token(154);
 jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                if (jjtree.nodeCreated()) {
@@ -3936,7 +3950,7 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         break;
         }
       default:
-        jj_la1[100] = jj_gen;
+        jj_la1[101] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3981,7 +3995,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[101] = jj_gen;
+        jj_la1[102] = jj_gen;
         if (jj_2_32(1)) {
           Statement();
         } else {
@@ -3996,7 +4010,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[102] = jj_gen;
+        jj_la1[103] = jj_gen;
         ;
       }
     } catch (Throwable jjte000) {
@@ -4159,7 +4173,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[103] = jj_gen;
+        jj_la1[104] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4197,7 +4211,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[104] = jj_gen;
+        jj_la1[105] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4235,7 +4249,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[105] = jj_gen;
+        jj_la1[106] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -4299,7 +4313,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[106] = jj_gen;
+            jj_la1[107] = jj_gen;
             ;
           }
           Type();
@@ -4317,7 +4331,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[107] = jj_gen;
+          jj_la1[108] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4383,7 +4397,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[108] = jj_gen;
+        jj_la1[109] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4412,7 +4426,7 @@ final public void TypedVariableDeclaration() throws ParseException {/*@bgen(jjtr
           break;
           }
         default:
-          jj_la1[109] = jj_gen;
+          jj_la1[110] = jj_gen;
           break label_31;
         }
         jj_consume_token(COMMA);
@@ -4462,7 +4476,7 @@ final public void StatementExpressionList() throws ParseException {/*@bgen(jjtre
           break;
           }
         default:
-          jj_la1[110] = jj_gen;
+          jj_la1[111] = jj_gen;
           break label_32;
         }
         jj_consume_token(COMMA);
@@ -4714,7 +4728,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[111] = jj_gen;
+        jj_la1[112] = jj_gen;
         ;
       }
       Block();
@@ -4725,7 +4739,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
           break;
           }
         default:
-          jj_la1[112] = jj_gen;
+          jj_la1[113] = jj_gen;
           break label_33;
         }
         jj_consume_token(CATCH);
@@ -4743,7 +4757,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[113] = jj_gen;
+        jj_la1[114] = jj_gen;
         ;
       }
 jjtree.closeNodeScope(jjtn000, true);
@@ -4790,7 +4804,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[114] = jj_gen;
+          jj_la1[115] = jj_gen;
           ;
         }
         Type();
@@ -4801,7 +4815,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
             break;
             }
           default:
-            jj_la1[115] = jj_gen;
+            jj_la1[116] = jj_gen;
             break label_34;
           }
           jj_consume_token(BIT_OR);
@@ -4827,7 +4841,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[116] = jj_gen;
+          jj_la1[117] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4871,7 +4885,7 @@ final public void TryWithResources() throws ParseException {/*@bgen(jjtree) TryW
           break;
           }
         default:
-          jj_la1[117] = jj_gen;
+          jj_la1[118] = jj_gen;
           break label_35;
         }
         jj_consume_token(SEMICOLON);
@@ -4918,7 +4932,7 @@ final public void AutoCloseable() throws ParseException {/*@bgen(jjtree) AutoClo
           break;
           }
         default:
-          jj_la1[118] = jj_gen;
+          jj_la1[119] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5327,6 +5341,18 @@ private boolean jj_2_38(int xla)
     finally { jj_save(37, xla); }
   }
 
+  private boolean jj_3R_169()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(104)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(105)) return true;
+    }
+    if (jj_3R_168()) return true;
+    return false;
+  }
+
   private boolean jj_3_34()
  {
     if (jj_3R_53()) return true;
@@ -5350,13 +5376,13 @@ private boolean jj_3R_171()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(105)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(106)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(113)) {
+    if (jj_scan_token(107)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(114)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(114)) return true;
+    if (jj_scan_token(115)) return true;
     }
     }
     }
@@ -5398,9 +5424,9 @@ private boolean jj_3R_173()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(115)) {
+    if (jj_scan_token(116)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(116)) return true;
+    if (jj_scan_token(117)) return true;
     }
     if (jj_3R_172()) return true;
     return false;
@@ -5441,13 +5467,13 @@ private boolean jj_3R_174()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(103)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(104)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(90)) {
+    if (jj_scan_token(105)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(89)) return true;
+    if (jj_scan_token(91)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(90)) return true;
     }
     }
     }
@@ -5465,9 +5491,9 @@ private boolean jj_3R_175()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(101)) {
+    if (jj_scan_token(102)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(102)) return true;
+    if (jj_scan_token(103)) return true;
     }
     if (jj_3R_181()) return true;
     return false;
@@ -5532,7 +5558,7 @@ private boolean jj_3_10()
     xsp = jj_scanpos;
     if (jj_3R_46()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(72)) return true;
+    if (jj_scan_token(73)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     return false;
@@ -5632,9 +5658,9 @@ private boolean jj_3R_182()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(101)) {
+    if (jj_scan_token(102)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(102)) return true;
+    if (jj_scan_token(103)) return true;
     }
     return false;
   }
@@ -5645,7 +5671,7 @@ private boolean jj_3R_179()
     xsp = jj_scanpos;
     if (jj_3R_183()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(72)) return true;
+    if (jj_scan_token(73)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     xsp = jj_scanpos;
@@ -5806,7 +5832,7 @@ private boolean jj_3_13()
     xsp = jj_scanpos;
     if (jj_3R_48()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(76)) return true;
+    if (jj_scan_token(77)) return true;
     }
     return false;
   }
@@ -5996,9 +6022,9 @@ private boolean jj_3R_72()
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(72)) {
+    if (jj_scan_token(73)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(41)) return true;
+    if (jj_scan_token(42)) return true;
     }
     return false;
   }
@@ -6026,7 +6052,7 @@ private boolean jj_3R_266()
 
   private boolean jj_3_16()
  {
-    if (jj_scan_token(152)) return true;
+    if (jj_scan_token(153)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
@@ -6145,28 +6171,28 @@ private boolean jj_3R_77()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(44)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(45)) {
     jj_scanpos = xsp;
     if (jj_scan_token(46)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(52)) {
+    if (jj_scan_token(47)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(53)) {
     jj_scanpos = xsp;
     if (jj_scan_token(28)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(40)) {
+    if (jj_scan_token(41)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(53)) {
+    if (jj_scan_token(54)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(59)) {
+    if (jj_scan_token(60)) {
     jj_scanpos = xsp;
     if (jj_scan_token(11)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(49)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(50)) {
     jj_scanpos = xsp;
+    if (jj_scan_token(51)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(21)) return true;
     }
     }
@@ -6236,16 +6262,16 @@ private boolean jj_3R_141()
     return false;
   }
 
-  private boolean jj_3R_199()
+  private boolean jj_3R_234()
  {
-    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
+    if (jj_scan_token(EXTENDS)) return true;
+    if (jj_3R_38()) return true;
     return false;
   }
 
-  private boolean jj_3R_234()
+  private boolean jj_3R_199()
  {
-    if (jj_scan_token(EXTENDS)) return true;
-    if (jj_3R_38()) return true;
+    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
     return false;
   }
 
@@ -6299,13 +6325,13 @@ private boolean jj_3R_200()
 
   private boolean jj_3R_201()
  {
-    if (jj_scan_token(42)) return true;
+    if (jj_scan_token(43)) return true;
     return false;
   }
 
   private boolean jj_3R_202()
  {
-    if (jj_scan_token(58)) return true;
+    if (jj_scan_token(59)) return true;
     return false;
   }
 
@@ -6391,6 +6417,12 @@ private boolean jj_3R_96()
     return false;
   }
 
+  private boolean jj_3R_122()
+ {
+    if (jj_scan_token(IDENTIFIER)) return true;
+    return false;
+  }
+
   private boolean jj_3R_203()
  {
     if (jj_scan_token(LPAREN)) return true;
@@ -6401,12 +6433,6 @@ private boolean jj_3R_203()
     return false;
   }
 
-  private boolean jj_3R_122()
- {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    return false;
-  }
-
   private boolean jj_3R_123()
  {
     if (jj_3R_54()) return true;
@@ -6437,17 +6463,17 @@ private boolean jj_3R_256()
     return false;
   }
 
-  private boolean jj_3R_223()
+  private boolean jj_3R_225()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_51()) return true;
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_81()) return true;
     return false;
   }
 
-  private boolean jj_3R_225()
+  private boolean jj_3R_223()
  {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_81()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_51()) return true;
     return false;
   }
 
@@ -6535,6 +6561,12 @@ private boolean jj_3R_209()
     return false;
   }
 
+  private boolean jj_3R_227()
+ {
+    if (jj_3R_231()) return true;
+    return false;
+  }
+
   private boolean jj_3R_210()
  {
     if (jj_3R_38()) return true;
@@ -6547,12 +6579,6 @@ private boolean jj_3R_210()
     return false;
   }
 
-  private boolean jj_3R_227()
- {
-    if (jj_3R_231()) return true;
-    return false;
-  }
-
   private boolean jj_3R_124()
  {
     if (jj_scan_token(IMPORT)) return true;
@@ -6644,32 +6670,20 @@ private boolean jj_3_20()
     return false;
   }
 
-  private boolean jj_3_21()
+  private boolean jj_3R_232()
  {
     if (jj_scan_token(LBRACKET)) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_232()
+  private boolean jj_3_21()
  {
     if (jj_scan_token(LBRACKET)) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_135()
- {
-    Token xsp;
-    if (jj_3R_144()) return true;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_144()) { jj_scanpos = xsp; break; }
-    }
-    if (jj_3R_41()) return true;
-    return false;
-  }
-
   private boolean jj_3R_233()
  {
     if (jj_scan_token(ASSIGN)) return true;
@@ -6684,33 +6698,38 @@ private boolean jj_3R_39()
     return false;
   }
 
-  private boolean jj_3R_239()
+  private boolean jj_3R_135()
  {
-    if (jj_scan_token(SEMICOLON)) return true;
     Token xsp;
+    if (jj_3R_144()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_2()) { jj_scanpos = xsp; break; }
+      if (jj_3R_144()) { jj_scanpos = xsp; break; }
     }
+    if (jj_3R_41()) return true;
     return false;
   }
 
-  private boolean jj_3_19()
+  private boolean jj_3R_239()
  {
-    if (jj_3R_50()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_2()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_144()
+  private boolean jj_3_5()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_3R_41()) return true;
     return false;
   }
 
-  private boolean jj_3_5()
+  private boolean jj_3_19()
  {
-    if (jj_3R_41()) return true;
+    if (jj_3R_50()) return true;
     return false;
   }
 
@@ -6725,6 +6744,13 @@ private boolean jj_3R_42()
     return false;
   }
 
+  private boolean jj_3R_144()
+ {
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
   private boolean jj_3R_136()
  {
     if (jj_3R_41()) return true;
@@ -6750,7 +6776,7 @@ private boolean jj_3R_41()
     xsp = jj_scanpos;
     if (jj_3R_67()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(82)) jj_scanpos = xsp;
+    if (jj_scan_token(83)) jj_scanpos = xsp;
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
@@ -6769,7 +6795,7 @@ private boolean jj_3R_57()
     jj_scanpos = xsp;
     if (jj_3_24()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(81)) {
+    if (jj_scan_token(82)) {
     jj_scanpos = xsp;
     if (jj_3R_82()) {
     jj_scanpos = xsp;
@@ -6875,12 +6901,6 @@ private boolean jj_3R_80()
     return false;
   }
 
-  private boolean jj_3R_84()
- {
-    if (jj_3R_109()) return true;
-    return false;
-  }
-
   private boolean jj_3R_104()
  {
     Token xsp;
@@ -6896,6 +6916,12 @@ private boolean jj_3R_104()
     return false;
   }
 
+  private boolean jj_3R_84()
+ {
+    if (jj_3R_109()) return true;
+    return false;
+  }
+
   private boolean jj_3_7()
  {
     Token xsp;
@@ -6920,15 +6946,15 @@ private boolean jj_3R_86()
     return false;
   }
 
-  private boolean jj_3R_87()
+  private boolean jj_3R_138()
  {
-    if (jj_3R_112()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_138()
+  private boolean jj_3R_87()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_112()) return true;
     return false;
   }
 
@@ -6975,12 +7001,6 @@ private boolean jj_3R_43()
     return false;
   }
 
-  private boolean jj_3R_92()
- {
-    if (jj_3R_117()) return true;
-    return false;
-  }
-
   private boolean jj_3R_44()
  {
     Token xsp;
@@ -6996,6 +7016,12 @@ private boolean jj_3R_44()
     return false;
   }
 
+  private boolean jj_3R_92()
+ {
+    if (jj_3R_117()) return true;
+    return false;
+  }
+
   private boolean jj_3R_93()
  {
     if (jj_3R_118()) return true;
@@ -7021,18 +7047,18 @@ private boolean jj_3R_69()
     return false;
   }
 
-  private boolean jj_3R_52()
+  private boolean jj_3_8()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3_8()
+  private boolean jj_3R_52()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_57()) return true;
     return false;
   }
 
@@ -7063,7 +7089,7 @@ private boolean jj_3R_50()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(49)) jj_scanpos = xsp;
+    if (jj_scan_token(50)) jj_scanpos = xsp;
     if (jj_scan_token(LBRACE)) return true;
     while (true) {
       xsp = jj_scanpos;
@@ -7218,7 +7244,7 @@ private boolean jj_3_26()
     xsp = jj_scanpos;
     if (jj_scan_token(14)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(38)) {
+    if (jj_scan_token(39)) {
     jj_scanpos = xsp;
     if (jj_scan_token(25)) return true;
     }
@@ -7261,12 +7287,6 @@ private boolean jj_3_30()
     return false;
   }
 
-  private boolean jj_3R_65()
- {
-    if (jj_3R_98()) return true;
-    return false;
-  }
-
   private boolean jj_3R_81()
  {
     if (jj_3R_38()) return true;
@@ -7278,6 +7298,12 @@ private boolean jj_3R_81()
     return false;
   }
 
+  private boolean jj_3R_65()
+ {
+    if (jj_3R_98()) return true;
+    return false;
+  }
+
   private boolean jj_3_28()
  {
     if (jj_3R_53()) return true;
@@ -7324,7 +7350,7 @@ private boolean jj_3R_231()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(81)) {
+    if (jj_scan_token(82)) {
     jj_scanpos = xsp;
     jj_lookingAhead = true;
     jj_semLA = isImplicitMethodTerminator();
@@ -7334,15 +7360,15 @@ private boolean jj_3R_231()
     return false;
   }
 
-  private boolean jj_3R_240()
+  private boolean jj_3R_106()
  {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_38()) return true;
     return false;
   }
 
-  private boolean jj_3R_106()
+  private boolean jj_3R_240()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_38()) return true;
     return false;
   }
 
@@ -7350,49 +7376,49 @@ private boolean jj_3R_134()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(84)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(125)) {
+    if (jj_scan_token(85)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(135)) {
+    if (jj_scan_token(126)) {
     jj_scanpos = xsp;
     if (jj_scan_token(136)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(126)) {
+    if (jj_scan_token(137)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(133)) {
+    if (jj_scan_token(127)) {
     jj_scanpos = xsp;
     if (jj_scan_token(134)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(123)) {
+    if (jj_scan_token(135)) {
     jj_scanpos = xsp;
     if (jj_scan_token(124)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(127)) {
+    if (jj_scan_token(125)) {
     jj_scanpos = xsp;
     if (jj_scan_token(128)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(131)) {
+    if (jj_scan_token(129)) {
     jj_scanpos = xsp;
     if (jj_scan_token(132)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(129)) {
+    if (jj_scan_token(133)) {
     jj_scanpos = xsp;
     if (jj_scan_token(130)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(137)) {
+    if (jj_scan_token(131)) {
     jj_scanpos = xsp;
     if (jj_scan_token(138)) {
     jj_scanpos = xsp;
     if (jj_scan_token(139)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(145)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(140)) {
     jj_scanpos = xsp;
+    if (jj_scan_token(146)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(141)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(142)) return true;
+    if (jj_scan_token(142)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(143)) return true;
     }
     }
     }
@@ -7421,7 +7447,7 @@ private boolean jj_3R_40()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(81)) jj_scanpos = xsp;
+    if (jj_scan_token(82)) jj_scanpos = xsp;
     return false;
   }
 
@@ -7462,11 +7488,11 @@ private boolean jj_3R_143()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(146)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(147)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(144)) return true;
+    if (jj_scan_token(148)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(145)) return true;
     }
     }
     if (jj_3R_137()) return true;
@@ -7488,9 +7514,9 @@ private boolean jj_3R_146()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(97)) {
+    if (jj_scan_token(98)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(98)) return true;
+    if (jj_scan_token(99)) return true;
     }
     if (jj_3R_145()) return true;
     return false;
@@ -7527,9 +7553,9 @@ private boolean jj_3R_148()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(99)) {
+    if (jj_scan_token(100)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(100)) return true;
+    if (jj_scan_token(101)) return true;
     }
     if (jj_3R_147()) return true;
     return false;
@@ -7578,7 +7604,7 @@ private boolean jj_3R_147()
 
   private boolean jj_3R_258()
  {
-    if (jj_scan_token(153)) return true;
+    if (jj_scan_token(154)) return true;
     return false;
   }
 
@@ -7586,9 +7612,9 @@ private boolean jj_3R_150()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(109)) {
+    if (jj_scan_token(110)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(110)) return true;
+    if (jj_scan_token(111)) return true;
     }
     if (jj_3R_149()) return true;
     return false;
@@ -7641,9 +7667,9 @@ private boolean jj_3R_156()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(111)) {
+    if (jj_scan_token(112)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(112)) return true;
+    if (jj_scan_token(113)) return true;
     }
     if (jj_3R_151()) return true;
     return false;
@@ -7674,14 +7700,25 @@ private boolean jj_3R_159()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(107)) {
+    if (jj_scan_token(108)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(108)) return true;
+    if (jj_scan_token(109)) return true;
     }
     if (jj_3R_157()) return true;
     return false;
   }
 
+  private boolean jj_3R_157()
+ {
+    if (jj_3R_160()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_161()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
   private boolean jj_3R_111()
  {
     if (jj_scan_token(DO)) return true;
@@ -7694,24 +7731,13 @@ private boolean jj_3R_111()
     return false;
   }
 
-  private boolean jj_3R_157()
- {
-    if (jj_3R_160()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_161()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
   private boolean jj_3R_161()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(91)) {
+    if (jj_scan_token(92)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(96)) return true;
+    if (jj_scan_token(97)) return true;
     }
     if (jj_3R_160()) return true;
     return false;
@@ -7744,16 +7770,21 @@ private boolean jj_3R_160()
     return false;
   }
 
-  private boolean jj_3R_242()
+  private boolean jj_3R_163()
  {
-    if (jj_scan_token(SEMICOLON)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(36)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(37)) return true;
+    }
+    if (jj_3R_44()) return true;
     return false;
   }
 
-  private boolean jj_3R_163()
+  private boolean jj_3R_242()
  {
-    if (jj_scan_token(INSTANCEOF)) return true;
-    if (jj_3R_44()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
@@ -7784,21 +7815,21 @@ private boolean jj_3R_165()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(87)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(88)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(85)) {
+    if (jj_scan_token(89)) {
     jj_scanpos = xsp;
     if (jj_scan_token(86)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(92)) {
+    if (jj_scan_token(87)) {
     jj_scanpos = xsp;
     if (jj_scan_token(93)) {
     jj_scanpos = xsp;
     if (jj_scan_token(94)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(95)) return true;
+    if (jj_scan_token(95)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(96)) return true;
     }
     }
     }
@@ -7870,8 +7901,6 @@ private boolean jj_3R_167()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(117)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(118)) {
     jj_scanpos = xsp;
     if (jj_scan_token(119)) {
@@ -7880,7 +7909,9 @@ private boolean jj_3R_167()
     jj_scanpos = xsp;
     if (jj_scan_token(121)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(122)) return true;
+    if (jj_scan_token(122)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(123)) return true;
     }
     }
     }
@@ -7930,18 +7961,6 @@ private boolean jj_3R_253()
     return false;
   }
 
-  private boolean jj_3R_169()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(103)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(104)) return true;
-    }
-    if (jj_3R_168()) return true;
-    return false;
-  }
-
   /** Generated Token Manager. */
   public ParserTokenManager token_source;
   JavaCharStream jj_input_stream;
@@ -7956,7 +7975,7 @@ private boolean jj_3R_169()
   private boolean jj_lookingAhead = false;
   private boolean jj_semLA;
   private int jj_gen;
-  final private int[] jj_la1 = new int[119];
+  final private int[] jj_la1 = new int[120];
   static private int[] jj_la1_0;
   static private int[] jj_la1_1;
   static private int[] jj_la1_2;
@@ -7970,19 +7989,19 @@ private boolean jj_3R_169()
 	   jj_la1_init_4();
 	}
 	private static void jj_la1_init_0() {
-	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
+	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_1() {
-	   jj_la1_1 = new int[] {0x0,0x8367100,0x8367100,0x0,0x4,0x0,0x40,0x4,0x40,0x0,0x20000,0x0,0x0,0x0,0x40100a0,0x800000,0x20000,0x20000,0x0,0x8,0x0,0x0,0x250106a0,0x250106a0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x100a0,0x40100a0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x250106a0,0x0,0x250306a0,0x25000600,0x0,0x250106a0,0x250106a0,0x250106a0,0x250106a0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x25000400,0x1000000,0x250106a0,0x0,0x0,0x100a0,0x200,0x0,0x0,0x350906a2,0x2508000,0x20000,0x808,0x0,0x0,0x0,0x0,0x0,0x0,0x2d3777a0,0x250106a0,0x250106a0,0x0,0x0,0x250106a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_1 = new int[] {0x0,0x106ce200,0x106ce200,0x0,0x4,0x0,0x80,0x4,0x80,0x0,0x40000,0x0,0x0,0x0,0x8020140,0x1000000,0x40000,0x40000,0x0,0x8,0x0,0x0,0x4a020d40,0x4a020d40,0x0,0x0,0x20140,0x0,0x0,0x0,0x20140,0x8020140,0x20140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4a020d40,0x0,0x4a060d40,0x4a000c00,0x0,0x4a020d40,0x4a020d40,0x4a020d40,0x4a020d40,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x4a000800,0x2000000,0x4a020d40,0x0,0x0,0x20140,0x400,0x0,0x0,0x6a120d42,0x4a10000,0x40000,0x1008,0x0,0x0,0x0,0x0,0x0,0x0,0x5a6eef40,0x4a020d40,0x4a020d40,0x0,0x0,0x4a020d40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_2() {
-	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x2000,0x100,0x40000,0x20000,0x100,0x0,0x2000,0x0,0x80000,0x0,0x8000,0x100000,0x600a9e4,0x600a9e4,0x40000,0x40000,0x100,0x0,0x0,0x100,0x100,0x100,0x0,0x40000,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0xf1e00000,0xf1e00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000000,0x0,0x0,0x0,0x6000000,0xa9e4,0x900,0x600a9e4,0xa8e4,0x100,0x600a9e4,0x600a9e4,0x600a9e4,0x600a9e4,0x0,0x0,0x0,0x100,0x800,0x800,0x8000,0x2000,0xe4,0x0,0x600a9e4,0x40000,0xa800,0xa100,0xa000,0x8000,0xa000,0x602a9e4,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x20000,0x0,0x600a9e4,0x600a9e4,0x600a9e4,0x0,0x0,0x600a9e4,0x40000,0x40000,0x800,0x0,0x0,0x0,0x0,0x100,0x20000,0x100,};
+	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x4000,0x200,0x80000,0x40000,0x200,0x0,0x4000,0x0,0x100000,0x0,0x10000,0x200000,0xc0153c8,0xc0153c8,0x80000,0x80000,0x200,0x0,0x0,0x200,0x200,0x200,0x0,0x80000,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0xe3c00000,0xe3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0x0,0x0,0x0,0xc000000,0x153c8,0x1200,0xc0153c8,0x151c8,0x200,0xc0153c8,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0x0,0x200,0x1000,0x1000,0x10000,0x4000,0x1c8,0x0,0xc0153c8,0x80000,0x15000,0x14200,0x14000,0x10000,0x14000,0xc0553c8,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x40000,0x0,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0xc0153c8,0x80000,0x80000,0x1000,0x0,0x0,0x0,0x0,0x200,0x40000,0x200,};
 	}
 	private static void jj_la1_init_3() {
-	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e0,0x1e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8000000,0xf8000000,0x0,0x0,0x0,0x6,0x6,0x18,0x18,0x6000,0x6000,0x18000,0x18000,0x1800,0x1800,0x1,0x1,0x0,0x0,0x0,0x7e00000,0x7e00000,0x180,0x180,0x60600,0x60600,0x180000,0x180000,0x180,0x60,0x60,0x60,0x1e0,0x0,0x0,0x1e0,0x0,0x0,0x1e0,0x1e0,0x1e0,0x1e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e0,0x1e0,0x1e0,0x0,0x0,0x1e0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,};
+	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0xf0000000,0x0,0x0,0x0,0xc,0xc,0x30,0x30,0xc000,0xc000,0x30000,0x30000,0x3000,0x3000,0x2,0x2,0x0,0x0,0x1,0x1,0xfc00000,0xfc00000,0x300,0x300,0xc0c00,0xc0c00,0x300000,0x300000,0x300,0xc0,0xc0,0xc0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_4() {
-	   jj_la1_4 = new int[] {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,0x800000,0x0,0x0,0x0,0x0,0x0,0x27fff,0x27fff,0x100000,0xd0000,0xd0000,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,0x200000,0x600000,0x600000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_4 = new int[] {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,0x1000000,0x0,0x0,0x0,0x0,0x0,0x4ffff,0x4ffff,0x200000,0x1a0000,0x1a0000,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,0x400000,0xc00000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
   private final JJCalls[] jj_2_rtns = new JJCalls[38];
   private boolean jj_rescan = false;
@@ -7999,7 +8018,7 @@ public Parser(final java.io.InputStream stream, final java.nio.charset.Charset e
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 119; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8014,7 +8033,7 @@ public void ReInit(final java.io.InputStream stream, final java.nio.charset.Char
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 119; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8028,7 +8047,7 @@ public Parser(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 119; i++)
+   for (int i = 0; i < 120; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8052,7 +8071,7 @@ public void ReInit(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 119; i++)
+   for (int i = 0; i < 120; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8067,7 +8086,7 @@ public Parser(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 119; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8080,7 +8099,7 @@ public void ReInit(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 119; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8225,12 +8244,12 @@ private void jj_add_error_token(int kind, int pos) {
    */
   public ParseException generateParseException() {
     jj_expentries.clear();
-    boolean[] la1tokens = new boolean[154];
+    boolean[] la1tokens = new boolean[155];
     if (jj_kind >= 0) {
       la1tokens[jj_kind] = true;
       jj_kind = -1;
     }
-    for (int i = 0; i < 119; i++) {
+    for (int i = 0; i < 120; i++) {
       if (jj_la1[i] == jj_gen) {
         for (int j = 0; j < 32; j++) {
           if ((jj_la1_0[i] & (1<<j)) != 0) {
@@ -8251,7 +8270,7 @@ public ParseException generateParseException() {
         }
       }
     }
-    for (int i = 0; i < 154; i++) {
+    for (int i = 0; i < 155; i++) {
       if (la1tokens[i]) {
         jj_expentry = new int[1];
         jj_expentry[0] = i;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
index 4301c2f..36104ee 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
@@ -98,235 +98,237 @@ public interface ParserConstants {
   /** RegularExpression Id. */
   int INSTANCEOF = 36;
   /** RegularExpression Id. */
-  int INT = 37;
+  int IS = 37;
   /** RegularExpression Id. */
-  int INTERFACE = 38;
+  int INT = 38;
   /** RegularExpression Id. */
-  int LONG = 39;
+  int INTERFACE = 39;
   /** RegularExpression Id. */
-  int NATIVE = 40;
+  int LONG = 40;
   /** RegularExpression Id. */
-  int NEW = 41;
+  int NATIVE = 41;
   /** RegularExpression Id. */
-  int NULL = 42;
+  int NEW = 42;
   /** RegularExpression Id. */
-  int PACKAGE = 43;
+  int NULL = 43;
   /** RegularExpression Id. */
-  int PRIVATE = 44;
+  int PACKAGE = 44;
   /** RegularExpression Id. */
-  int PROTECTED = 45;
+  int PRIVATE = 45;
   /** RegularExpression Id. */
-  int PUBLIC = 46;
+  int PROTECTED = 46;
   /** RegularExpression Id. */
-  int RETURN = 47;
+  int PUBLIC = 47;
   /** RegularExpression Id. */
-  int SHORT = 48;
+  int RETURN = 48;
   /** RegularExpression Id. */
-  int STATIC = 49;
+  int SHORT = 49;
   /** RegularExpression Id. */
-  int STRICTFP = 50;
+  int STATIC = 50;
   /** RegularExpression Id. */
-  int SWITCH = 51;
+  int STRICTFP = 51;
   /** RegularExpression Id. */
-  int SYNCHRONIZED = 52;
+  int SWITCH = 52;
   /** RegularExpression Id. */
-  int TRANSIENT = 53;
+  int SYNCHRONIZED = 53;
   /** RegularExpression Id. */
-  int THROW = 54;
+  int TRANSIENT = 54;
   /** RegularExpression Id. */
-  int THROWS = 55;
+  int THROW = 55;
   /** RegularExpression Id. */
-  int TRUE = 56;
+  int THROWS = 56;
   /** RegularExpression Id. */
-  int TRY = 57;
+  int TRUE = 57;
   /** RegularExpression Id. */
-  int VOID = 58;
+  int TRY = 58;
   /** RegularExpression Id. */
-  int VOLATILE = 59;
+  int VOID = 59;
   /** RegularExpression Id. */
-  int WHILE = 60;
+  int VOLATILE = 60;
   /** RegularExpression Id. */
-  int INTEGER_LITERAL = 61;
+  int WHILE = 61;
   /** RegularExpression Id. */
-  int DECIMAL_LITERAL = 62;
+  int INTEGER_LITERAL = 62;
   /** RegularExpression Id. */
-  int HEX_LITERAL = 63;
+  int DECIMAL_LITERAL = 63;
   /** RegularExpression Id. */
-  int BINARY_LITERAL = 64;
+  int HEX_LITERAL = 64;
   /** RegularExpression Id. */
-  int OCTAL_LITERAL = 65;
+  int BINARY_LITERAL = 65;
   /** RegularExpression Id. */
-  int FLOATING_POINT_LITERAL = 66;
+  int OCTAL_LITERAL = 66;
   /** RegularExpression Id. */
-  int EXPONENT = 67;
+  int FLOATING_POINT_LITERAL = 67;
   /** RegularExpression Id. */
-  int ESCAPE = 68;
+  int EXPONENT = 68;
   /** RegularExpression Id. */
-  int CHARACTER_LITERAL = 69;
+  int ESCAPE = 69;
   /** RegularExpression Id. */
-  int STRING_LITERAL = 70;
+  int CHARACTER_LITERAL = 70;
   /** RegularExpression Id. */
-  int LONG_STRING_LITERAL = 71;
+  int STRING_LITERAL = 71;
   /** RegularExpression Id. */
-  int IDENTIFIER = 72;
+  int LONG_STRING_LITERAL = 72;
   /** RegularExpression Id. */
-  int LETTER = 73;
+  int IDENTIFIER = 73;
   /** RegularExpression Id. */
-  int DIGIT = 74;
+  int LETTER = 74;
   /** RegularExpression Id. */
-  int LPAREN = 75;
+  int DIGIT = 75;
   /** RegularExpression Id. */
-  int RPAREN = 76;
+  int LPAREN = 76;
   /** RegularExpression Id. */
-  int LBRACE = 77;
+  int RPAREN = 77;
   /** RegularExpression Id. */
-  int RBRACE = 78;
+  int LBRACE = 78;
   /** RegularExpression Id. */
-  int LBRACKET = 79;
+  int RBRACE = 79;
   /** RegularExpression Id. */
-  int RBRACKET = 80;
+  int LBRACKET = 80;
   /** RegularExpression Id. */
-  int SEMICOLON = 81;
+  int RBRACKET = 81;
   /** RegularExpression Id. */
-  int COMMA = 82;
+  int SEMICOLON = 82;
   /** RegularExpression Id. */
-  int DOT = 83;
+  int COMMA = 83;
   /** RegularExpression Id. */
-  int ASSIGN = 84;
+  int DOT = 84;
   /** RegularExpression Id. */
-  int GT = 85;
+  int ASSIGN = 85;
   /** RegularExpression Id. */
-  int GTX = 86;
+  int GT = 86;
   /** RegularExpression Id. */
-  int LT = 87;
+  int GTX = 87;
   /** RegularExpression Id. */
-  int LTX = 88;
+  int LT = 88;
   /** RegularExpression Id. */
-  int BANG = 89;
+  int LTX = 89;
   /** RegularExpression Id. */
-  int TILDE = 90;
+  int BANG = 90;
   /** RegularExpression Id. */
-  int EQ = 91;
+  int TILDE = 91;
   /** RegularExpression Id. */
-  int LE = 92;
+  int EQ = 92;
   /** RegularExpression Id. */
-  int LEX = 93;
+  int LE = 93;
   /** RegularExpression Id. */
-  int GE = 94;
+  int LEX = 94;
   /** RegularExpression Id. */
-  int GEX = 95;
+  int GE = 95;
   /** RegularExpression Id. */
-  int NE = 96;
+  int GEX = 96;
   /** RegularExpression Id. */
-  int BOOL_OR = 97;
+  int NE = 97;
   /** RegularExpression Id. */
-  int BOOL_ORX = 98;
+  int BOOL_OR = 98;
   /** RegularExpression Id. */
-  int BOOL_AND = 99;
+  int BOOL_ORX = 99;
   /** RegularExpression Id. */
-  int BOOL_ANDX = 100;
+  int BOOL_AND = 100;
   /** RegularExpression Id. */
-  int INCR = 101;
+  int BOOL_ANDX = 101;
   /** RegularExpression Id. */
-  int DECR = 102;
+  int INCR = 102;
   /** RegularExpression Id. */
-  int PLUS = 103;
+  int DECR = 103;
   /** RegularExpression Id. */
-  int MINUS = 104;
+  int PLUS = 104;
   /** RegularExpression Id. */
-  int STAR = 105;
+  int MINUS = 105;
   /** RegularExpression Id. */
-  int SLASH = 106;
+  int STAR = 106;
   /** RegularExpression Id. */
-  int BIT_AND = 107;
+  int SLASH = 107;
   /** RegularExpression Id. */
-  int BIT_ANDX = 108;
+  int BIT_AND = 108;
   /** RegularExpression Id. */
-  int BIT_OR = 109;
+  int BIT_ANDX = 109;
   /** RegularExpression Id. */
-  int BIT_ORX = 110;
+  int BIT_OR = 110;
   /** RegularExpression Id. */
-  int XOR = 111;
+  int BIT_ORX = 111;
   /** RegularExpression Id. */
-  int XORX = 112;
+  int XOR = 112;
   /** RegularExpression Id. */
-  int MOD = 113;
+  int XORX = 113;
   /** RegularExpression Id. */
-  int MODX = 114;
+  int MOD = 114;
   /** RegularExpression Id. */
-  int POWER = 115;
+  int MODX = 115;
   /** RegularExpression Id. */
-  int POWERX = 116;
+  int POWER = 116;
   /** RegularExpression Id. */
-  int LSHIFT = 117;
+  int POWERX = 117;
   /** RegularExpression Id. */
-  int LSHIFTX = 118;
+  int LSHIFT = 118;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFT = 119;
+  int LSHIFTX = 119;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTX = 120;
+  int RSIGNEDSHIFT = 120;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFT = 121;
+  int RSIGNEDSHIFTX = 121;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTX = 122;
+  int RUNSIGNEDSHIFT = 122;
   /** RegularExpression Id. */
-  int PLUSASSIGN = 123;
+  int RUNSIGNEDSHIFTX = 123;
   /** RegularExpression Id. */
-  int MINUSASSIGN = 124;
+  int PLUSASSIGN = 124;
   /** RegularExpression Id. */
-  int STARASSIGN = 125;
+  int MINUSASSIGN = 125;
   /** RegularExpression Id. */
-  int SLASHASSIGN = 126;
+  int STARASSIGN = 126;
   /** RegularExpression Id. */
-  int ANDASSIGN = 127;
+  int SLASHASSIGN = 127;
   /** RegularExpression Id. */
-  int ANDASSIGNX = 128;
+  int ANDASSIGN = 128;
   /** RegularExpression Id. */
-  int ORASSIGN = 129;
+  int ANDASSIGNX = 129;
   /** RegularExpression Id. */
-  int ORASSIGNX = 130;
+  int ORASSIGN = 130;
   /** RegularExpression Id. */
-  int XORASSIGN = 131;
+  int ORASSIGNX = 131;
   /** RegularExpression Id. */
-  int XORASSIGNX = 132;
+  int XORASSIGN = 132;
   /** RegularExpression Id. */
-  int MODASSIGN = 133;
+  int XORASSIGNX = 133;
   /** RegularExpression Id. */
-  int MODASSIGNX = 134;
+  int MODASSIGN = 134;
   /** RegularExpression Id. */
-  int POWERASSIGN = 135;
+  int MODASSIGNX = 135;
   /** RegularExpression Id. */
-  int POWERASSIGNX = 136;
+  int POWERASSIGN = 136;
   /** RegularExpression Id. */
-  int LSHIFTASSIGN = 137;
+  int POWERASSIGNX = 137;
   /** RegularExpression Id. */
-  int LSHIFTASSIGNX = 138;
+  int LSHIFTASSIGN = 138;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGN = 139;
+  int LSHIFTASSIGNX = 139;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGNX = 140;
+  int RSIGNEDSHIFTASSIGN = 140;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGN = 141;
+  int RSIGNEDSHIFTASSIGNX = 141;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGNX = 142;
+  int RUNSIGNEDSHIFTASSIGN = 142;
   /** RegularExpression Id. */
-  int ARROW = 143;
+  int RUNSIGNEDSHIFTASSIGNX = 143;
   /** RegularExpression Id. */
-  int SPACESHIP = 144;
+  int ARROW = 144;
   /** RegularExpression Id. */
-  int NULLCOALESCEASSIGN = 145;
+  int SPACESHIP = 145;
   /** RegularExpression Id. */
-  int NULLCOALESCE = 146;
+  int NULLCOALESCEASSIGN = 146;
   /** RegularExpression Id. */
-  int ELVIS = 147;
+  int NULLCOALESCE = 147;
   /** RegularExpression Id. */
-  int HOOK = 148;
+  int ELVIS = 148;
   /** RegularExpression Id. */
-  int COLON = 149;
+  int HOOK = 149;
   /** RegularExpression Id. */
-  int COLON_COLON = 150;
+  int COLON = 150;
   /** RegularExpression Id. */
-  int ELLIPSIS = 151;
+  int COLON_COLON = 151;
+  /** RegularExpression Id. */
+  int ELLIPSIS = 152;
 
   /** Lexical state. */
   int DEFAULT = 0;
@@ -370,6 +372,7 @@ public interface ParserConstants {
     "\"implements\"",
     "\"import\"",
     "\"instanceof\"",
+    "\"is\"",
     "\"int\"",
     "\"interface\"",
     "\"long\"",
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
index 6945b53..93c086f 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
@@ -38,140 +38,140 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
    switch (pos)
    {
       case 0:
-         if ((active1 & 0x20000010800000L) != 0x0L || (active2 & 0x10200L) != 0x0L)
+         if ((active1 & 0x40000021000000L) != 0x0L || (active2 & 0x20400L) != 0x0L)
             return 75;
-         if ((active1 & 0x80000L) != 0x0L || (active2 & 0x800000L) != 0x0L)
+         if ((active1 & 0x100000L) != 0x0L || (active2 & 0x1000000L) != 0x0L)
             return 18;
-         if ((active1 & 0x4000040000000000L) != 0x0L)
+         if ((active1 & 0x8000080000000000L) != 0x0L)
             return 64;
-         if ((active0 & 0x1ffffffffffff800L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active0 & 0x3ffffffffffff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
-            jjmatchedKind = 72;
+            jjmatchedKind = 73;
             return 42;
          }
          if ((active0 & 0x3eL) != 0x0L)
             return 0;
          return -1;
       case 1:
-         if ((active0 & 0x1ffffffdff3ff800L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active1 & 0x40000000000000L) != 0x0L || (active2 & 0x400L) != 0x0L)
+            return 75;
+         if ((active0 & 0x2200c00000L) != 0x0L)
+            return 42;
+         if ((active0 & 0x3fffffddff3ff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 1)
             {
-               jjmatchedKind = 72;
+               jjmatchedKind = 73;
                jjmatchedPos = 1;
             }
             return 42;
          }
-         if ((active1 & 0x20000000000000L) != 0x0L || (active2 & 0x200L) != 0x0L)
-            return 75;
-         if ((active0 & 0x200c00000L) != 0x0L)
-            return 42;
          return -1;
       case 2:
-         if ((active0 & 0x200026080000000L) != 0x0L)
+         if ((active0 & 0x40004c080000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x1dfffd9d7fbff800L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active0 & 0x3bfffb1d7fbff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 2)
             {
-               jjmatchedKind = 72;
+               jjmatchedKind = 73;
                jjmatchedPos = 2;
             }
             return 42;
          }
          return -1;
       case 3:
-         if ((active0 & 0x500048103058000L) != 0x0L)
+         if ((active0 & 0xa00090103058000L) != 0x0L)
             return 42;
-         if ((active0 & 0x18fff95c7cba7800L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active0 & 0x31fff29c7cba7800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 3)
             {
-               jjmatchedKind = 72;
+               jjmatchedKind = 73;
                jjmatchedPos = 3;
             }
             return 42;
          }
          return -1;
       case 4:
-         if ((active0 & 0x10c10000780a6000L) != 0x0L)
+         if ((active0 & 0x21820000780a6000L) != 0x0L)
             return 42;
-         if ((active0 & 0x83ef95c04b01800L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active0 & 0x107df29c04b01800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 4)
             {
-               jjmatchedKind = 72;
+               jjmatchedKind = 73;
                jjmatchedPos = 4;
             }
             return 42;
          }
          return -1;
       case 5:
-         if ((active0 & 0x834385424301800L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active0 & 0x1068709424301800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
-            jjmatchedKind = 72;
+            jjmatchedKind = 73;
             jjmatchedPos = 5;
             return 42;
          }
-         if ((active0 & 0x8ac10800800000L) != 0x0L)
+         if ((active0 & 0x115820800800000L) != 0x0L)
             return 42;
          return -1;
       case 6:
-         if ((active0 & 0x180024201000L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active0 & 0x300024201000L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x834205400100800L) != 0x0L)
+         if ((active0 & 0x1068409400100800L) != 0x0L)
          {
             if (jjmatchedPos != 6)
             {
-               jjmatchedKind = 72;
+               jjmatchedKind = 73;
                jjmatchedPos = 6;
             }
             return 42;
          }
          return -1;
       case 7:
-         if ((active0 & 0x804000000100800L) != 0x0L)
+         if ((active0 & 0x1008000000100800L) != 0x0L)
             return 42;
-         if ((active0 & 0x30205400000000L) != 0x0L)
+         if ((active0 & 0x60409400000000L) != 0x0L)
          {
-            jjmatchedKind = 72;
+            jjmatchedKind = 73;
             jjmatchedPos = 7;
             return 42;
          }
          return -1;
       case 8:
-         if ((active0 & 0x20204000000000L) != 0x0L)
+         if ((active0 & 0x40408000000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x10001400000000L) != 0x0L)
+         if ((active0 & 0x20001400000000L) != 0x0L)
          {
-            jjmatchedKind = 72;
+            jjmatchedKind = 73;
             jjmatchedPos = 8;
             return 42;
          }
          return -1;
       case 9:
-         if ((active0 & 0x10000000000000L) != 0x0L)
+         if ((active0 & 0x1400000000L) != 0x0L)
+            return 42;
+         if ((active0 & 0x20000000000000L) != 0x0L)
          {
-            jjmatchedKind = 72;
+            jjmatchedKind = 73;
             jjmatchedPos = 9;
             return 42;
          }
-         if ((active0 & 0x1400000000L) != 0x0L)
-            return 42;
          return -1;
       case 10:
-         if ((active0 & 0x10000000000000L) != 0x0L)
+         if ((active0 & 0x20000000000000L) != 0x0L)
          {
             if (jjmatchedPos != 10)
             {
-               jjmatchedKind = 72;
+               jjmatchedKind = 73;
                jjmatchedPos = 10;
             }
             return 42;
          }
          return -1;
       case 11:
-         if ((active0 & 0x10000000000000L) != 0x0L)
+         if ((active0 & 0x20000000000000L) != 0x0L)
             return 42;
          return -1;
       default :
@@ -201,61 +201,61 @@ private int jjMoveStringLiteralDfa0_0(){
       case ' ':
          return jjStartNfaWithStates_0(0, 1, 0);
       case '!':
-         jjmatchedKind = 89;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000L, 0x0L);
+         jjmatchedKind = 90;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L, 0x0L);
       case '%':
-         jjmatchedKind = 113;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x20L);
+         jjmatchedKind = 114;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x40L);
       case '&':
-         jjmatchedKind = 107;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000800000000L, 0x0L);
+         jjmatchedKind = 108;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000L, 0x1L);
       case '(':
-         return jjStopAtPos(0, 75);
-      case ')':
          return jjStopAtPos(0, 76);
+      case ')':
+         return jjStopAtPos(0, 77);
       case '*':
-         jjmatchedKind = 105;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x2008000000000000L, 0x80L);
+         jjmatchedKind = 106;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x4010000000000000L, 0x100L);
       case '+':
-         jjmatchedKind = 103;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x800002000000000L, 0x0L);
+         jjmatchedKind = 104;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000004000000000L, 0x0L);
       case ',':
-         return jjStopAtPos(0, 82);
+         return jjStopAtPos(0, 83);
       case '-':
-         jjmatchedKind = 104;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000004000000000L, 0x8000L);
+         jjmatchedKind = 105;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000008000000000L, 0x10000L);
       case '.':
-         jjmatchedKind = 83;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x800000L);
+         jjmatchedKind = 84;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1000000L);
       case '/':
-         jjmatchedKind = 106;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000000L, 0x0L);
+         jjmatchedKind = 107;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L, 0x0L);
       case ':':
-         jjmatchedKind = 149;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x400000L);
+         jjmatchedKind = 150;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x800000L);
       case ';':
-         return jjStopAtPos(0, 81);
+         return jjStopAtPos(0, 82);
       case '<':
-         jjmatchedKind = 87;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x20000010000000L, 0x10200L);
+         jjmatchedKind = 88;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000020000000L, 0x20400L);
       case '=':
-         jjmatchedKind = 84;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L, 0x0L);
-      case '>':
          jjmatchedKind = 85;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x280000040000000L, 0x2800L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L, 0x0L);
+      case '>':
+         jjmatchedKind = 86;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x500000080000000L, 0x5000L);
       case '?':
-         jjmatchedKind = 148;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10e0000L);
+         jjmatchedKind = 149;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x21c0000L);
       case '@':
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x5555014a1400000L, 0x5555L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0xaaaa02942800000L, 0xaaaaL);
       case '[':
-         return jjStopAtPos(0, 79);
-      case ']':
          return jjStopAtPos(0, 80);
+      case ']':
+         return jjStopAtPos(0, 81);
       case '^':
-         jjmatchedKind = 111;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x8L);
+         jjmatchedKind = 112;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10L);
       case 'a':
          return jjMoveStringLiteralDfa1_0(0x800L, 0x0L, 0x0L);
       case 'b':
@@ -263,7 +263,7 @@ private int jjMoveStringLiteralDfa0_0(){
       case 'c':
          return jjMoveStringLiteralDfa1_0(0x1f4000L, 0x0L, 0x0L);
       case 'd':
-         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x2000000L);
+         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x4000000L);
       case 'e':
          return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L, 0x0L);
       case 'f':
@@ -271,32 +271,32 @@ private int jjMoveStringLiteralDfa0_0(){
       case 'g':
          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L, 0x0L);
       case 'i':
-         return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0xfe00000000L, 0x0L, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L, 0x0L);
       case 'p':
-         return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L, 0x0L);
       case 'r':
-         return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L, 0x0L);
       case 's':
-         return jjMoveStringLiteralDfa1_0(0x1f000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x3e000000000000L, 0x0L, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa1_0(0x3e0000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x7c0000000000000L, 0x0L, 0x0L);
       case 'v':
-         return jjMoveStringLiteralDfa1_0(0xc00000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa1_0(0x1000000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L, 0x0L);
       case '{':
-         return jjStopAtPos(0, 77);
+         return jjStopAtPos(0, 78);
       case '|':
-         jjmatchedKind = 109;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L, 0x2L);
+         jjmatchedKind = 110;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L, 0x4L);
       case '}':
-         return jjStopAtPos(0, 78);
+         return jjStopAtPos(0, 79);
       case '~':
-         return jjStopAtPos(0, 90);
+         return jjStopAtPos(0, 91);
       default :
          return jjMoveNfa_0(1, 0);
    }
@@ -310,55 +310,53 @@ private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){
    switch(curChar)
    {
       case '&':
-         if ((active1 & 0x800000000L) != 0x0L)
-            return jjStopAtPos(1, 99);
+         if ((active1 & 0x1000000000L) != 0x0L)
+            return jjStopAtPos(1, 100);
          break;
       case '*':
-         if ((active1 & 0x8000000000000L) != 0x0L)
+         if ((active1 & 0x10000000000000L) != 0x0L)
          {
-            jjmatchedKind = 115;
+            jjmatchedKind = 116;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x80L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x100L);
       case '+':
-         if ((active1 & 0x2000000000L) != 0x0L)
-            return jjStopAtPos(1, 101);
-         break;
-      case '-':
          if ((active1 & 0x4000000000L) != 0x0L)
             return jjStopAtPos(1, 102);
          break;
+      case '-':
+         if ((active1 & 0x8000000000L) != 0x0L)
+            return jjStopAtPos(1, 103);
+         break;
       case '.':
-         if ((active2 & 0x1000000L) != 0x0L)
-            return jjStopAtPos(1, 152);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x800000L);
+         if ((active2 & 0x2000000L) != 0x0L)
+            return jjStopAtPos(1, 153);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x1000000L);
       case ':':
-         if ((active2 & 0x80000L) != 0x0L)
-            return jjStopAtPos(1, 147);
-         else if ((active2 & 0x400000L) != 0x0L)
-            return jjStopAtPos(1, 150);
+         if ((active2 & 0x100000L) != 0x0L)
+            return jjStopAtPos(1, 148);
+         else if ((active2 & 0x800000L) != 0x0L)
+            return jjStopAtPos(1, 151);
          break;
       case '<':
-         if ((active1 & 0x20000000000000L) != 0x0L)
+         if ((active1 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 117;
+            jjmatchedKind = 118;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x200L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
       case '=':
-         if ((active1 & 0x8000000L) != 0x0L)
-            return jjStopAtPos(1, 91);
-         else if ((active1 & 0x10000000L) != 0x0L)
+         if ((active1 & 0x10000000L) != 0x0L)
+            return jjStopAtPos(1, 92);
+         else if ((active1 & 0x20000000L) != 0x0L)
          {
-            jjmatchedKind = 92;
+            jjmatchedKind = 93;
             jjmatchedPos = 1;
          }
-         else if ((active1 & 0x40000000L) != 0x0L)
-            return jjStopAtPos(1, 94);
-         else if ((active1 & 0x100000000L) != 0x0L)
-            return jjStopAtPos(1, 96);
-         else if ((active1 & 0x800000000000000L) != 0x0L)
-            return jjStopAtPos(1, 123);
+         else if ((active1 & 0x80000000L) != 0x0L)
+            return jjStopAtPos(1, 95);
+         else if ((active1 & 0x200000000L) != 0x0L)
+            return jjStopAtPos(1, 97);
          else if ((active1 & 0x1000000000000000L) != 0x0L)
             return jjStopAtPos(1, 124);
          else if ((active1 & 0x2000000000000000L) != 0x0L)
@@ -367,75 +365,81 @@ else if ((active1 & 0x4000000000000000L) != 0x0L)
             return jjStopAtPos(1, 126);
          else if ((active1 & 0x8000000000000000L) != 0x0L)
             return jjStopAtPos(1, 127);
-         else if ((active2 & 0x2L) != 0x0L)
-            return jjStopAtPos(1, 129);
-         else if ((active2 & 0x8L) != 0x0L)
-            return jjStopAtPos(1, 131);
-         else if ((active2 & 0x20L) != 0x0L)
-            return jjStopAtPos(1, 133);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x10000L);
+         else if ((active2 & 0x1L) != 0x0L)
+            return jjStopAtPos(1, 128);
+         else if ((active2 & 0x4L) != 0x0L)
+            return jjStopAtPos(1, 130);
+         else if ((active2 & 0x10L) != 0x0L)
+            return jjStopAtPos(1, 132);
+         else if ((active2 & 0x40L) != 0x0L)
+            return jjStopAtPos(1, 134);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x20000L);
       case '>':
-         if ((active1 & 0x80000000000000L) != 0x0L)
+         if ((active1 & 0x100000000000000L) != 0x0L)
          {
-            jjmatchedKind = 119;
+            jjmatchedKind = 120;
             jjmatchedPos = 1;
          }
-         else if ((active2 & 0x8000L) != 0x0L)
-            return jjStopAtPos(1, 143);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2800L);
+         else if ((active2 & 0x10000L) != 0x0L)
+            return jjStopAtPos(1, 144);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x5000L);
       case '?':
-         if ((active2 & 0x40000L) != 0x0L)
+         if ((active2 & 0x80000L) != 0x0L)
          {
-            jjmatchedKind = 146;
+            jjmatchedKind = 147;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x40000L);
       case 'a':
-         return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0x1000000000L, active2, 0x1L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x120008030000L, active1, 0x2000000000L, active2, 0x2L);
       case 'b':
-         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x1500000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa2_0(active0, 0x820000200000L, active1, 0x0L, active2, 0x2000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x1040000200000L, active1, 0x0L, active2, 0x4000000L);
       case 'f':
          if ((active0 & 0x200000000L) != 0x0L)
             return jjStartNfaWithStates_0(1, 33, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x80400000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x100800000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa2_0(active0, 0x10c1000000040000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x2182000000040000L, active1, 0x0L, active2, 0x0L);
       case 'i':
          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x40000021000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x80000042000000L, active2, 0x800L);
       case 'm':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x4000000000000L, active2, 0x40L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x8000000000000L, active2, 0x80L);
       case 'n':
-         return jjMoveStringLiteralDfa2_0(active0, 0x7002000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xd002000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x400000L) != 0x0L)
          {
             jjmatchedKind = 22;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0xc00008180981000L, active1, 0x400000000L, active2, 0x4L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x1800010180981000L, active1, 0x800000000L, active2, 0x8L);
       case 'p':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x10000000000000L, active2, 0x100L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x20000000000000L, active2, 0x200L);
       case 'r':
-         return jjMoveStringLiteralDfa2_0(active0, 0x320300000002000L, active1, 0x500000000000000L, active2, 0x5000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x640600000002000L, active1, 0xa00000000000000L, active2, 0xa000L);
+      case 's':
+         if ((active0 & 0x2000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(1, 37, 42);
+         break;
       case 't':
-         return jjMoveStringLiteralDfa2_0(active0, 0x6000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc000000000000L, active1, 0x0L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa2_0(active0, 0x440000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x880000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
       case 'x':
-         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x20L);
       case 'y':
-         return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x20000000008000L, active1, 0x0L, active2, 0x0L);
       case '|':
-         if ((active1 & 0x200000000L) != 0x0L)
-            return jjStopAtPos(1, 97);
+         if ((active1 & 0x400000000L) != 0x0L)
+            return jjStopAtPos(1, 98);
          break;
       default :
          break;
@@ -453,85 +457,85 @@ private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '.':
-         if ((active2 & 0x800000L) != 0x0L)
-            return jjStopAtPos(2, 151);
+         if ((active2 & 0x1000000L) != 0x0L)
+            return jjStopAtPos(2, 152);
          break;
       case '=':
-         if ((active2 & 0x80L) != 0x0L)
-            return jjStopAtPos(2, 135);
-         else if ((active2 & 0x200L) != 0x0L)
-            return jjStopAtPos(2, 137);
-         else if ((active2 & 0x800L) != 0x0L)
-            return jjStopAtPos(2, 139);
-         else if ((active2 & 0x20000L) != 0x0L)
-            return jjStopAtPos(2, 145);
+         if ((active2 & 0x100L) != 0x0L)
+            return jjStopAtPos(2, 136);
+         else if ((active2 & 0x400L) != 0x0L)
+            return jjStopAtPos(2, 138);
+         else if ((active2 & 0x1000L) != 0x0L)
+            return jjStopAtPos(2, 140);
+         else if ((active2 & 0x40000L) != 0x0L)
+            return jjStopAtPos(2, 146);
          break;
       case '>':
-         if ((active1 & 0x200000000000000L) != 0x0L)
+         if ((active1 & 0x400000000000000L) != 0x0L)
          {
-            jjmatchedKind = 121;
+            jjmatchedKind = 122;
             jjmatchedPos = 2;
          }
-         else if ((active2 & 0x10000L) != 0x0L)
-            return jjStopAtPos(2, 144);
-         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
+         else if ((active2 & 0x20000L) != 0x0L)
+            return jjStopAtPos(2, 145);
+         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x4000L);
       case 'a':
-         return jjMoveStringLiteralDfa3_0(active0, 0x22000000044000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x44000000044000L, active1, 0x0L, active2, 0x0L);
       case 'b':
-         return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
-         return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa3_0(active0, 0x2000L, active1, 0x40000000000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2000L, active1, 0x80000000000000L, active2, 0x800L);
       case 'f':
-         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x2000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x4000000L);
       case 'i':
-         return jjMoveStringLiteralDfa3_0(active0, 0x1408100000000000L, active1, 0x501500000000000L, active2, 0x5000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2810200000000000L, active1, 0xa02a00000000000L, active2, 0xa000L);
       case 'l':
-         return jjMoveStringLiteralDfa3_0(active0, 0x800040008000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x1000080008000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa3_0(active0, 0x10008030180000L, active1, 0x1000000000L, active2, 0x1L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x20010030180000L, active1, 0x2000000000L, active2, 0x2L);
       case 'o':
-         return jjMoveStringLiteralDfa3_0(active0, 0x1200040001000L, active1, 0x14000000000000L, active2, 0x150L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2400040001000L, active1, 0x28000000000000L, active2, 0x2a0L);
       case 'p':
          return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x80000000L) != 0x0L)
             return jjStartNfaWithStates_0(2, 31, 42);
-         else if ((active1 & 0x400000000L) != 0x0L)
+         else if ((active1 & 0x800000000L) != 0x0L)
          {
-            jjmatchedKind = 98;
+            jjmatchedKind = 99;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0xc4000000000000L, active1, 0x0L, active2, 0x4L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x188000000000000L, active1, 0x0L, active2, 0x8L);
       case 's':
          return jjMoveStringLiteralDfa3_0(active0, 0x1001010800L, active1, 0x0L, active2, 0x0L);
       case 't':
-         if ((active0 & 0x2000000000L) != 0x0L)
+         if ((active0 & 0x4000000000L) != 0x0L)
          {
-            jjmatchedKind = 37;
+            jjmatchedKind = 38;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x400000L) != 0x0L)
+         else if ((active1 & 0x800000L) != 0x0L)
          {
-            jjmatchedKind = 86;
+            jjmatchedKind = 87;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x1000000L) != 0x0L)
+         else if ((active1 & 0x2000000L) != 0x0L)
          {
-            jjmatchedKind = 88;
+            jjmatchedKind = 89;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0xa0000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x1028104028000L, active1, 0x140000000L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa3_0(active0, 0x100000002800000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000002800000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active0 & 0x20000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(2, 41, 42);
+         if ((active0 & 0x40000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(2, 42, 42);
          break;
       case 'y':
-         if ((active0 & 0x200000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(2, 57, 42);
+         if ((active0 & 0x400000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(2, 58, 42);
          break;
       default :
          break;
@@ -549,31 +553,31 @@ private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '=':
-         if ((active2 & 0x2000L) != 0x0L)
-            return jjStopAtPos(3, 141);
+         if ((active2 & 0x4000L) != 0x0L)
+            return jjStopAtPos(3, 142);
          break;
       case '_':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x4L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 'a':
-         return jjMoveStringLiteralDfa4_0(active0, 0x800000070202000L, active1, 0x0L, active2, 0x2000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000070202000L, active1, 0x0L, active2, 0x4000000L);
       case 'b':
          return jjMoveStringLiteralDfa4_0(active0, 0x800000L, active1, 0x0L, active2, 0x0L);
       case 'c':
-         return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x20000000020000L, active1, 0x0L, active2, 0x0L);
       case 'd':
-         if ((active0 & 0x400000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 58, 42);
-         else if ((active1 & 0x1000000000L) != 0x0L)
+         if ((active0 & 0x800000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 59, 42);
+         else if ((active1 & 0x2000000000L) != 0x0L)
          {
-            jjmatchedKind = 100;
+            jjmatchedKind = 101;
             jjmatchedPos = 3;
          }
-         else if ((active1 & 0x4000000000000L) != 0x0L)
+         else if ((active1 & 0x8000000000000L) != 0x0L)
          {
-            jjmatchedKind = 114;
+            jjmatchedKind = 115;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x41L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x82L);
       case 'e':
          if ((active0 & 0x8000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 15, 42);
@@ -581,52 +585,52 @@ else if ((active0 & 0x10000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 16, 42);
          else if ((active0 & 0x1000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 24, 42);
-         else if ((active0 & 0x100000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 56, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x4004000000L, active1, 0xa0000000L, active2, 0x0L);
+         else if ((active0 & 0x200000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 57, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x8004000000L, active1, 0x140000000L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x40000000000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'g':
-         if ((active0 & 0x8000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 39, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x500000000000000L, active2, 0x5000L);
+         if ((active0 & 0x10000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 40, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 'i':
-         return jjMoveStringLiteralDfa4_0(active0, 0x4010000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x8020000000000L, active1, 0x0L, active2, 0x0L);
       case 'k':
-         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         if ((active0 & 0x40000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 42, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x1000400400001000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x80000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 43, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000800400001000L, active1, 0x0L, active2, 0x0L);
       case 'm':
          if ((active0 & 0x2000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 25, 42);
          break;
       case 'n':
-         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x100000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 32, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x180000800000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x40000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 18, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0x0L, active2, 0x20L);
       case 's':
          return jjMoveStringLiteralDfa4_0(active0, 0x8084000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa4_0(active0, 0xa201000100800L, active1, 0x1500000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x14401000100800L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x0L, active2, 0x0L);
       case 'v':
-         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active1 & 0x10000000000000L) != 0x0L)
+         if ((active1 & 0x20000000000000L) != 0x0L)
          {
-            jjmatchedKind = 116;
+            jjmatchedKind = 117;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x100L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x200L);
       default :
          break;
    }
@@ -643,23 +647,23 @@ private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0x151L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0x2a2L);
       case 'a':
-         return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L, active1, 0x0L, active2, 0x4L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x301000000000L, active1, 0x0L, active2, 0x8L);
       case 'c':
-         return jjMoveStringLiteralDfa5_0(active0, 0xc000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x18000000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x8000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 27, 42);
-         else if ((active0 & 0x1000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 60, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x200400001000L, active1, 0x0L, active2, 0x0L);
+         else if ((active0 & 0x2000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 61, 42);
+         return jjMoveStringLiteralDfa5_0(active0, 0x400400001000L, active1, 0x0L, active2, 0x0L);
       case 'h':
          if ((active0 & 0x20000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 17, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L, active1, 0x500000000000000L, active2, 0x5000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 'i':
-         return jjMoveStringLiteralDfa5_0(active0, 0x2400000100000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x4800000100000L, active1, 0x0L, active2, 0x0L);
       case 'k':
          if ((active0 & 0x2000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 13, 42);
@@ -674,36 +678,36 @@ else if ((active0 & 0x1000000000000000L) != 0x0L)
       case 'n':
          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'q':
-         if ((active1 & 0x20000000L) != 0x0L)
-            return jjStopAtPos(4, 93);
-         else if ((active1 & 0x80000000L) != 0x0L)
-            return jjStopAtPos(4, 95);
+         if ((active1 & 0x40000000L) != 0x0L)
+            return jjStopAtPos(4, 94);
+         else if ((active1 & 0x100000000L) != 0x0L)
+            return jjStopAtPos(4, 96);
          break;
       case 'r':
-         return jjMoveStringLiteralDfa5_0(active0, 0x804800000800L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x1008800000800L, active1, 0x0L, active2, 0x0L);
       case 's':
          if ((active0 & 0x4000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 14, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
          if ((active0 & 0x80000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 19, 42);
          else if ((active0 & 0x40000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 30, 42);
-         else if ((active0 & 0x1000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 48, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0x40000000000000L, active2, 0x400L);
+         else if ((active0 & 0x2000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 49, 42);
+         return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0x80000000000000L, active2, 0x800L);
       case 'u':
-         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x2000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x4000000L);
       case 'v':
-         return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active0 & 0x40000000000000L) != 0x0L)
+         if ((active0 & 0x80000000000000L) != 0x0L)
          {
-            jjmatchedKind = 54;
+            jjmatchedKind = 55;
             jjmatchedPos = 4;
          }
-         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0x1500000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0x2a00000000000L, active2, 0x0L);
       default :
          break;
    }
@@ -720,51 +724,51 @@ private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x40000000000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'a':
-         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0x151L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0x2a2L);
       case 'c':
-         if ((active0 & 0x400000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 46, 42);
-         else if ((active0 & 0x2000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 49, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x800000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 47, 42);
+         else if ((active0 & 0x4000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 50, 42);
+         return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
       case 'd':
          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x800000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 23, 42);
-         else if ((active0 & 0x10000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 40, 42);
+         else if ((active0 & 0x20000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 41, 42);
          break;
       case 'f':
-         return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0x0L, active2, 0x0L);
       case 'g':
-         return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
       case 'h':
-         if ((active0 & 0x8000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 51, 42);
+         if ((active0 & 0x10000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 52, 42);
          break;
       case 'i':
-         return jjMoveStringLiteralDfa6_0(active0, 0x820000000000000L, active1, 0x1500000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x1040000000000000L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x2000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x4000000L);
       case 'm':
          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         if ((active0 & 0x800000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 47, 42);
+         if ((active0 & 0x1000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 48, 42);
          return jjMoveStringLiteralDfa6_0(active0, 0x1000100000L, active1, 0x0L, active2, 0x0L);
       case 'r':
-         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 's':
-         if ((active0 & 0x80000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 55, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x4L);
+         if ((active0 & 0x100000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 56, 42);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 't':
          if ((active0 & 0x800000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 35, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x4100000000000L, active1, 0x500000000000000L, active2, 0x5000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x8200000000000L, active1, 0xa00000000000000L, active2, 0xa000L);
       default :
          break;
    }
@@ -781,38 +785,38 @@ private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x500000000000000L, active2, 0x5000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 'a':
-         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
          return jjMoveStringLiteralDfa7_0(active0, 0x1000000800L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         if ((active0 & 0x80000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(6, 43, 42);
-         else if ((active0 & 0x100000000000L) != 0x0L)
+         if ((active0 & 0x100000000000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 44, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x20000400000000L, active1, 0x0L, active2, 0x0L);
+         else if ((active0 & 0x200000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(6, 45, 42);
+         return jjMoveStringLiteralDfa7_0(active0, 0x40000400000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
          if ((active0 & 0x1000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 12, 42);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 's':
          if ((active0 & 0x4000000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 26, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x41500000000000L, active2, 0x555L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x82a00000000000L, active2, 0xaaaL);
       case 't':
          if ((active0 & 0x200000L) != 0x0L)
          {
             jjmatchedKind = 21;
             jjmatchedPos = 6;
          }
-         return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x2000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x4000000L);
       case 'u':
          return jjMoveStringLiteralDfa7_0(active0, 0x100000L, active1, 0x0L, active2, 0x0L);
       case 'y':
@@ -835,35 +839,35 @@ private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case ':':
-         if ((active2 & 0x2000000L) != 0x0L)
-            return jjStopAtPos(7, 153);
+         if ((active2 & 0x4000000L) != 0x0L)
+            return jjStopAtPos(7, 154);
          break;
       case 'c':
-         return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x100000L) != 0x0L)
             return jjStartNfaWithStates_0(7, 20, 42);
-         else if ((active0 & 0x800000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(7, 59, 42);
-         return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L, active1, 0x1500000000000L, active2, 0x0L);
+         else if ((active0 & 0x1000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(7, 60, 42);
+         return jjMoveStringLiteralDfa8_0(active0, 0x401000000000L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x40000000000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'i':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x4L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 'n':
-         return jjMoveStringLiteralDfa8_0(active0, 0x30000400000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x60000400000000L, active1, 0x0L, active2, 0x0L);
       case 'p':
-         if ((active0 & 0x4000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(7, 50, 42);
+         if ((active0 & 0x8000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(7, 51, 42);
          break;
       case 's':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1151L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x22a2L);
       case 't':
          if ((active0 & 0x800L) != 0x0L)
             return jjStartNfaWithStates_0(7, 11, 42);
          break;
       case 'u':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -880,28 +884,28 @@ private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x1500000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'd':
-         if ((active0 & 0x200000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 45, 42);
+         if ((active0 & 0x400000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 46, 42);
          break;
       case 'e':
-         if ((active0 & 0x4000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 38, 42);
+         if ((active0 & 0x8000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 39, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x4L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 'h':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'i':
-         return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L, active1, 0x40000000000000L, active2, 0x551L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0x80000000000000L, active2, 0xaa2L);
       case 'n':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'o':
          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         if ((active0 & 0x20000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 53, 42);
+         if ((active0 & 0x40000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 54, 42);
          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       default :
          break;
@@ -919,29 +923,29 @@ private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x100000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000L, active2, 0x0L);
       case 'f':
          if ((active0 & 0x1000000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 36, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x40000000000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'g':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0x151L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0x2a2L);
       case 'i':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'n':
-         if ((active2 & 0x4L) != 0x0L)
-            return jjStopAtPos(9, 130);
+         if ((active2 & 0x8L) != 0x0L)
+            return jjStopAtPos(9, 131);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
       case 's':
          if ((active0 & 0x400000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 34, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'x':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x1000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
       case 'z':
-         return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       default :
          break;
    }
@@ -958,34 +962,34 @@ private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case 'e':
-         return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'i':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x1L) != 0x0L)
-            return jjStopAtPos(10, 128);
-         else if ((active2 & 0x10L) != 0x0L)
-            return jjStopAtPos(10, 132);
-         else if ((active2 & 0x40L) != 0x0L)
-            return jjStopAtPos(10, 134);
-         else if ((active2 & 0x100L) != 0x0L)
-            return jjStopAtPos(10, 136);
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x100000000000L, active2, 0x0L);
+         if ((active2 & 0x2L) != 0x0L)
+            return jjStopAtPos(10, 129);
+         else if ((active2 & 0x20L) != 0x0L)
+            return jjStopAtPos(10, 133);
+         else if ((active2 & 0x80L) != 0x0L)
+            return jjStopAtPos(10, 135);
+         else if ((active2 & 0x200L) != 0x0L)
+            return jjStopAtPos(10, 137);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x200000000000L, active2, 0x0L);
       case 'o':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x1000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
       case 'r':
-         if ((active1 & 0x400000000000L) != 0x0L)
-            return jjStopAtPos(10, 110);
+         if ((active1 & 0x800000000000L) != 0x0L)
+            return jjStopAtPos(10, 111);
          break;
       case 't':
-         if ((active1 & 0x40000000000000L) != 0x0L)
+         if ((active1 & 0x80000000000000L) != 0x0L)
          {
-            jjmatchedKind = 118;
+            jjmatchedKind = 119;
             jjmatchedPos = 10;
          }
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
       default :
          break;
    }
@@ -1002,26 +1006,26 @@ private int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
       case 'd':
-         if ((active0 & 0x10000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(11, 52, 42);
-         else if ((active1 & 0x100000000000L) != 0x0L)
-            return jjStopAtPos(11, 108);
+         if ((active0 & 0x20000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(11, 53, 42);
+         else if ((active1 & 0x200000000000L) != 0x0L)
+            return jjStopAtPos(11, 109);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'r':
-         if ((active1 & 0x1000000000000L) != 0x0L)
-            return jjStopAtPos(11, 112);
+         if ((active1 & 0x2000000000000L) != 0x0L)
+            return jjStopAtPos(11, 113);
          break;
       case 't':
-         if ((active1 & 0x100000000000000L) != 0x0L)
+         if ((active1 & 0x200000000000000L) != 0x0L)
          {
-            jjmatchedKind = 120;
+            jjmatchedKind = 121;
             jjmatchedPos = 11;
          }
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
       default :
          break;
    }
@@ -1038,11 +1042,11 @@ private int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x2000L);
       case 'a':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x800L);
       case 'n':
-         return jjMoveStringLiteralDfa13_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -1059,11 +1063,11 @@ private int jjMoveStringLiteralDfa13_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x2000L);
       case 'e':
-         return jjMoveStringLiteralDfa14_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 's':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x800L);
       default :
          break;
    }
@@ -1080,9 +1084,9 @@ private int jjMoveStringLiteralDfa14_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'd':
-         return jjMoveStringLiteralDfa15_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 's':
-         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0x1400L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0x2800L);
       default :
          break;
    }
@@ -1099,11 +1103,11 @@ private int jjMoveStringLiteralDfa15_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa16_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 'i':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x800L);
       case 's':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x2000L);
       default :
          break;
    }
@@ -1120,11 +1124,11 @@ private int jjMoveStringLiteralDfa16_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x800L);
       case 'i':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x2000L);
       case 's':
-         return jjMoveStringLiteralDfa17_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -1141,12 +1145,12 @@ private int jjMoveStringLiteralDfa17_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x2000L);
       case 'h':
-         return jjMoveStringLiteralDfa18_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x400L) != 0x0L)
-            return jjStopAtPos(17, 138);
+         if ((active2 & 0x800L) != 0x0L)
+            return jjStopAtPos(17, 139);
          break;
       default :
          break;
@@ -1164,10 +1168,10 @@ private int jjMoveStringLiteralDfa18_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa19_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa19_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x1000L) != 0x0L)
-            return jjStopAtPos(18, 140);
+         if ((active2 & 0x2000L) != 0x0L)
+            return jjStopAtPos(18, 141);
          break;
       default :
          break;
@@ -1185,7 +1189,7 @@ private int jjMoveStringLiteralDfa19_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'f':
-         return jjMoveStringLiteralDfa20_0(active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa20_0(active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -1202,12 +1206,12 @@ private int jjMoveStringLiteralDfa20_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 't':
-         if ((active1 & 0x400000000000000L) != 0x0L)
+         if ((active1 & 0x800000000000000L) != 0x0L)
          {
-            jjmatchedKind = 122;
+            jjmatchedKind = 123;
             jjmatchedPos = 20;
          }
-         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x8000L);
       default :
          break;
    }
@@ -1224,7 +1228,7 @@ private int jjMoveStringLiteralDfa21_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa22_0(active2, 0x4000L);
+         return jjMoveStringLiteralDfa22_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1241,7 +1245,7 @@ private int jjMoveStringLiteralDfa22_0(long old2, long active2){
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa23_0(active2, 0x4000L);
+         return jjMoveStringLiteralDfa23_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1258,7 +1262,7 @@ private int jjMoveStringLiteralDfa23_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa24_0(active2, 0x4000L);
+         return jjMoveStringLiteralDfa24_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1275,7 +1279,7 @@ private int jjMoveStringLiteralDfa24_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa25_0(active2, 0x4000L);
+         return jjMoveStringLiteralDfa25_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1292,7 +1296,7 @@ private int jjMoveStringLiteralDfa25_0(long old2, long active2){
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa26_0(active2, 0x4000L);
+         return jjMoveStringLiteralDfa26_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1309,7 +1313,7 @@ private int jjMoveStringLiteralDfa26_0(long old2, long active2){
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa27_0(active2, 0x4000L);
+         return jjMoveStringLiteralDfa27_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1326,8 +1330,8 @@ private int jjMoveStringLiteralDfa27_0(long old2, long active2){
    switch(curChar)
    {
       case 'n':
-         if ((active2 & 0x4000L) != 0x0L)
-            return jjStopAtPos(27, 142);
+         if ((active2 & 0x8000L) != 0x0L)
+            return jjStopAtPos(27, 143);
          break;
       default :
          break;
@@ -1421,8 +1425,8 @@ else if (curChar == 47)
                      { jjAddStates(13, 14); }
                   else if (curChar == 36)
                   {
-                     if (kind > 72)
-                        kind = 72;
+                     if (kind > 73)
+                        kind = 73;
                      { jjCheckNAdd(42); }
                   }
                   else if (curChar == 34)
@@ -1437,14 +1441,14 @@ else if (curChar == 60)
                      { jjCheckNAddStates(0, 3); }
                   if ((0x3fe000000000000L & l) != 0x0L)
                   {
-                     if (kind > 61)
-                        kind = 61;
+                     if (kind > 62)
+                        kind = 62;
                      { jjCheckNAddTwoStates(15, 16); }
                   }
                   else if (curChar == 48)
                   {
-                     if (kind > 61)
-                        kind = 61;
+                     if (kind > 62)
+                        kind = 62;
                      { jjCheckNAddStates(18, 21); }
                   }
                   else if (curChar == 34)
@@ -1511,15 +1515,15 @@ else if (curChar == 34)
                case 14:
                   if ((0x3fe000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 15:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 17:
@@ -1529,8 +1533,8 @@ else if (curChar == 34)
                case 18:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 66)
-                     kind = 66;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddStates(28, 30); }
                   break;
                case 20:
@@ -1540,8 +1544,8 @@ else if (curChar == 34)
                case 21:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 66)
-                     kind = 66;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddTwoStates(21, 22); }
                   break;
                case 23:
@@ -1556,8 +1560,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(15, 17); }
                   break;
                case 27:
-                  if (curChar == 39 && kind > 69)
-                     kind = 69;
+                  if (curChar == 39 && kind > 70)
+                     kind = 70;
                   break;
                case 28:
                   if (curChar == 34)
@@ -1571,8 +1575,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(22, 24); }
                   break;
                case 32:
-                  if (curChar == 34 && kind > 70)
-                     kind = 70;
+                  if (curChar == 34 && kind > 71)
+                     kind = 71;
                   break;
                case 33:
                case 35:
@@ -1584,8 +1588,8 @@ else if (curChar == 34)
                      { jjCheckNAddStates(31, 33); }
                   break;
                case 36:
-                  if (curChar == 34 && kind > 71)
-                     kind = 71;
+                  if (curChar == 34 && kind > 72)
+                     kind = 72;
                   break;
                case 37:
                   if (curChar == 34)
@@ -1606,15 +1610,15 @@ else if (curChar == 34)
                case 41:
                   if (curChar != 36)
                      break;
-                  if (kind > 72)
-                     kind = 72;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 42:
                   if ((0x3ff001000000000L & l) == 0x0L)
                      break;
-                  if (kind > 72)
-                     kind = 72;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 43:
@@ -1628,15 +1632,15 @@ else if (curChar == 34)
                case 45:
                   if (curChar != 46)
                      break;
-                  if (kind > 66)
-                     kind = 66;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 46:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 66)
-                     kind = 66;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 48:
@@ -1646,8 +1650,8 @@ else if (curChar == 34)
                case 49:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 66)
-                     kind = 66;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddTwoStates(49, 22); }
                   break;
                case 50:
@@ -1661,8 +1665,8 @@ else if (curChar == 34)
                case 53:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 66)
-                     kind = 66;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddTwoStates(53, 22); }
                   break;
                case 54:
@@ -1672,36 +1676,36 @@ else if (curChar == 34)
                case 56:
                   if (curChar != 48)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(18, 21); }
                   break;
                case 58:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 60:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 61:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAdd(16); }
                   break;
                case 62:
                   if ((0xff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(62, 16); }
                   break;
                case 63:
@@ -1771,8 +1775,8 @@ else if (curChar < 128)
                case 42:
                   if ((0x7fffffe87fffffeL & l) == 0x0L)
                      break;
-                  if (kind > 72)
-                     kind = 72;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 9:
@@ -1781,21 +1785,21 @@ else if (curChar < 128)
                case 15:
                   if (curChar != 95)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 16:
-                  if ((0x88920000889200L & l) != 0x0L && kind > 61)
-                     kind = 61;
+                  if ((0x88920000889200L & l) != 0x0L && kind > 62)
+                     kind = 62;
                   break;
                case 19:
                   if ((0x2000000020L & l) != 0x0L)
                      { jjAddStates(43, 44); }
                   break;
                case 22:
-                  if ((0x80005000800050L & l) != 0x0L && kind > 66)
-                     kind = 66;
+                  if ((0x80005000800050L & l) != 0x0L && kind > 67)
+                     kind = 67;
                   break;
                case 24:
                   if ((0xffffffffefffffffL & l) != 0x0L)
@@ -1831,8 +1835,8 @@ else if (curChar < 128)
                      { jjAddStates(47, 48); }
                   break;
                case 55:
-                  if ((0x5000000050L & l) != 0x0L && kind > 66)
-                     kind = 66;
+                  if ((0x5000000050L & l) != 0x0L && kind > 67)
+                     kind = 67;
                   break;
                case 57:
                   if ((0x100000001000000L & l) != 0x0L)
@@ -1841,22 +1845,22 @@ else if (curChar < 128)
                case 58:
                   if ((0x7e8000007eL & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 59:
                   if ((0x400000004L & l) == 0x0L)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 60:
                   if (curChar != 95)
                      break;
-                  if (kind > 61)
-                     kind = 61;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 65:
@@ -1900,8 +1904,8 @@ else if (curChar < 128)
                   }
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
                   {
-                     if (kind > 72)
-                        kind = 72;
+                     if (kind > 73)
+                        kind = 73;
                      { jjCheckNAdd(42); }
                   }
                   break;
@@ -1934,8 +1938,8 @@ else if (curChar < 128)
                case 42:
                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
                      break;
-                  if (kind > 72)
-                     kind = 72;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 65:
@@ -1984,7 +1988,7 @@ else if (curChar < 128)
 "\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\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\163", "\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", 
@@ -2282,10 +2286,10 @@ public void SwitchTo(int lexState)
    -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 = {
-   0x3ffffffffffff801L, 0xfffffffffffff9e4L, 0x3ffffffL, 
+   0x7ffffffffffff801L, 0xfffffffffffff3c8L, 0x7ffffffL, 
 };
 static final long[] jjtoSkip = {
    0x7feL, 0x0L, 0x0L, 
diff --git a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
index 24e5b9e..23b758f 100644
--- a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
+++ b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
@@ -444,6 +444,7 @@ TOKEN : /* RESERVED WORDS AND LITERALS */
 | < IMPLEMENTS: "implements" >
 | < IMPORT: "import" >
 | < INSTANCEOF: "instanceof" >
+| < IS: "is" >
 | < INT: "int" >
 | < INTERFACE: "interface" >
 | < LONG: "long" >
@@ -984,10 +985,11 @@ void EqualityExpression() :
 }
 
 void InstanceOfExpression() :
-{ Token t = null; }
+{}
 {
   RelationalExpression()
-  [t = <INSTANCEOF> Type() { jjtThis.kind = t.kind; } #BinaryExpression(2) ]
+  [(<INSTANCEOF> | <IS>) Type()
+    { jjtThis.kind = INSTANCEOF; } #BinaryExpression(2) ]
 }
 
 void RelationalExpression() :

From 417f7e5d65a1473ff4dd6da4051c63f0d819820b Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 23 Apr 2026 13:07:05 +0800
Subject: [PATCH 05/27] feat: support kotlin-style as cast operator

---
 README.md                                     |    7 +-
 .../main/java/bsh/BSHBinaryExpression.java    |   14 +-
 .../src/main/java/bsh/Parser.java             | 1485 +++++++++--------
 .../src/main/java/bsh/ParserConstants.java    |  233 +--
 .../src/main/java/bsh/ParserTokenManager.java |  908 +++++-----
 .../src/main/jjtree/bsh.jjt                   |   12 +-
 6 files changed, 1369 insertions(+), 1290 deletions(-)

diff --git a/README.md b/README.md
index c899fcf..968425d 100644
--- a/README.md
+++ b/README.md
@@ -117,9 +117,12 @@ hi("user") // name: user, age: 18
 hi("user", 1) // name: user, age: 1
 
 // 类型判断
-print("abc" is String) // true
 print(123 is Number) // true
-print(null is Object) // false
+// 等价: print(123 instanceof Number) // true
+
+// 类型转换
+print("1" as int) // 1
+// 等价: print((int) "1") // 1
 ```
 
 ## 致谢
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java
index 0b9ffcb..5298905 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java
@@ -45,7 +45,7 @@ public Object eval( CallStack callstack, Interpreter interpreter)
         /*
             Doing instanceof?  Next node is a type.
         */
-        if (kind == INSTANCEOF)
+        if ( (kind == INSTANCEOF || kind == IS) )
         {
             // null object ref is not instance of any type
             if ( lhs == Primitive.NULL )
@@ -72,6 +72,18 @@ public Object eval( CallStack callstack, Interpreter interpreter)
                     ? Primitive.TRUE : Primitive.FALSE;
         }
 
+        if (kind == AS)
+        {
+            Class<?> rhs = ((BSHType)jjtGetChild(1)).getType(
+                callstack, interpreter );
+
+            try {
+                return Types.castObject( lhs, rhs, Types.CAST );
+            } catch ( UtilEvalError e ) {
+                throw e.toEvalError( this, callstack );
+            }
+        }
+
         /*
             Look ahead and short circuit evaluation of the rhs if:
             we're a boolean AND and the lhs is false.
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
index d765b35..d3f9ef2 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
@@ -2049,49 +2049,84 @@ final public void ConditionalExpression() throws ParseException {
     }
 }
 
-  final public void InstanceOfExpression() throws ParseException {
+  final public void InstanceOfExpression() throws ParseException {Token t = null;
     RelationalExpression();
     switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
     case INSTANCEOF:
-    case IS:{
+    case IS:
+    case AS:{
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
-      case INSTANCEOF:{
-        jj_consume_token(INSTANCEOF);
-        break;
-        }
+      case INSTANCEOF:
       case IS:{
-        jj_consume_token(IS);
-        break;
+        switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
+        case INSTANCEOF:{
+          t = jj_consume_token(INSTANCEOF);
+          break;
+          }
+        case IS:{
+          t = jj_consume_token(IS);
+          break;
+          }
+        default:
+          jj_la1[51] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
         }
-      default:
-        jj_la1[51] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-      Type();
+        Type();
 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
-      boolean jjtc001 = true;
-      jjtree.openNodeScope(jjtn001);
-      jjtreeOpenNodeScope(jjtn001);
-      try {
+        boolean jjtc001 = true;
+        jjtree.openNodeScope(jjtn001);
+        jjtreeOpenNodeScope(jjtn001);
+        try {
 jjtree.closeNodeScope(jjtn001,  2);
-      jjtc001 = false;
-      if (jjtree.nodeCreated()) {
-       jjtreeCloseNodeScope(jjtn001);
-      }
-jjtn001.kind = INSTANCEOF;
-      } finally {
-if (jjtc001) {
-        jjtree.closeNodeScope(jjtn001,  2);
+        jjtc001 = false;
         if (jjtree.nodeCreated()) {
          jjtreeCloseNodeScope(jjtn001);
         }
-      }
+jjtn001.kind = t.kind;
+        } finally {
+if (jjtc001) {
+          jjtree.closeNodeScope(jjtn001,  2);
+          if (jjtree.nodeCreated()) {
+           jjtreeCloseNodeScope(jjtn001);
+          }
+        }
+        }
+        break;
+        }
+      case AS:{
+        t = jj_consume_token(AS);
+        Type();
+BSHBinaryExpression jjtn002 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
+        boolean jjtc002 = true;
+        jjtree.openNodeScope(jjtn002);
+        jjtreeOpenNodeScope(jjtn002);
+        try {
+jjtree.closeNodeScope(jjtn002,  2);
+        jjtc002 = false;
+        if (jjtree.nodeCreated()) {
+         jjtreeCloseNodeScope(jjtn002);
+        }
+jjtn002.kind = t.kind;
+        } finally {
+if (jjtc002) {
+          jjtree.closeNodeScope(jjtn002,  2);
+          if (jjtree.nodeCreated()) {
+           jjtreeCloseNodeScope(jjtn002);
+          }
+        }
+        }
+        break;
+        }
+      default:
+        jj_la1[52] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
       }
       break;
       }
     default:
-      jj_la1[52] = jj_gen;
+      jj_la1[53] = jj_gen;
       ;
     }
 }
@@ -2112,7 +2147,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[53] = jj_gen;
+        jj_la1[54] = jj_gen;
         break label_18;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2149,7 +2184,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[54] = jj_gen;
+        jj_la1[55] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2190,7 +2225,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[55] = jj_gen;
+        jj_la1[56] = jj_gen;
         break label_19;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2219,7 +2254,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[56] = jj_gen;
+        jj_la1[57] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2256,7 +2291,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[57] = jj_gen;
+        jj_la1[58] = jj_gen;
         break label_20;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2269,7 +2304,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[58] = jj_gen;
+        jj_la1[59] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2308,7 +2343,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[59] = jj_gen;
+        jj_la1[60] = jj_gen;
         break label_21;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2329,7 +2364,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[60] = jj_gen;
+        jj_la1[61] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2366,7 +2401,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[61] = jj_gen;
+        jj_la1[62] = jj_gen;
         break label_22;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2379,7 +2414,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[62] = jj_gen;
+        jj_la1[63] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2430,7 +2465,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[63] = jj_gen;
+        jj_la1[64] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2468,7 +2503,7 @@ final public void InstanceOfExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[64] = jj_gen;
+        jj_la1[65] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2495,7 +2530,7 @@ final public void InstanceOfExpression() throws ParseException {
       break;
       }
     default:
-      jj_la1[67] = jj_gen;
+      jj_la1[68] = jj_gen;
       if (jj_2_10(2147483647)) {
         LambdaExpression();
       } else if (jj_2_11(2147483647)) {
@@ -2538,7 +2573,7 @@ final public void InstanceOfExpression() throws ParseException {
               break;
               }
             default:
-              jj_la1[65] = jj_gen;
+              jj_la1[66] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -2564,13 +2599,13 @@ final public void InstanceOfExpression() throws ParseException {
             break;
             }
           default:
-            jj_la1[66] = jj_gen;
+            jj_la1[67] = jj_gen;
             ;
           }
           break;
           }
         default:
-          jj_la1[68] = jj_gen;
+          jj_la1[69] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2699,7 +2734,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[69] = jj_gen;
+        jj_la1[70] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2741,7 +2776,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[70] = jj_gen;
+        jj_la1[71] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2802,7 +2837,7 @@ final public void PrimaryPrefix() throws ParseException {
       break;
       }
     default:
-      jj_la1[71] = jj_gen;
+      jj_la1[72] = jj_gen;
       if (jj_2_13(2147483647)) {
         MethodInvocation();
       } else if (jj_2_14(2147483647)) {
@@ -2814,7 +2849,7 @@ final public void PrimaryPrefix() throws ParseException {
           break;
           }
         default:
-          jj_la1[72] = jj_gen;
+          jj_la1[73] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2875,7 +2910,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
             break;
             }
           default:
-            jj_la1[73] = jj_gen;
+            jj_la1[74] = jj_gen;
             ;
           }
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2917,7 +2952,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[74] = jj_gen;
+                jj_la1[75] = jj_gen;
                 ;
               }
 jjtn000.slice = true; jjtn000.step = true;
@@ -2960,7 +2995,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[75] = jj_gen;
+                jj_la1[76] = jj_gen;
                 ;
               }
               switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3000,26 +3035,26 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                   break;
                   }
                 default:
-                  jj_la1[76] = jj_gen;
+                  jj_la1[77] = jj_gen;
                   ;
                 }
                 break;
                 }
               default:
-                jj_la1[77] = jj_gen;
+                jj_la1[78] = jj_gen;
                 ;
               }
               break;
               }
             default:
-              jj_la1[78] = jj_gen;
+              jj_la1[79] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
             break;
             }
           default:
-            jj_la1[79] = jj_gen;
+            jj_la1[80] = jj_gen;
             ;
           }
           jj_consume_token(RBRACKET);
@@ -3032,7 +3067,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
           break;
           }
         default:
-          jj_la1[83] = jj_gen;
+          jj_la1[84] = jj_gen;
           if (getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET) {
             jj_consume_token(COLON_COLON);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3045,7 +3080,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[80] = jj_gen;
+              jj_la1[81] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -3057,7 +3092,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
 jjtn000.operation = BSHPrimarySuffix.METHODREF;
     jjtn000.field = t.image;
           } else if (jj_2_16(2)) {
-            jj_consume_token(153);
+            jj_consume_token(154);
             t = jj_consume_token(IDENTIFIER);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
             case LPAREN:{
@@ -3065,7 +3100,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[81] = jj_gen;
+              jj_la1[82] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3085,7 +3120,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[82] = jj_gen;
+              jj_la1[83] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3110,7 +3145,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[84] = jj_gen;
+              jj_la1[85] = jj_gen;
               if (jj_2_18(2)) {
                 jj_consume_token(DOT);
                 AllocationExpression();
@@ -3279,7 +3314,7 @@ final public void Literal() throws ParseException {/*@bgen(jjtree) Literal */
         break;
         }
       default:
-        jj_la1[85] = jj_gen;
+        jj_la1[86] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3320,7 +3355,7 @@ final public boolean BooleanLiteral() throws ParseException {
       break;
       }
     default:
-      jj_la1[86] = jj_gen;
+      jj_la1[87] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
@@ -3375,7 +3410,7 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
         break;
         }
       default:
-        jj_la1[87] = jj_gen;
+        jj_la1[88] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -3413,7 +3448,7 @@ final public void ArgumentList() throws ParseException {
         break;
         }
       default:
-        jj_la1[88] = jj_gen;
+        jj_la1[89] = jj_gen;
         break label_24;
       }
       jj_consume_token(COMMA);
@@ -3461,7 +3496,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[89] = jj_gen;
+            jj_la1[90] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3473,7 +3508,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[90] = jj_gen;
+          jj_la1[91] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3485,7 +3520,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[91] = jj_gen;
+        jj_la1[92] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3554,7 +3589,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
               break;
               }
             default:
-              jj_la1[92] = jj_gen;
+              jj_la1[93] = jj_gen;
               break label_27;
             }
           }
@@ -3572,7 +3607,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
           break;
           }
         default:
-          jj_la1[93] = jj_gen;
+          jj_la1[94] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3665,7 +3700,7 @@ void Statement() throws ParseException {
         break;
         }
       default:
-        jj_la1[94] = jj_gen;
+        jj_la1[95] = jj_gen;
         if (isRegularForStatement()) {
           ForStatement();
         } else {
@@ -3699,7 +3734,7 @@ void Statement() throws ParseException {
             break;
             }
           default:
-            jj_la1[95] = jj_gen;
+            jj_la1[96] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3759,7 +3794,7 @@ final public void Block() throws ParseException {/*@bgen(jjtree) Block */
         break;
         }
       default:
-        jj_la1[96] = jj_gen;
+        jj_la1[97] = jj_gen;
         ;
       }
       jj_consume_token(LBRACE);
@@ -3825,7 +3860,7 @@ final public void BlockStatement() throws ParseException {
         break;
         }
       default:
-        jj_la1[97] = jj_gen;
+        jj_la1[98] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3843,7 +3878,7 @@ final public void MethodDeclTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[98] = jj_gen;
+      jj_la1[99] = jj_gen;
       if (isImplicitMethodTerminator()) {
 
       } else {
@@ -3860,7 +3895,7 @@ final public void StatementTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[99] = jj_gen;
+      jj_la1[100] = jj_gen;
       ;
     }
 }
@@ -3884,11 +3919,11 @@ final public void SwitchStatement() throws ParseException {/*@bgen(jjtree) Switc
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CASE:
-        case 154:{
+        case 155:{
           break;
           }
         default:
-          jj_la1[100] = jj_gen;
+          jj_la1[101] = jj_gen;
           break label_29;
         }
         SwitchLabel();
@@ -3939,8 +3974,8 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         jj_consume_token(COLON);
         break;
         }
-      case 154:{
-        jj_consume_token(154);
+      case 155:{
+        jj_consume_token(155);
 jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                if (jjtree.nodeCreated()) {
@@ -3950,7 +3985,7 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         break;
         }
       default:
-        jj_la1[101] = jj_gen;
+        jj_la1[102] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3995,7 +4030,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[102] = jj_gen;
+        jj_la1[103] = jj_gen;
         if (jj_2_32(1)) {
           Statement();
         } else {
@@ -4010,7 +4045,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[103] = jj_gen;
+        jj_la1[104] = jj_gen;
         ;
       }
     } catch (Throwable jjte000) {
@@ -4173,7 +4208,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[104] = jj_gen;
+        jj_la1[105] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4211,7 +4246,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[105] = jj_gen;
+        jj_la1[106] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4249,7 +4284,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[106] = jj_gen;
+        jj_la1[107] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -4313,7 +4348,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[107] = jj_gen;
+            jj_la1[108] = jj_gen;
             ;
           }
           Type();
@@ -4331,7 +4366,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[108] = jj_gen;
+          jj_la1[109] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4397,7 +4432,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[109] = jj_gen;
+        jj_la1[110] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4426,7 +4461,7 @@ final public void TypedVariableDeclaration() throws ParseException {/*@bgen(jjtr
           break;
           }
         default:
-          jj_la1[110] = jj_gen;
+          jj_la1[111] = jj_gen;
           break label_31;
         }
         jj_consume_token(COMMA);
@@ -4476,7 +4511,7 @@ final public void StatementExpressionList() throws ParseException {/*@bgen(jjtre
           break;
           }
         default:
-          jj_la1[111] = jj_gen;
+          jj_la1[112] = jj_gen;
           break label_32;
         }
         jj_consume_token(COMMA);
@@ -4728,7 +4763,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[112] = jj_gen;
+        jj_la1[113] = jj_gen;
         ;
       }
       Block();
@@ -4739,7 +4774,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
           break;
           }
         default:
-          jj_la1[113] = jj_gen;
+          jj_la1[114] = jj_gen;
           break label_33;
         }
         jj_consume_token(CATCH);
@@ -4757,7 +4792,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[114] = jj_gen;
+        jj_la1[115] = jj_gen;
         ;
       }
 jjtree.closeNodeScope(jjtn000, true);
@@ -4804,7 +4839,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[115] = jj_gen;
+          jj_la1[116] = jj_gen;
           ;
         }
         Type();
@@ -4815,7 +4850,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
             break;
             }
           default:
-            jj_la1[116] = jj_gen;
+            jj_la1[117] = jj_gen;
             break label_34;
           }
           jj_consume_token(BIT_OR);
@@ -4841,7 +4876,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[117] = jj_gen;
+          jj_la1[118] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4885,7 +4920,7 @@ final public void TryWithResources() throws ParseException {/*@bgen(jjtree) TryW
           break;
           }
         default:
-          jj_la1[118] = jj_gen;
+          jj_la1[119] = jj_gen;
           break label_35;
         }
         jj_consume_token(SEMICOLON);
@@ -4932,7 +4967,7 @@ final public void AutoCloseable() throws ParseException {/*@bgen(jjtree) AutoClo
           break;
           }
         default:
-          jj_la1[119] = jj_gen;
+          jj_la1[120] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5341,15 +5376,38 @@ private boolean jj_2_38(int xla)
     finally { jj_save(37, xla); }
   }
 
-  private boolean jj_3R_169()
+  private boolean jj_3R_262()
+ {
+    if (jj_3R_263()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_168()
+ {
+    if (jj_3R_170()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_171()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_255()
+ {
+    if (jj_scan_token(FINAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_171()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(104)) {
+    if (jj_scan_token(105)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(105)) return true;
+    if (jj_scan_token(106)) return true;
     }
-    if (jj_3R_168()) return true;
+    if (jj_3R_170()) return true;
     return false;
   }
 
@@ -5361,32 +5419,32 @@ private boolean jj_3_34()
     return false;
   }
 
-  private boolean jj_3R_168()
+  private boolean jj_3R_170()
  {
-    if (jj_3R_170()) return true;
+    if (jj_3R_172()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_171()) { jj_scanpos = xsp; break; }
+      if (jj_3R_173()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_171()
+  private boolean jj_3R_173()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(106)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(107)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(114)) {
+    if (jj_scan_token(108)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(115)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(115)) return true;
+    if (jj_scan_token(116)) return true;
     }
     }
     }
-    if (jj_3R_170()) return true;
+    if (jj_3R_172()) return true;
     return false;
   }
 
@@ -5398,18 +5456,18 @@ private boolean jj_3R_97()
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_228()) { jj_scanpos = xsp; break; }
+      if (jj_3R_230()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_170()
+  private boolean jj_3R_172()
  {
-    if (jj_3R_172()) return true;
+    if (jj_3R_174()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_173()) { jj_scanpos = xsp; break; }
+      if (jj_3R_175()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
@@ -5420,42 +5478,42 @@ private boolean jj_3_32()
     return false;
   }
 
-  private boolean jj_3R_173()
+  private boolean jj_3R_175()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(116)) {
+    if (jj_scan_token(117)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(117)) return true;
+    if (jj_scan_token(118)) return true;
     }
-    if (jj_3R_172()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
-  private boolean jj_3R_261()
+  private boolean jj_3R_263()
  {
     if (jj_3R_107()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_265()) { jj_scanpos = xsp; break; }
+      if (jj_3R_267()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_172()
+  private boolean jj_3R_174()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_174()) {
-    jj_scanpos = xsp;
-    if (jj_3R_175()) {
-    jj_scanpos = xsp;
     if (jj_3R_176()) {
     jj_scanpos = xsp;
     if (jj_3R_177()) {
     jj_scanpos = xsp;
-    if (jj_3R_178()) return true;
+    if (jj_3R_178()) {
+    jj_scanpos = xsp;
+    if (jj_3R_179()) {
+    jj_scanpos = xsp;
+    if (jj_3R_180()) return true;
     }
     }
     }
@@ -5463,39 +5521,39 @@ private boolean jj_3R_172()
     return false;
   }
 
-  private boolean jj_3R_174()
+  private boolean jj_3R_176()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(104)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(105)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(91)) {
+    if (jj_scan_token(106)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(92)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(90)) return true;
+    if (jj_scan_token(91)) return true;
     }
     }
     }
-    if (jj_3R_172()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
-  private boolean jj_3R_252()
+  private boolean jj_3R_254()
  {
-    if (jj_3R_261()) return true;
+    if (jj_3R_263()) return true;
     return false;
   }
 
-  private boolean jj_3R_175()
+  private boolean jj_3R_177()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(102)) {
+    if (jj_scan_token(103)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(103)) return true;
+    if (jj_scan_token(104)) return true;
     }
-    if (jj_3R_181()) return true;
+    if (jj_3R_183()) return true;
     return false;
   }
 
@@ -5511,13 +5569,13 @@ private boolean jj_3R_114()
     return false;
   }
 
-  private boolean jj_3R_176()
+  private boolean jj_3R_178()
  {
-    if (jj_3R_179()) return true;
+    if (jj_3R_181()) return true;
     return false;
   }
 
-  private boolean jj_3R_243()
+  private boolean jj_3R_245()
  {
     if (jj_scan_token(ELSE)) return true;
     if (jj_3R_57()) return true;
@@ -5531,9 +5589,9 @@ private boolean jj_3_35()
     return false;
   }
 
-  private boolean jj_3R_177()
+  private boolean jj_3R_179()
  {
-    if (jj_3R_180()) return true;
+    if (jj_3R_182()) return true;
     return false;
   }
 
@@ -5543,12 +5601,12 @@ private boolean jj_3R_152()
     return false;
   }
 
-  private boolean jj_3R_178()
+  private boolean jj_3R_180()
  {
-    if (jj_3R_181()) return true;
+    if (jj_3R_183()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_182()) jj_scanpos = xsp;
+    if (jj_3R_184()) jj_scanpos = xsp;
     return false;
   }
 
@@ -5558,13 +5616,13 @@ private boolean jj_3_10()
     xsp = jj_scanpos;
     if (jj_3R_46()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(73)) return true;
+    if (jj_scan_token(74)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     return false;
   }
 
-  private boolean jj_3R_228()
+  private boolean jj_3R_230()
  {
     if (jj_scan_token(COMMA)) return true;
     if (jj_3R_60()) return true;
@@ -5583,7 +5641,7 @@ private boolean jj_3R_115()
     return false;
   }
 
-  private boolean jj_3R_265()
+  private boolean jj_3R_267()
  {
     if (jj_scan_token(COMMA)) return true;
     if (jj_3R_107()) return true;
@@ -5596,12 +5654,12 @@ private boolean jj_3R_46()
     return false;
   }
 
-  private boolean jj_3R_180()
+  private boolean jj_3R_182()
  {
     if (jj_scan_token(LPAREN)) return true;
     if (jj_3R_44()) return true;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_172()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
@@ -5626,9 +5684,9 @@ private boolean jj_3R_153()
     return false;
   }
 
-  private boolean jj_3R_181()
+  private boolean jj_3R_183()
  {
-    if (jj_3R_184()) return true;
+    if (jj_3R_186()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
@@ -5647,37 +5705,37 @@ private boolean jj_3R_116()
     return false;
   }
 
-  private boolean jj_3R_194()
+  private boolean jj_3R_196()
  {
     if (jj_3R_38()) return true;
-    if (jj_3R_203()) return true;
+    if (jj_3R_205()) return true;
     return false;
   }
 
-  private boolean jj_3R_182()
+  private boolean jj_3R_184()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(102)) {
+    if (jj_scan_token(103)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(103)) return true;
+    if (jj_scan_token(104)) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_179()
+  private boolean jj_3R_181()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_183()) {
+    if (jj_3R_185()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(73)) return true;
+    if (jj_scan_token(74)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_185()) {
+    if (jj_3R_187()) {
     jj_scanpos = xsp;
-    if (jj_3R_186()) return true;
+    if (jj_3R_188()) return true;
     }
     return false;
   }
@@ -5692,7 +5750,7 @@ private boolean jj_3R_117()
     return false;
   }
 
-  private boolean jj_3R_183()
+  private boolean jj_3R_185()
  {
     if (jj_3R_55()) return true;
     return false;
@@ -5704,7 +5762,7 @@ private boolean jj_3R_154()
     return false;
   }
 
-  private boolean jj_3R_185()
+  private boolean jj_3R_187()
  {
     if (jj_3R_50()) return true;
     return false;
@@ -5724,21 +5782,21 @@ private boolean jj_3R_118()
     return false;
   }
 
-  private boolean jj_3R_184()
+  private boolean jj_3R_186()
  {
     Token xsp;
     xsp = jj_scanpos;
-    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()) return true;
+    if (jj_3R_192()) {
+    jj_scanpos = xsp;
+    if (jj_3R_193()) {
+    jj_scanpos = xsp;
+    if (jj_3R_194()) return true;
     }
     }
     }
@@ -5747,13 +5805,13 @@ private boolean jj_3R_184()
     return false;
   }
 
-  private boolean jj_3R_187()
+  private boolean jj_3R_189()
  {
-    if (jj_3R_193()) return true;
+    if (jj_3R_195()) return true;
     return false;
   }
 
-  private boolean jj_3R_188()
+  private boolean jj_3R_190()
  {
     if (jj_scan_token(LPAREN)) return true;
     if (jj_3R_51()) return true;
@@ -5761,25 +5819,25 @@ private boolean jj_3R_188()
     return false;
   }
 
-  private boolean jj_3R_189()
+  private boolean jj_3R_191()
  {
     if (jj_3R_49()) return true;
     return false;
   }
 
-  private boolean jj_3R_186()
+  private boolean jj_3R_188()
  {
     if (jj_3R_51()) return true;
     return false;
   }
 
-  private boolean jj_3R_190()
+  private boolean jj_3R_192()
  {
-    if (jj_3R_194()) return true;
+    if (jj_3R_196()) return true;
     return false;
   }
 
-  private boolean jj_3R_191()
+  private boolean jj_3R_193()
  {
     if (jj_3R_44()) return true;
     return false;
@@ -5794,30 +5852,30 @@ private boolean jj_3R_119()
     if (jj_3R_50()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_247()) { jj_scanpos = xsp; break; }
+      if (jj_3R_249()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_248()) jj_scanpos = xsp;
+    if (jj_3R_250()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_192()
+  private boolean jj_3R_194()
  {
     if (jj_3R_38()) return true;
     return false;
   }
 
-  private boolean jj_3R_247()
+  private boolean jj_3R_249()
  {
     if (jj_scan_token(CATCH)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_254()) return true;
+    if (jj_3R_256()) return true;
     if (jj_scan_token(RPAREN)) return true;
     if (jj_3R_50()) return true;
     return false;
   }
 
-  private boolean jj_3R_248()
+  private boolean jj_3R_250()
  {
     if (jj_scan_token(FINALLY)) return true;
     if (jj_3R_50()) return true;
@@ -5832,7 +5890,7 @@ private boolean jj_3_13()
     xsp = jj_scanpos;
     if (jj_3R_48()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(77)) return true;
+    if (jj_scan_token(78)) return true;
     }
     return false;
   }
@@ -5865,13 +5923,13 @@ private boolean jj_3_37()
     return false;
   }
 
-  private boolean jj_3R_254()
+  private boolean jj_3R_256()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_37()) {
     jj_scanpos = xsp;
-    if (jj_3R_264()) return true;
+    if (jj_3R_266()) return true;
     }
     return false;
   }
@@ -5912,7 +5970,7 @@ private boolean jj_3R_47()
     return false;
   }
 
-  private boolean jj_3R_264()
+  private boolean jj_3R_266()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
@@ -5923,9 +5981,9 @@ private boolean jj_3R_71()
     if (jj_scan_token(LBRACKET)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_204()) jj_scanpos = xsp;
+    if (jj_3R_206()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_205()) jj_scanpos = xsp;
+    if (jj_3R_207()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
@@ -5940,17 +5998,17 @@ private boolean jj_3R_59()
   private boolean jj_3R_158()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_262()) return true;
+    if (jj_3R_264()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_263()) { jj_scanpos = xsp; break; }
+      if (jj_3R_265()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_204()
+  private boolean jj_3R_206()
  {
     if (jj_3R_51()) return true;
     return false;
@@ -5969,45 +6027,45 @@ private boolean jj_3_38()
     return false;
   }
 
-  private boolean jj_3R_205()
+  private boolean jj_3R_207()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_213()) {
+    if (jj_3R_215()) {
     jj_scanpos = xsp;
-    if (jj_3R_214()) return true;
+    if (jj_3R_216()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_213()
+  private boolean jj_3R_215()
  {
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_220()) jj_scanpos = xsp;
+    if (jj_3R_222()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_262()
+  private boolean jj_3R_264()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_38()) {
     jj_scanpos = xsp;
-    if (jj_3R_266()) return true;
+    if (jj_3R_268()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_214()
+  private boolean jj_3R_216()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_221()) jj_scanpos = xsp;
+    if (jj_3R_223()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_222()) jj_scanpos = xsp;
+    if (jj_3R_224()) jj_scanpos = xsp;
     return false;
   }
 
@@ -6022,29 +6080,29 @@ private boolean jj_3R_72()
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(73)) {
+    if (jj_scan_token(74)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(42)) return true;
+    if (jj_scan_token(43)) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_220()
+  private boolean jj_3R_222()
  {
     if (jj_3R_51()) return true;
     return false;
   }
 
-  private boolean jj_3R_222()
+  private boolean jj_3R_224()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_224()) jj_scanpos = xsp;
+    if (jj_3R_226()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_266()
+  private boolean jj_3R_268()
  {
     if (jj_3R_60()) return true;
     return false;
@@ -6052,18 +6110,18 @@ private boolean jj_3R_266()
 
   private boolean jj_3_16()
  {
-    if (jj_scan_token(153)) return true;
+    if (jj_scan_token(154)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_206()) jj_scanpos = xsp;
+    if (jj_3R_208()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_263()
+  private boolean jj_3R_265()
  {
     if (jj_scan_token(SEMICOLON)) return true;
-    if (jj_3R_262()) return true;
+    if (jj_3R_264()) return true;
     return false;
   }
 
@@ -6073,7 +6131,7 @@ private boolean jj_3_17()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_207()) jj_scanpos = xsp;
+    if (jj_3R_209()) jj_scanpos = xsp;
     return false;
   }
 
@@ -6085,51 +6143,47 @@ private boolean jj_3R_73()
     return false;
   }
 
-  private boolean jj_3_18()
+  private boolean jj_3_1()
  {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_3R_49()) return true;
+    if (jj_3R_36()) return true;
     return false;
   }
 
-  private boolean jj_3_1()
+  private boolean jj_3_18()
  {
-    if (jj_3R_36()) return true;
+    if (jj_scan_token(DOT)) return true;
+    if (jj_3R_49()) return true;
     return false;
   }
 
-  private boolean jj_3R_221()
+  private boolean jj_3R_223()
  {
     if (jj_3R_51()) return true;
     return false;
   }
 
-  private boolean jj_3R_206()
+  private boolean jj_3R_208()
  {
-    if (jj_3R_203()) return true;
+    if (jj_3R_205()) return true;
     return false;
   }
 
-  private boolean jj_3R_224()
+  private boolean jj_3R_226()
  {
     if (jj_3R_51()) return true;
     return false;
   }
 
-  private boolean jj_3R_207()
+  private boolean jj_3R_209()
  {
-    if (jj_3R_203()) return true;
+    if (jj_3R_205()) return true;
     return false;
   }
 
-  private boolean jj_3R_193()
+  private boolean jj_3R_195()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_195()) {
-    jj_scanpos = xsp;
-    if (jj_3R_196()) {
-    jj_scanpos = xsp;
     if (jj_3R_197()) {
     jj_scanpos = xsp;
     if (jj_3R_198()) {
@@ -6140,7 +6194,11 @@ private boolean jj_3R_193()
     jj_scanpos = xsp;
     if (jj_3R_201()) {
     jj_scanpos = xsp;
-    if (jj_3R_202()) return true;
+    if (jj_3R_202()) {
+    jj_scanpos = xsp;
+    if (jj_3R_203()) {
+    jj_scanpos = xsp;
+    if (jj_3R_204()) return true;
     }
     }
     }
@@ -6151,7 +6209,7 @@ private boolean jj_3R_193()
     return false;
   }
 
-  private boolean jj_3R_195()
+  private boolean jj_3R_197()
  {
     if (jj_scan_token(INTEGER_LITERAL)) return true;
     return false;
@@ -6171,28 +6229,28 @@ private boolean jj_3R_77()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(45)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(46)) {
     jj_scanpos = xsp;
     if (jj_scan_token(47)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(53)) {
+    if (jj_scan_token(48)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(54)) {
     jj_scanpos = xsp;
     if (jj_scan_token(28)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(41)) {
+    if (jj_scan_token(42)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(54)) {
+    if (jj_scan_token(55)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(60)) {
+    if (jj_scan_token(61)) {
     jj_scanpos = xsp;
     if (jj_scan_token(11)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(50)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(51)) {
     jj_scanpos = xsp;
+    if (jj_scan_token(52)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(21)) return true;
     }
     }
@@ -6208,18 +6266,12 @@ private boolean jj_3R_77()
     return false;
   }
 
-  private boolean jj_3R_196()
+  private boolean jj_3R_198()
  {
     if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_197()
- {
-    if (jj_scan_token(CHARACTER_LITERAL)) return true;
-    return false;
-  }
-
   private boolean jj_3R_95()
  {
     if (jj_3R_53()) return true;
@@ -6232,6 +6284,12 @@ private boolean jj_3R_95()
     return false;
   }
 
+  private boolean jj_3R_199()
+ {
+    if (jj_scan_token(CHARACTER_LITERAL)) return true;
+    return false;
+  }
+
   private boolean jj_3R_120()
  {
     Token xsp;
@@ -6244,38 +6302,32 @@ private boolean jj_3R_120()
     return false;
   }
 
-  private boolean jj_3R_198()
- {
-    if (jj_scan_token(STRING_LITERAL)) return true;
-    return false;
-  }
-
   private boolean jj_3R_141()
  {
     if (jj_scan_token(CLASS)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_234()) jj_scanpos = xsp;
+    if (jj_3R_236()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_235()) jj_scanpos = xsp;
+    if (jj_3R_237()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_234()
+  private boolean jj_3R_200()
  {
-    if (jj_scan_token(EXTENDS)) return true;
-    if (jj_3R_38()) return true;
+    if (jj_scan_token(STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_199()
+  private boolean jj_3R_236()
  {
-    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
+    if (jj_scan_token(EXTENDS)) return true;
+    if (jj_3R_38()) return true;
     return false;
   }
 
-  private boolean jj_3R_235()
+  private boolean jj_3R_237()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
     if (jj_3R_81()) return true;
@@ -6288,7 +6340,7 @@ private boolean jj_3R_142()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_236()) jj_scanpos = xsp;
+    if (jj_3R_238()) jj_scanpos = xsp;
     return false;
   }
 
@@ -6298,102 +6350,108 @@ private boolean jj_3R_121()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_229()) jj_scanpos = xsp;
-    if (jj_3R_230()) return true;
+    if (jj_3R_231()) jj_scanpos = xsp;
+    if (jj_3R_232()) return true;
     return false;
   }
 
-  private boolean jj_3R_236()
+  private boolean jj_3R_238()
  {
     if (jj_scan_token(EXTENDS)) return true;
     if (jj_3R_81()) return true;
     return false;
   }
 
-  private boolean jj_3R_229()
+  private boolean jj_3R_201()
  {
-    if (jj_scan_token(IMPLEMENTS)) return true;
-    if (jj_3R_81()) return true;
+    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_200()
+  private boolean jj_3R_231()
  {
-    if (jj_3R_208()) return true;
+    if (jj_scan_token(IMPLEMENTS)) return true;
+    if (jj_3R_81()) return true;
     return false;
   }
 
-  private boolean jj_3R_201()
+  private boolean jj_3R_202()
  {
-    if (jj_scan_token(43)) return true;
+    if (jj_3R_210()) return true;
     return false;
   }
 
-  private boolean jj_3R_202()
+  private boolean jj_3R_203()
  {
-    if (jj_scan_token(59)) return true;
+    if (jj_scan_token(44)) return true;
     return false;
   }
 
-  private boolean jj_3R_249()
+  private boolean jj_3R_251()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_255()) jj_scanpos = xsp;
+    if (jj_3R_257()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_256()) jj_scanpos = xsp;
+    if (jj_3R_258()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_208()
+  private boolean jj_3R_204()
+ {
+    if (jj_scan_token(60)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_210()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_215()) {
+    if (jj_3R_217()) {
     jj_scanpos = xsp;
-    if (jj_3R_216()) return true;
+    if (jj_3R_218()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_215()
+  private boolean jj_3R_217()
  {
     if (jj_scan_token(TRUE)) return true;
     return false;
   }
 
-  private boolean jj_3R_216()
+  private boolean jj_3R_218()
  {
     if (jj_scan_token(FALSE)) return true;
     return false;
   }
 
-  private boolean jj_3R_230()
+  private boolean jj_3R_232()
  {
     if (jj_scan_token(LBRACE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_237()) jj_scanpos = xsp;
+    if (jj_3R_239()) jj_scanpos = xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_238()) { jj_scanpos = xsp; break; }
+      if (jj_3R_240()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_239()) jj_scanpos = xsp;
+    if (jj_3R_241()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_255()
+  private boolean jj_3R_257()
  {
-    if (jj_3R_203()) return true;
+    if (jj_3R_205()) return true;
     return false;
   }
 
-  private boolean jj_3R_237()
+  private boolean jj_3R_239()
  {
-    if (jj_3R_249()) return true;
+    if (jj_3R_251()) return true;
     return false;
   }
 
@@ -6408,11 +6466,11 @@ private boolean jj_3R_96()
     }
     if (jj_3R_55()) return true;
     xsp = jj_scanpos;
-    if (jj_3R_225()) jj_scanpos = xsp;
+    if (jj_3R_227()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_226()) {
+    if (jj_3R_228()) {
     jj_scanpos = xsp;
-    if (jj_3R_227()) return true;
+    if (jj_3R_229()) return true;
     }
     return false;
   }
@@ -6423,16 +6481,6 @@ private boolean jj_3R_122()
     return false;
   }
 
-  private boolean jj_3R_203()
- {
-    if (jj_scan_token(LPAREN)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_212()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
-    return false;
-  }
-
   private boolean jj_3R_123()
  {
     if (jj_3R_54()) return true;
@@ -6440,44 +6488,30 @@ private boolean jj_3R_123()
     return false;
   }
 
-  private boolean jj_3R_212()
- {
-    if (jj_3R_219()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_219()
+  private boolean jj_3R_205()
  {
-    if (jj_3R_51()) return true;
+    if (jj_scan_token(LPAREN)) return true;
     Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_223()) { jj_scanpos = xsp; break; }
-    }
+    xsp = jj_scanpos;
+    if (jj_3R_214()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_256()
+  private boolean jj_3R_258()
  {
     if (jj_3R_50()) return true;
     return false;
   }
 
-  private boolean jj_3R_225()
+  private boolean jj_3R_227()
  {
     if (jj_scan_token(THROWS)) return true;
     if (jj_3R_81()) return true;
     return false;
   }
 
-  private boolean jj_3R_223()
- {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_51()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_226()
+  private boolean jj_3R_228()
  {
     if (jj_3R_50()) return true;
     return false;
@@ -6490,28 +6524,19 @@ private boolean jj_3_3()
     return false;
   }
 
-  private boolean jj_3R_49()
+  private boolean jj_3R_214()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_74()) {
-    jj_scanpos = xsp;
-    if (jj_3R_75()) return true;
-    }
+    if (jj_3R_221()) return true;
     return false;
   }
 
-  private boolean jj_3R_74()
+  private boolean jj_3R_221()
  {
-    if (jj_scan_token(NEW)) return true;
+    if (jj_3R_51()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_209()) {
-    jj_scanpos = xsp;
-    if (jj_3R_210()) {
-    jj_scanpos = xsp;
-    if (jj_3R_211()) return true;
-    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_225()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
@@ -6523,10 +6548,17 @@ private boolean jj_3R_99()
     return false;
   }
 
-  private boolean jj_3R_238()
+  private boolean jj_3R_240()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_251()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_225()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_249()) return true;
+    if (jj_3R_51()) return true;
     return false;
   }
 
@@ -6554,28 +6586,35 @@ private boolean jj_3R_98()
     return false;
   }
 
-  private boolean jj_3R_209()
- {
-    if (jj_3R_100()) return true;
-    if (jj_3R_102()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_227()
+  private boolean jj_3R_49()
  {
-    if (jj_3R_231()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_74()) {
+    jj_scanpos = xsp;
+    if (jj_3R_75()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_210()
+  private boolean jj_3R_74()
  {
-    if (jj_3R_38()) return true;
+    if (jj_scan_token(NEW)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_217()) {
+    if (jj_3R_211()) {
     jj_scanpos = xsp;
-    if (jj_3R_218()) return true;
+    if (jj_3R_212()) {
+    jj_scanpos = xsp;
+    if (jj_3R_213()) return true;
     }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_229()
+ {
+    if (jj_3R_233()) return true;
     return false;
   }
 
@@ -6587,28 +6626,26 @@ private boolean jj_3R_124()
     return false;
   }
 
-  private boolean jj_3R_217()
+  private boolean jj_3R_211()
  {
+    if (jj_3R_100()) return true;
     if (jj_3R_102()) return true;
     return false;
   }
 
-  private boolean jj_3R_218()
+  private boolean jj_3R_212()
  {
-    if (jj_3R_203()) return true;
+    if (jj_3R_38()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_19()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_75()
- {
-    if (jj_3R_102()) return true;
+    if (jj_3R_219()) {
+    jj_scanpos = xsp;
+    if (jj_3R_220()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_211()
+  private boolean jj_3R_219()
  {
     if (jj_3R_102()) return true;
     return false;
@@ -6620,32 +6657,24 @@ private boolean jj_3R_37()
     return false;
   }
 
-  private boolean jj_3R_102()
+  private boolean jj_3R_220()
  {
+    if (jj_3R_205()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_22()) {
-    jj_scanpos = xsp;
-    if (jj_3R_135()) {
-    jj_scanpos = xsp;
-    if (jj_3R_136()) return true;
-    }
-    }
+    if (jj_3_19()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3_22()
+  private boolean jj_3R_75()
  {
-    Token xsp;
-    if (jj_3_20()) return true;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_20()) { jj_scanpos = xsp; break; }
-    }
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_21()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_102()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_213()
+ {
+    if (jj_3R_102()) return true;
     return false;
   }
 
@@ -6655,39 +6684,53 @@ private boolean jj_3R_60()
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_232()) { jj_scanpos = xsp; break; }
+      if (jj_3R_234()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_233()) jj_scanpos = xsp;
+    if (jj_3R_235()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3_20()
+  private boolean jj_3R_234()
  {
     if (jj_scan_token(LBRACKET)) return true;
-    if (jj_3R_51()) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_232()
+  private boolean jj_3R_102()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_22()) {
+    jj_scanpos = xsp;
+    if (jj_3R_135()) {
+    jj_scanpos = xsp;
+    if (jj_3R_136()) return true;
+    }
+    }
     return false;
   }
 
-  private boolean jj_3_21()
+  private boolean jj_3R_235()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(ASSIGN)) return true;
+    if (jj_3R_42()) return true;
     return false;
   }
 
-  private boolean jj_3R_233()
+  private boolean jj_3_22()
  {
-    if (jj_scan_token(ASSIGN)) return true;
-    if (jj_3R_42()) return true;
+    Token xsp;
+    if (jj_3_20()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_20()) { jj_scanpos = xsp; break; }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_21()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
@@ -6698,19 +6741,7 @@ private boolean jj_3R_39()
     return false;
   }
 
-  private boolean jj_3R_135()
- {
-    Token xsp;
-    if (jj_3R_144()) return true;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_144()) { jj_scanpos = xsp; break; }
-    }
-    if (jj_3R_41()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_239()
+  private boolean jj_3R_241()
  {
     if (jj_scan_token(SEMICOLON)) return true;
     Token xsp;
@@ -6727,12 +6758,6 @@ private boolean jj_3_5()
     return false;
   }
 
-  private boolean jj_3_19()
- {
-    if (jj_3R_50()) return true;
-    return false;
-  }
-
   private boolean jj_3R_42()
  {
     Token xsp;
@@ -6744,16 +6769,18 @@ private boolean jj_3R_42()
     return false;
   }
 
-  private boolean jj_3R_144()
+  private boolean jj_3_20()
  {
     if (jj_scan_token(LBRACKET)) return true;
+    if (jj_3R_51()) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_136()
+  private boolean jj_3_21()
  {
-    if (jj_3R_41()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
@@ -6763,12 +6790,43 @@ private boolean jj_3R_68()
     return false;
   }
 
+  private boolean jj_3R_135()
+ {
+    Token xsp;
+    if (jj_3R_144()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_144()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_3R_41()) return true;
+    return false;
+  }
+
   private boolean jj_3_2()
  {
     if (jj_3R_36()) return true;
     return false;
   }
 
+  private boolean jj_3_19()
+ {
+    if (jj_3R_50()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_144()
+ {
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_136()
+ {
+    if (jj_3R_41()) return true;
+    return false;
+  }
+
   private boolean jj_3R_41()
  {
     if (jj_scan_token(LBRACE)) return true;
@@ -6776,17 +6834,38 @@ private boolean jj_3R_41()
     xsp = jj_scanpos;
     if (jj_3R_67()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(83)) jj_scanpos = xsp;
+    if (jj_scan_token(84)) jj_scanpos = xsp;
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
+  private boolean jj_3R_67()
+ {
+    if (jj_3R_42()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_6()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
   private boolean jj_3_23()
  {
     if (jj_3R_52()) return true;
     return false;
   }
 
+  private boolean jj_3R_55()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_80()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
   private boolean jj_3R_57()
  {
     Token xsp;
@@ -6795,7 +6874,7 @@ private boolean jj_3R_57()
     jj_scanpos = xsp;
     if (jj_3_24()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(82)) {
+    if (jj_scan_token(83)) {
     jj_scanpos = xsp;
     if (jj_3R_82()) {
     jj_scanpos = xsp;
@@ -6843,33 +6922,6 @@ private boolean jj_3R_57()
     return false;
   }
 
-  private boolean jj_3_24()
- {
-    if (jj_3R_50()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_67()
- {
-    if (jj_3R_42()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_6()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_55()
- {
-    if (jj_scan_token(LPAREN)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_80()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
-    return false;
-  }
-
   private boolean jj_3_6()
  {
     if (jj_scan_token(COMMA)) return true;
@@ -6877,16 +6929,9 @@ private boolean jj_3_6()
     return false;
   }
 
-  private boolean jj_3R_82()
- {
-    if (jj_3R_107()) return true;
-    if (jj_3R_40()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_83()
+  private boolean jj_3_24()
  {
-    if (jj_3R_108()) return true;
+    if (jj_3R_50()) return true;
     return false;
   }
 
@@ -6916,12 +6961,6 @@ private boolean jj_3R_104()
     return false;
   }
 
-  private boolean jj_3R_84()
- {
-    if (jj_3R_109()) return true;
-    return false;
-  }
-
   private boolean jj_3_7()
  {
     Token xsp;
@@ -6934,15 +6973,22 @@ private boolean jj_3_7()
     return false;
   }
 
-  private boolean jj_3R_85()
+  private boolean jj_3R_82()
  {
-    if (jj_3R_110()) return true;
+    if (jj_3R_107()) return true;
+    if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_86()
+  private boolean jj_3R_83()
  {
-    if (jj_3R_111()) return true;
+    if (jj_3R_108()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_84()
+ {
+    if (jj_3R_109()) return true;
     return false;
   }
 
@@ -6952,15 +6998,15 @@ private boolean jj_3R_138()
     return false;
   }
 
-  private boolean jj_3R_87()
+  private boolean jj_3R_85()
  {
-    if (jj_3R_112()) return true;
+    if (jj_3R_110()) return true;
     return false;
   }
 
-  private boolean jj_3R_88()
+  private boolean jj_3R_86()
  {
-    if (jj_3R_113()) return true;
+    if (jj_3R_111()) return true;
     return false;
   }
 
@@ -6977,27 +7023,27 @@ private boolean jj_3R_45()
     return false;
   }
 
-  private boolean jj_3R_89()
+  private boolean jj_3R_87()
  {
-    if (jj_3R_114()) return true;
+    if (jj_3R_112()) return true;
     return false;
   }
 
-  private boolean jj_3R_90()
+  private boolean jj_3R_88()
  {
-    if (jj_3R_115()) return true;
+    if (jj_3R_113()) return true;
     return false;
   }
 
-  private boolean jj_3R_91()
+  private boolean jj_3R_43()
  {
-    if (jj_3R_116()) return true;
+    if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_43()
+  private boolean jj_3R_89()
  {
-    if (jj_scan_token(FINAL)) return true;
+    if (jj_3R_114()) return true;
     return false;
   }
 
@@ -7016,28 +7062,28 @@ private boolean jj_3R_44()
     return false;
   }
 
-  private boolean jj_3R_92()
+  private boolean jj_3R_90()
  {
-    if (jj_3R_117()) return true;
+    if (jj_3R_115()) return true;
     return false;
   }
 
-  private boolean jj_3R_93()
+  private boolean jj_3R_105()
  {
-    if (jj_3R_118()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_105()
+  private boolean jj_3R_91()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_104()) return true;
+    if (jj_3R_116()) return true;
     return false;
   }
 
-  private boolean jj_3R_94()
+  private boolean jj_3R_92()
  {
-    if (jj_3R_119()) return true;
+    if (jj_3R_117()) return true;
     return false;
   }
 
@@ -7047,6 +7093,18 @@ private boolean jj_3R_69()
     return false;
   }
 
+  private boolean jj_3R_93()
+ {
+    if (jj_3R_118()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_94()
+ {
+    if (jj_3R_119()) return true;
+    return false;
+  }
+
   private boolean jj_3_8()
  {
     if (jj_scan_token(LBRACKET)) return true;
@@ -7085,20 +7143,6 @@ private boolean jj_3R_79()
     return false;
   }
 
-  private boolean jj_3R_50()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(50)) jj_scanpos = xsp;
-    if (jj_scan_token(LBRACE)) return true;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_25()) { jj_scanpos = xsp; break; }
-    }
-    if (jj_scan_token(RBRACE)) return true;
-    return false;
-  }
-
   private boolean jj_3R_100()
  {
     Token xsp;
@@ -7158,6 +7202,20 @@ private boolean jj_3R_128()
     return false;
   }
 
+  private boolean jj_3R_50()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(51)) jj_scanpos = xsp;
+    if (jj_scan_token(LBRACE)) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_25()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
   private boolean jj_3R_129()
  {
     if (jj_scan_token(INT)) return true;
@@ -7214,12 +7272,6 @@ private boolean jj_3R_61()
     return false;
   }
 
-  private boolean jj_3R_62()
- {
-    if (jj_3R_96()) return true;
-    return false;
-  }
-
   private boolean jj_3R_38()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
@@ -7231,6 +7283,19 @@ private boolean jj_3R_38()
     return false;
   }
 
+  private boolean jj_3R_62()
+ {
+    if (jj_3R_96()) return true;
+    return false;
+  }
+
+  private boolean jj_3_9()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    return false;
+  }
+
   private boolean jj_3R_63()
  {
     if (jj_3R_96()) return true;
@@ -7244,7 +7309,7 @@ private boolean jj_3_26()
     xsp = jj_scanpos;
     if (jj_scan_token(14)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(39)) {
+    if (jj_scan_token(40)) {
     jj_scanpos = xsp;
     if (jj_scan_token(25)) return true;
     }
@@ -7252,17 +7317,21 @@ private boolean jj_3_26()
     return false;
   }
 
-  private boolean jj_3_9()
+  private boolean jj_3R_64()
  {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_97()) return true;
+    if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_64()
+  private boolean jj_3R_81()
  {
-    if (jj_3R_97()) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_38()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_106()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
@@ -7287,17 +7356,6 @@ private boolean jj_3_30()
     return false;
   }
 
-  private boolean jj_3R_81()
- {
-    if (jj_3R_38()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_106()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
   private boolean jj_3R_65()
  {
     if (jj_3R_98()) return true;
@@ -7346,20 +7404,6 @@ private boolean jj_3R_101()
     return false;
   }
 
-  private boolean jj_3R_231()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(82)) {
-    jj_scanpos = xsp;
-    jj_lookingAhead = true;
-    jj_semLA = isImplicitMethodTerminator();
-    jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_240()) return true;
-    }
-    return false;
-  }
-
   private boolean jj_3R_106()
  {
     if (jj_scan_token(COMMA)) return true;
@@ -7367,58 +7411,53 @@ private boolean jj_3R_106()
     return false;
   }
 
-  private boolean jj_3R_240()
- {
-    return false;
-  }
-
   private boolean jj_3R_134()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(85)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(126)) {
+    if (jj_scan_token(86)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(136)) {
+    if (jj_scan_token(127)) {
     jj_scanpos = xsp;
     if (jj_scan_token(137)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(127)) {
+    if (jj_scan_token(138)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(134)) {
+    if (jj_scan_token(128)) {
     jj_scanpos = xsp;
     if (jj_scan_token(135)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(124)) {
+    if (jj_scan_token(136)) {
     jj_scanpos = xsp;
     if (jj_scan_token(125)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(128)) {
+    if (jj_scan_token(126)) {
     jj_scanpos = xsp;
     if (jj_scan_token(129)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(132)) {
+    if (jj_scan_token(130)) {
     jj_scanpos = xsp;
     if (jj_scan_token(133)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(130)) {
+    if (jj_scan_token(134)) {
     jj_scanpos = xsp;
     if (jj_scan_token(131)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(138)) {
+    if (jj_scan_token(132)) {
     jj_scanpos = xsp;
     if (jj_scan_token(139)) {
     jj_scanpos = xsp;
     if (jj_scan_token(140)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(146)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(141)) {
     jj_scanpos = xsp;
+    if (jj_scan_token(147)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(142)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(143)) return true;
+    if (jj_scan_token(143)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(144)) return true;
     }
     }
     }
@@ -7443,18 +7482,30 @@ private boolean jj_3R_134()
     return false;
   }
 
-  private boolean jj_3R_40()
+  private boolean jj_3R_233()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(82)) jj_scanpos = xsp;
+    if (jj_scan_token(83)) {
+    jj_scanpos = xsp;
+    jj_lookingAhead = true;
+    jj_semLA = isImplicitMethodTerminator();
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_242()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_56()
+  private boolean jj_3R_242()
  {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_81()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_40()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(83)) jj_scanpos = xsp;
     return false;
   }
 
@@ -7467,9 +7518,10 @@ private boolean jj_3R_76()
     return false;
   }
 
-  private boolean jj_3R_107()
+  private boolean jj_3R_56()
  {
-    if (jj_3R_51()) return true;
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_81()) return true;
     return false;
   }
 
@@ -7484,15 +7536,21 @@ private boolean jj_3R_103()
     return false;
   }
 
+  private boolean jj_3R_107()
+ {
+    if (jj_3R_51()) return true;
+    return false;
+  }
+
   private boolean jj_3R_143()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(147)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(148)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(145)) return true;
+    if (jj_scan_token(149)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(146)) return true;
     }
     }
     if (jj_3R_137()) return true;
@@ -7514,30 +7572,14 @@ private boolean jj_3R_146()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(98)) {
+    if (jj_scan_token(99)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(99)) return true;
+    if (jj_scan_token(100)) return true;
     }
     if (jj_3R_145()) return true;
     return false;
   }
 
-  private boolean jj_3R_108()
- {
-    if (jj_scan_token(SWITCH)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) 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_241()) { jj_scanpos = xsp; break; }
-    }
-    if (jj_scan_token(RBRACE)) return true;
-    return false;
-  }
-
   private boolean jj_3R_145()
  {
     if (jj_3R_147()) return true;
@@ -7553,70 +7595,86 @@ private boolean jj_3R_148()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(100)) {
+    if (jj_scan_token(101)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(101)) return true;
+    if (jj_scan_token(102)) return true;
     }
     if (jj_3R_147()) return true;
     return false;
   }
 
-  private boolean jj_3R_241()
+  private boolean jj_3R_108()
  {
-    if (jj_3R_250()) return true;
+    if (jj_scan_token(SWITCH)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_51()) 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_3_31()) { jj_scanpos = xsp; break; }
+      if (jj_3R_243()) { jj_scanpos = xsp; break; }
     }
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_250()
+  private boolean jj_3R_147()
  {
+    if (jj_3R_149()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_257()) {
-    jj_scanpos = xsp;
-    if (jj_3R_258()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_150()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_257()
- {
-    if (jj_scan_token(CASE)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(COLON)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_147()
+  private boolean jj_3R_243()
  {
-    if (jj_3R_149()) return true;
+    if (jj_3R_252()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_150()) { jj_scanpos = xsp; break; }
+      if (jj_3_31()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_258()
+  private boolean jj_3R_150()
  {
-    if (jj_scan_token(154)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(111)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(112)) return true;
+    }
+    if (jj_3R_149()) return true;
     return false;
   }
 
-  private boolean jj_3R_150()
+  private boolean jj_3R_252()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(110)) {
+    if (jj_3R_259()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(111)) return true;
+    if (jj_3R_260()) return true;
     }
-    if (jj_3R_149()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_259()
+ {
+    if (jj_scan_token(CASE)) return true;
+    if (jj_3R_51()) return true;
+    if (jj_scan_token(COLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_260()
+ {
+    if (jj_scan_token(155)) return true;
     return false;
   }
 
@@ -7640,6 +7698,18 @@ private boolean jj_3R_149()
     return false;
   }
 
+  private boolean jj_3R_156()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(113)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(114)) return true;
+    }
+    if (jj_3R_151()) return true;
+    return false;
+  }
+
   private boolean jj_3_31()
  {
     if (jj_3R_36()) return true;
@@ -7654,24 +7724,35 @@ private boolean jj_3R_109()
     if (jj_scan_token(RPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_242()) {
+    if (jj_3R_244()) {
     jj_scanpos = xsp;
     if (jj_3_32()) return true;
     }
     xsp = jj_scanpos;
-    if (jj_3R_243()) jj_scanpos = xsp;
+    if (jj_3R_245()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_156()
+  private boolean jj_3R_151()
+ {
+    if (jj_3R_157()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_159()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_159()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(112)) {
+    if (jj_scan_token(109)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(113)) return true;
+    if (jj_scan_token(110)) return true;
     }
-    if (jj_3R_151()) return true;
+    if (jj_3R_157()) return true;
     return false;
   }
 
@@ -7685,37 +7766,26 @@ private boolean jj_3R_110()
     return false;
   }
 
-  private boolean jj_3R_151()
+  private boolean jj_3R_157()
  {
-    if (jj_3R_157()) return true;
+    if (jj_3R_160()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_159()) { jj_scanpos = xsp; break; }
+      if (jj_3R_161()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_159()
+  private boolean jj_3R_161()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(108)) {
+    if (jj_scan_token(93)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(109)) return true;
+    if (jj_scan_token(98)) return true;
     }
-    if (jj_3R_157()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_157()
- {
     if (jj_3R_160()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_161()) { jj_scanpos = xsp; break; }
-    }
     return false;
   }
 
@@ -7731,15 +7801,12 @@ private boolean jj_3R_111()
     return false;
   }
 
-  private boolean jj_3R_161()
+  private boolean jj_3R_160()
  {
+    if (jj_3R_162()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(92)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(97)) return true;
-    }
-    if (jj_3R_160()) return true;
+    if (jj_3R_163()) jj_scanpos = xsp;
     return false;
   }
 
@@ -7749,28 +7816,30 @@ private boolean jj_3R_112()
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_244()) jj_scanpos = xsp;
+    if (jj_3R_246()) jj_scanpos = xsp;
     if (jj_scan_token(SEMICOLON)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_245()) jj_scanpos = xsp;
+    if (jj_3R_247()) jj_scanpos = xsp;
     if (jj_scan_token(SEMICOLON)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_246()) jj_scanpos = xsp;
+    if (jj_3R_248()) jj_scanpos = xsp;
     if (jj_scan_token(RPAREN)) return true;
     if (jj_3R_57()) return true;
     return false;
   }
 
-  private boolean jj_3R_160()
+  private boolean jj_3R_163()
  {
-    if (jj_3R_162()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_163()) jj_scanpos = xsp;
+    if (jj_3R_166()) {
+    jj_scanpos = xsp;
+    if (jj_3R_167()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_163()
+  private boolean jj_3R_166()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7782,13 +7851,20 @@ private boolean jj_3R_163()
     return false;
   }
 
-  private boolean jj_3R_242()
+  private boolean jj_3R_167()
+ {
+    if (jj_scan_token(AS)) return true;
+    if (jj_3R_44()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_244()
  {
     if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_245()
+  private boolean jj_3R_247()
  {
     if (jj_3R_51()) return true;
     return false;
@@ -7805,9 +7881,9 @@ private boolean jj_3R_162()
     return false;
   }
 
-  private boolean jj_3R_246()
+  private boolean jj_3R_248()
  {
-    if (jj_3R_252()) return true;
+    if (jj_3R_254()) return true;
     return false;
   }
 
@@ -7815,21 +7891,21 @@ private boolean jj_3R_165()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(88)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(89)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(86)) {
+    if (jj_scan_token(90)) {
     jj_scanpos = xsp;
     if (jj_scan_token(87)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(93)) {
+    if (jj_scan_token(88)) {
     jj_scanpos = xsp;
     if (jj_scan_token(94)) {
     jj_scanpos = xsp;
     if (jj_scan_token(95)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(96)) return true;
+    if (jj_scan_token(96)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(97)) return true;
     }
     }
     }
@@ -7841,9 +7917,9 @@ private boolean jj_3R_165()
     return false;
   }
 
-  private boolean jj_3R_244()
+  private boolean jj_3R_246()
  {
-    if (jj_3R_251()) return true;
+    if (jj_3R_253()) return true;
     return false;
   }
 
@@ -7876,7 +7952,7 @@ private boolean jj_3R_140()
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_253()) jj_scanpos = xsp;
+    if (jj_3R_255()) jj_scanpos = xsp;
     if (jj_3R_44()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_scan_token(COLON)) return true;
@@ -7888,21 +7964,19 @@ private boolean jj_3R_140()
 
   private boolean jj_3R_164()
  {
-    if (jj_3R_166()) return true;
+    if (jj_3R_168()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_167()) { jj_scanpos = xsp; break; }
+      if (jj_3R_169()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_167()
+  private boolean jj_3R_169()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(118)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(119)) {
     jj_scanpos = xsp;
     if (jj_scan_token(120)) {
@@ -7911,56 +7985,35 @@ private boolean jj_3R_167()
     jj_scanpos = xsp;
     if (jj_scan_token(122)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(123)) return true;
+    if (jj_scan_token(123)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(124)) return true;
     }
     }
     }
     }
     }
-    if (jj_3R_166()) return true;
+    if (jj_3R_168()) return true;
     return false;
   }
 
-  private boolean jj_3R_251()
+  private boolean jj_3R_253()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_259()) {
+    if (jj_3R_261()) {
     jj_scanpos = xsp;
-    if (jj_3R_260()) return true;
+    if (jj_3R_262()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_259()
+  private boolean jj_3R_261()
  {
     if (jj_3R_97()) return true;
     return false;
   }
 
-  private boolean jj_3R_260()
- {
-    if (jj_3R_261()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_166()
- {
-    if (jj_3R_168()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_169()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_253()
- {
-    if (jj_scan_token(FINAL)) return true;
-    return false;
-  }
-
   /** Generated Token Manager. */
   public ParserTokenManager token_source;
   JavaCharStream jj_input_stream;
@@ -7975,7 +8028,7 @@ private boolean jj_3R_253()
   private boolean jj_lookingAhead = false;
   private boolean jj_semLA;
   private int jj_gen;
-  final private int[] jj_la1 = new int[120];
+  final private int[] jj_la1 = new int[121];
   static private int[] jj_la1_0;
   static private int[] jj_la1_1;
   static private int[] jj_la1_2;
@@ -7989,19 +8042,19 @@ private boolean jj_3R_253()
 	   jj_la1_init_4();
 	}
 	private static void jj_la1_init_0() {
-	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
+	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_1() {
-	   jj_la1_1 = new int[] {0x0,0x106ce200,0x106ce200,0x0,0x4,0x0,0x80,0x4,0x80,0x0,0x40000,0x0,0x0,0x0,0x8020140,0x1000000,0x40000,0x40000,0x0,0x8,0x0,0x0,0x4a020d40,0x4a020d40,0x0,0x0,0x20140,0x0,0x0,0x0,0x20140,0x8020140,0x20140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4a020d40,0x0,0x4a060d40,0x4a000c00,0x0,0x4a020d40,0x4a020d40,0x4a020d40,0x4a020d40,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x4a000800,0x2000000,0x4a020d40,0x0,0x0,0x20140,0x400,0x0,0x0,0x6a120d42,0x4a10000,0x40000,0x1008,0x0,0x0,0x0,0x0,0x0,0x0,0x5a6eef40,0x4a020d40,0x4a020d40,0x0,0x0,0x4a020d40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_1 = new int[] {0x0,0x20d9c400,0x20d9c400,0x0,0x4,0x0,0x100,0x4,0x100,0x0,0x80000,0x0,0x0,0x0,0x10040280,0x2000000,0x80000,0x80000,0x0,0x8,0x0,0x0,0x94041a80,0x94041a80,0x0,0x0,0x40280,0x0,0x0,0x0,0x40280,0x10040280,0x40280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x70,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x94041a80,0x0,0x940c1a80,0x94001800,0x0,0x94041a80,0x94041a80,0x94041a80,0x94041a80,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x94001000,0x4000000,0x94041a80,0x0,0x0,0x40280,0x800,0x0,0x0,0xd4241a82,0x9420000,0x80000,0x2008,0x0,0x0,0x0,0x0,0x0,0x0,0xb4ddde80,0x94041a80,0x94041a80,0x0,0x0,0x94041a80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_2() {
-	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x4000,0x200,0x80000,0x40000,0x200,0x0,0x4000,0x0,0x100000,0x0,0x10000,0x200000,0xc0153c8,0xc0153c8,0x80000,0x80000,0x200,0x0,0x0,0x200,0x200,0x200,0x0,0x80000,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0xe3c00000,0xe3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0x0,0x0,0x0,0xc000000,0x153c8,0x1200,0xc0153c8,0x151c8,0x200,0xc0153c8,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0x0,0x200,0x1000,0x1000,0x10000,0x4000,0x1c8,0x0,0xc0153c8,0x80000,0x15000,0x14200,0x14000,0x10000,0x14000,0xc0553c8,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x40000,0x0,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0xc0153c8,0x80000,0x80000,0x1000,0x0,0x0,0x0,0x0,0x200,0x40000,0x200,};
+	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x8000,0x400,0x100000,0x80000,0x400,0x0,0x8000,0x0,0x200000,0x0,0x20000,0x400000,0x1802a790,0x1802a790,0x100000,0x100000,0x400,0x0,0x0,0x400,0x400,0x400,0x0,0x100000,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x0,0x0,0xc7800000,0xc7800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18000000,0x0,0x0,0x0,0x18000000,0x2a790,0x2400,0x1802a790,0x2a390,0x400,0x1802a790,0x1802a790,0x1802a790,0x1802a790,0x0,0x0,0x0,0x400,0x2000,0x2000,0x20000,0x8000,0x390,0x0,0x1802a790,0x100000,0x2a000,0x28400,0x28000,0x20000,0x28000,0x180aa790,0x0,0x0,0x0,0x80000,0x80000,0x0,0x0,0x80000,0x0,0x1802a790,0x1802a790,0x1802a790,0x0,0x0,0x1802a790,0x100000,0x100000,0x2000,0x0,0x0,0x0,0x0,0x400,0x80000,0x400,};
 	}
 	private static void jj_la1_init_3() {
-	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0xf0000000,0x0,0x0,0x0,0xc,0xc,0x30,0x30,0xc000,0xc000,0x30000,0x30000,0x3000,0x3000,0x2,0x2,0x0,0x0,0x1,0x1,0xfc00000,0xfc00000,0x300,0x300,0xc0c00,0xc0c00,0x300000,0x300000,0x300,0xc0,0xc0,0xc0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,};
+	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0000000,0xe0000000,0x0,0x0,0x0,0x18,0x18,0x60,0x60,0x18000,0x18000,0x60000,0x60000,0x6000,0x6000,0x4,0x4,0x0,0x0,0x0,0x3,0x3,0x1f800000,0x1f800000,0x600,0x600,0x181800,0x181800,0x600000,0x600000,0x600,0x180,0x180,0x180,0x780,0x0,0x0,0x780,0x0,0x0,0x780,0x780,0x780,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x780,0x780,0x0,0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_4() {
-	   jj_la1_4 = new int[] {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,0x1000000,0x0,0x0,0x0,0x0,0x0,0x4ffff,0x4ffff,0x200000,0x1a0000,0x1a0000,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,0x400000,0xc00000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_4 = new int[] {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,0x2000000,0x0,0x0,0x0,0x0,0x0,0x9ffff,0x9ffff,0x400000,0x340000,0x340000,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,0x800000,0x1800000,0x1800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
   private final JJCalls[] jj_2_rtns = new JJCalls[38];
   private boolean jj_rescan = false;
@@ -8018,7 +8071,7 @@ public Parser(final java.io.InputStream stream, final java.nio.charset.Charset e
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8033,7 +8086,7 @@ public void ReInit(final java.io.InputStream stream, final java.nio.charset.Char
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8047,7 +8100,7 @@ public Parser(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 120; i++)
+   for (int i = 0; i < 121; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8071,7 +8124,7 @@ public void ReInit(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 120; i++)
+   for (int i = 0; i < 121; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8086,7 +8139,7 @@ public Parser(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8099,7 +8152,7 @@ public void ReInit(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 120; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8244,12 +8297,12 @@ private void jj_add_error_token(int kind, int pos) {
    */
   public ParseException generateParseException() {
     jj_expentries.clear();
-    boolean[] la1tokens = new boolean[155];
+    boolean[] la1tokens = new boolean[156];
     if (jj_kind >= 0) {
       la1tokens[jj_kind] = true;
       jj_kind = -1;
     }
-    for (int i = 0; i < 120; i++) {
+    for (int i = 0; i < 121; i++) {
       if (jj_la1[i] == jj_gen) {
         for (int j = 0; j < 32; j++) {
           if ((jj_la1_0[i] & (1<<j)) != 0) {
@@ -8270,7 +8323,7 @@ public ParseException generateParseException() {
         }
       }
     }
-    for (int i = 0; i < 155; i++) {
+    for (int i = 0; i < 156; i++) {
       if (la1tokens[i]) {
         jj_expentry = new int[1];
         jj_expentry[0] = i;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
index 36104ee..c88706a 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
@@ -100,235 +100,237 @@ public interface ParserConstants {
   /** RegularExpression Id. */
   int IS = 37;
   /** RegularExpression Id. */
-  int INT = 38;
+  int AS = 38;
   /** RegularExpression Id. */
-  int INTERFACE = 39;
+  int INT = 39;
   /** RegularExpression Id. */
-  int LONG = 40;
+  int INTERFACE = 40;
   /** RegularExpression Id. */
-  int NATIVE = 41;
+  int LONG = 41;
   /** RegularExpression Id. */
-  int NEW = 42;
+  int NATIVE = 42;
   /** RegularExpression Id. */
-  int NULL = 43;
+  int NEW = 43;
   /** RegularExpression Id. */
-  int PACKAGE = 44;
+  int NULL = 44;
   /** RegularExpression Id. */
-  int PRIVATE = 45;
+  int PACKAGE = 45;
   /** RegularExpression Id. */
-  int PROTECTED = 46;
+  int PRIVATE = 46;
   /** RegularExpression Id. */
-  int PUBLIC = 47;
+  int PROTECTED = 47;
   /** RegularExpression Id. */
-  int RETURN = 48;
+  int PUBLIC = 48;
   /** RegularExpression Id. */
-  int SHORT = 49;
+  int RETURN = 49;
   /** RegularExpression Id. */
-  int STATIC = 50;
+  int SHORT = 50;
   /** RegularExpression Id. */
-  int STRICTFP = 51;
+  int STATIC = 51;
   /** RegularExpression Id. */
-  int SWITCH = 52;
+  int STRICTFP = 52;
   /** RegularExpression Id. */
-  int SYNCHRONIZED = 53;
+  int SWITCH = 53;
   /** RegularExpression Id. */
-  int TRANSIENT = 54;
+  int SYNCHRONIZED = 54;
   /** RegularExpression Id. */
-  int THROW = 55;
+  int TRANSIENT = 55;
   /** RegularExpression Id. */
-  int THROWS = 56;
+  int THROW = 56;
   /** RegularExpression Id. */
-  int TRUE = 57;
+  int THROWS = 57;
   /** RegularExpression Id. */
-  int TRY = 58;
+  int TRUE = 58;
   /** RegularExpression Id. */
-  int VOID = 59;
+  int TRY = 59;
   /** RegularExpression Id. */
-  int VOLATILE = 60;
+  int VOID = 60;
   /** RegularExpression Id. */
-  int WHILE = 61;
+  int VOLATILE = 61;
   /** RegularExpression Id. */
-  int INTEGER_LITERAL = 62;
+  int WHILE = 62;
   /** RegularExpression Id. */
-  int DECIMAL_LITERAL = 63;
+  int INTEGER_LITERAL = 63;
   /** RegularExpression Id. */
-  int HEX_LITERAL = 64;
+  int DECIMAL_LITERAL = 64;
   /** RegularExpression Id. */
-  int BINARY_LITERAL = 65;
+  int HEX_LITERAL = 65;
   /** RegularExpression Id. */
-  int OCTAL_LITERAL = 66;
+  int BINARY_LITERAL = 66;
   /** RegularExpression Id. */
-  int FLOATING_POINT_LITERAL = 67;
+  int OCTAL_LITERAL = 67;
   /** RegularExpression Id. */
-  int EXPONENT = 68;
+  int FLOATING_POINT_LITERAL = 68;
   /** RegularExpression Id. */
-  int ESCAPE = 69;
+  int EXPONENT = 69;
   /** RegularExpression Id. */
-  int CHARACTER_LITERAL = 70;
+  int ESCAPE = 70;
   /** RegularExpression Id. */
-  int STRING_LITERAL = 71;
+  int CHARACTER_LITERAL = 71;
   /** RegularExpression Id. */
-  int LONG_STRING_LITERAL = 72;
+  int STRING_LITERAL = 72;
   /** RegularExpression Id. */
-  int IDENTIFIER = 73;
+  int LONG_STRING_LITERAL = 73;
   /** RegularExpression Id. */
-  int LETTER = 74;
+  int IDENTIFIER = 74;
   /** RegularExpression Id. */
-  int DIGIT = 75;
+  int LETTER = 75;
   /** RegularExpression Id. */
-  int LPAREN = 76;
+  int DIGIT = 76;
   /** RegularExpression Id. */
-  int RPAREN = 77;
+  int LPAREN = 77;
   /** RegularExpression Id. */
-  int LBRACE = 78;
+  int RPAREN = 78;
   /** RegularExpression Id. */
-  int RBRACE = 79;
+  int LBRACE = 79;
   /** RegularExpression Id. */
-  int LBRACKET = 80;
+  int RBRACE = 80;
   /** RegularExpression Id. */
-  int RBRACKET = 81;
+  int LBRACKET = 81;
   /** RegularExpression Id. */
-  int SEMICOLON = 82;
+  int RBRACKET = 82;
   /** RegularExpression Id. */
-  int COMMA = 83;
+  int SEMICOLON = 83;
   /** RegularExpression Id. */
-  int DOT = 84;
+  int COMMA = 84;
   /** RegularExpression Id. */
-  int ASSIGN = 85;
+  int DOT = 85;
   /** RegularExpression Id. */
-  int GT = 86;
+  int ASSIGN = 86;
   /** RegularExpression Id. */
-  int GTX = 87;
+  int GT = 87;
   /** RegularExpression Id. */
-  int LT = 88;
+  int GTX = 88;
   /** RegularExpression Id. */
-  int LTX = 89;
+  int LT = 89;
   /** RegularExpression Id. */
-  int BANG = 90;
+  int LTX = 90;
   /** RegularExpression Id. */
-  int TILDE = 91;
+  int BANG = 91;
   /** RegularExpression Id. */
-  int EQ = 92;
+  int TILDE = 92;
   /** RegularExpression Id. */
-  int LE = 93;
+  int EQ = 93;
   /** RegularExpression Id. */
-  int LEX = 94;
+  int LE = 94;
   /** RegularExpression Id. */
-  int GE = 95;
+  int LEX = 95;
   /** RegularExpression Id. */
-  int GEX = 96;
+  int GE = 96;
   /** RegularExpression Id. */
-  int NE = 97;
+  int GEX = 97;
   /** RegularExpression Id. */
-  int BOOL_OR = 98;
+  int NE = 98;
   /** RegularExpression Id. */
-  int BOOL_ORX = 99;
+  int BOOL_OR = 99;
   /** RegularExpression Id. */
-  int BOOL_AND = 100;
+  int BOOL_ORX = 100;
   /** RegularExpression Id. */
-  int BOOL_ANDX = 101;
+  int BOOL_AND = 101;
   /** RegularExpression Id. */
-  int INCR = 102;
+  int BOOL_ANDX = 102;
   /** RegularExpression Id. */
-  int DECR = 103;
+  int INCR = 103;
   /** RegularExpression Id. */
-  int PLUS = 104;
+  int DECR = 104;
   /** RegularExpression Id. */
-  int MINUS = 105;
+  int PLUS = 105;
   /** RegularExpression Id. */
-  int STAR = 106;
+  int MINUS = 106;
   /** RegularExpression Id. */
-  int SLASH = 107;
+  int STAR = 107;
   /** RegularExpression Id. */
-  int BIT_AND = 108;
+  int SLASH = 108;
   /** RegularExpression Id. */
-  int BIT_ANDX = 109;
+  int BIT_AND = 109;
   /** RegularExpression Id. */
-  int BIT_OR = 110;
+  int BIT_ANDX = 110;
   /** RegularExpression Id. */
-  int BIT_ORX = 111;
+  int BIT_OR = 111;
   /** RegularExpression Id. */
-  int XOR = 112;
+  int BIT_ORX = 112;
   /** RegularExpression Id. */
-  int XORX = 113;
+  int XOR = 113;
   /** RegularExpression Id. */
-  int MOD = 114;
+  int XORX = 114;
   /** RegularExpression Id. */
-  int MODX = 115;
+  int MOD = 115;
   /** RegularExpression Id. */
-  int POWER = 116;
+  int MODX = 116;
   /** RegularExpression Id. */
-  int POWERX = 117;
+  int POWER = 117;
   /** RegularExpression Id. */
-  int LSHIFT = 118;
+  int POWERX = 118;
   /** RegularExpression Id. */
-  int LSHIFTX = 119;
+  int LSHIFT = 119;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFT = 120;
+  int LSHIFTX = 120;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTX = 121;
+  int RSIGNEDSHIFT = 121;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFT = 122;
+  int RSIGNEDSHIFTX = 122;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTX = 123;
+  int RUNSIGNEDSHIFT = 123;
   /** RegularExpression Id. */
-  int PLUSASSIGN = 124;
+  int RUNSIGNEDSHIFTX = 124;
   /** RegularExpression Id. */
-  int MINUSASSIGN = 125;
+  int PLUSASSIGN = 125;
   /** RegularExpression Id. */
-  int STARASSIGN = 126;
+  int MINUSASSIGN = 126;
   /** RegularExpression Id. */
-  int SLASHASSIGN = 127;
+  int STARASSIGN = 127;
   /** RegularExpression Id. */
-  int ANDASSIGN = 128;
+  int SLASHASSIGN = 128;
   /** RegularExpression Id. */
-  int ANDASSIGNX = 129;
+  int ANDASSIGN = 129;
   /** RegularExpression Id. */
-  int ORASSIGN = 130;
+  int ANDASSIGNX = 130;
   /** RegularExpression Id. */
-  int ORASSIGNX = 131;
+  int ORASSIGN = 131;
   /** RegularExpression Id. */
-  int XORASSIGN = 132;
+  int ORASSIGNX = 132;
   /** RegularExpression Id. */
-  int XORASSIGNX = 133;
+  int XORASSIGN = 133;
   /** RegularExpression Id. */
-  int MODASSIGN = 134;
+  int XORASSIGNX = 134;
   /** RegularExpression Id. */
-  int MODASSIGNX = 135;
+  int MODASSIGN = 135;
   /** RegularExpression Id. */
-  int POWERASSIGN = 136;
+  int MODASSIGNX = 136;
   /** RegularExpression Id. */
-  int POWERASSIGNX = 137;
+  int POWERASSIGN = 137;
   /** RegularExpression Id. */
-  int LSHIFTASSIGN = 138;
+  int POWERASSIGNX = 138;
   /** RegularExpression Id. */
-  int LSHIFTASSIGNX = 139;
+  int LSHIFTASSIGN = 139;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGN = 140;
+  int LSHIFTASSIGNX = 140;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGNX = 141;
+  int RSIGNEDSHIFTASSIGN = 141;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGN = 142;
+  int RSIGNEDSHIFTASSIGNX = 142;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGNX = 143;
+  int RUNSIGNEDSHIFTASSIGN = 143;
   /** RegularExpression Id. */
-  int ARROW = 144;
+  int RUNSIGNEDSHIFTASSIGNX = 144;
   /** RegularExpression Id. */
-  int SPACESHIP = 145;
+  int ARROW = 145;
   /** RegularExpression Id. */
-  int NULLCOALESCEASSIGN = 146;
+  int SPACESHIP = 146;
   /** RegularExpression Id. */
-  int NULLCOALESCE = 147;
+  int NULLCOALESCEASSIGN = 147;
   /** RegularExpression Id. */
-  int ELVIS = 148;
+  int NULLCOALESCE = 148;
   /** RegularExpression Id. */
-  int HOOK = 149;
+  int ELVIS = 149;
   /** RegularExpression Id. */
-  int COLON = 150;
+  int HOOK = 150;
   /** RegularExpression Id. */
-  int COLON_COLON = 151;
+  int COLON = 151;
   /** RegularExpression Id. */
-  int ELLIPSIS = 152;
+  int COLON_COLON = 152;
+  /** RegularExpression Id. */
+  int ELLIPSIS = 153;
 
   /** Lexical state. */
   int DEFAULT = 0;
@@ -373,6 +375,7 @@ public interface ParserConstants {
     "\"import\"",
     "\"instanceof\"",
     "\"is\"",
+    "\"as\"",
     "\"int\"",
     "\"interface\"",
     "\"long\"",
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
index 93c086f..10b08cb 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
@@ -38,113 +38,113 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
    switch (pos)
    {
       case 0:
-         if ((active1 & 0x40000021000000L) != 0x0L || (active2 & 0x20400L) != 0x0L)
+         if ((active1 & 0x80000042000000L) != 0x0L || (active2 & 0x40800L) != 0x0L)
             return 75;
-         if ((active1 & 0x100000L) != 0x0L || (active2 & 0x1000000L) != 0x0L)
+         if ((active1 & 0x200000L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
             return 18;
-         if ((active1 & 0x8000080000000000L) != 0x0L)
+         if ((active1 & 0x100000000000L) != 0x0L || (active2 & 0x1L) != 0x0L)
             return 64;
-         if ((active0 & 0x3ffffffffffff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active0 & 0x7ffffffffffff800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
          {
-            jjmatchedKind = 73;
+            jjmatchedKind = 74;
             return 42;
          }
          if ((active0 & 0x3eL) != 0x0L)
             return 0;
          return -1;
       case 1:
-         if ((active1 & 0x40000000000000L) != 0x0L || (active2 & 0x400L) != 0x0L)
+         if ((active1 & 0x80000000000000L) != 0x0L || (active2 & 0x800L) != 0x0L)
             return 75;
-         if ((active0 & 0x2200c00000L) != 0x0L)
+         if ((active0 & 0x6200c00000L) != 0x0L)
             return 42;
-         if ((active0 & 0x3fffffddff3ff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active0 & 0x7fffff9dff3ff800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
          {
             if (jjmatchedPos != 1)
             {
-               jjmatchedKind = 73;
+               jjmatchedKind = 74;
                jjmatchedPos = 1;
             }
             return 42;
          }
          return -1;
       case 2:
-         if ((active0 & 0x40004c080000000L) != 0x0L)
-            return 42;
-         if ((active0 & 0x3bfffb1d7fbff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active0 & 0x77fff61d7fbff800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
          {
             if (jjmatchedPos != 2)
             {
-               jjmatchedKind = 73;
+               jjmatchedKind = 74;
                jjmatchedPos = 2;
             }
             return 42;
          }
+         if ((active0 & 0x800098080000000L) != 0x0L)
+            return 42;
          return -1;
       case 3:
-         if ((active0 & 0xa00090103058000L) != 0x0L)
+         if ((active0 & 0x1400120103058000L) != 0x0L)
             return 42;
-         if ((active0 & 0x31fff29c7cba7800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active0 & 0x63ffe51c7cba7800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
          {
             if (jjmatchedPos != 3)
             {
-               jjmatchedKind = 73;
+               jjmatchedKind = 74;
                jjmatchedPos = 3;
             }
             return 42;
          }
          return -1;
       case 4:
-         if ((active0 & 0x21820000780a6000L) != 0x0L)
+         if ((active0 & 0x43040000780a6000L) != 0x0L)
             return 42;
-         if ((active0 & 0x107df29c04b01800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active0 & 0x20fbe51c04b01800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
          {
             if (jjmatchedPos != 4)
             {
-               jjmatchedKind = 73;
+               jjmatchedKind = 74;
                jjmatchedPos = 4;
             }
             return 42;
          }
          return -1;
       case 5:
-         if ((active0 & 0x1068709424301800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active0 & 0x22b040800800000L) != 0x0L)
+            return 42;
+         if ((active0 & 0x20d0e11424301800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
          {
-            jjmatchedKind = 73;
+            jjmatchedKind = 74;
             jjmatchedPos = 5;
             return 42;
          }
-         if ((active0 & 0x115820800800000L) != 0x0L)
-            return 42;
          return -1;
       case 6:
-         if ((active0 & 0x300024201000L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
-            return 42;
-         if ((active0 & 0x1068409400100800L) != 0x0L)
+         if ((active0 & 0x20d0811400100800L) != 0x0L)
          {
             if (jjmatchedPos != 6)
             {
-               jjmatchedKind = 73;
+               jjmatchedKind = 74;
                jjmatchedPos = 6;
             }
             return 42;
          }
+         if ((active0 & 0x600024201000L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+            return 42;
          return -1;
       case 7:
-         if ((active0 & 0x1008000000100800L) != 0x0L)
+         if ((active0 & 0x2010000000100800L) != 0x0L)
             return 42;
-         if ((active0 & 0x60409400000000L) != 0x0L)
+         if ((active0 & 0xc0811400000000L) != 0x0L)
          {
-            jjmatchedKind = 73;
+            jjmatchedKind = 74;
             jjmatchedPos = 7;
             return 42;
          }
          return -1;
       case 8:
-         if ((active0 & 0x40408000000000L) != 0x0L)
+         if ((active0 & 0x80810000000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x20001400000000L) != 0x0L)
+         if ((active0 & 0x40001400000000L) != 0x0L)
          {
-            jjmatchedKind = 73;
+            jjmatchedKind = 74;
             jjmatchedPos = 8;
             return 42;
          }
@@ -152,26 +152,26 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
       case 9:
          if ((active0 & 0x1400000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x20000000000000L) != 0x0L)
+         if ((active0 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 73;
+            jjmatchedKind = 74;
             jjmatchedPos = 9;
             return 42;
          }
          return -1;
       case 10:
-         if ((active0 & 0x20000000000000L) != 0x0L)
+         if ((active0 & 0x40000000000000L) != 0x0L)
          {
             if (jjmatchedPos != 10)
             {
-               jjmatchedKind = 73;
+               jjmatchedKind = 74;
                jjmatchedPos = 10;
             }
             return 42;
          }
          return -1;
       case 11:
-         if ((active0 & 0x20000000000000L) != 0x0L)
+         if ((active0 & 0x40000000000000L) != 0x0L)
             return 42;
          return -1;
       default :
@@ -201,69 +201,69 @@ private int jjMoveStringLiteralDfa0_0(){
       case ' ':
          return jjStartNfaWithStates_0(0, 1, 0);
       case '!':
-         jjmatchedKind = 90;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L, 0x0L);
+         jjmatchedKind = 91;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L, 0x0L);
       case '%':
-         jjmatchedKind = 114;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x40L);
+         jjmatchedKind = 115;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x80L);
       case '&':
-         jjmatchedKind = 108;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000L, 0x1L);
+         jjmatchedKind = 109;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000L, 0x2L);
       case '(':
-         return jjStopAtPos(0, 76);
-      case ')':
          return jjStopAtPos(0, 77);
+      case ')':
+         return jjStopAtPos(0, 78);
       case '*':
-         jjmatchedKind = 106;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x4010000000000000L, 0x100L);
+         jjmatchedKind = 107;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x8020000000000000L, 0x200L);
       case '+':
-         jjmatchedKind = 104;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000004000000000L, 0x0L);
+         jjmatchedKind = 105;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000008000000000L, 0x0L);
       case ',':
-         return jjStopAtPos(0, 83);
+         return jjStopAtPos(0, 84);
       case '-':
-         jjmatchedKind = 105;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000008000000000L, 0x10000L);
+         jjmatchedKind = 106;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000010000000000L, 0x20000L);
       case '.':
-         jjmatchedKind = 84;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1000000L);
+         jjmatchedKind = 85;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2000000L);
       case '/':
-         jjmatchedKind = 107;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L, 0x0L);
+         jjmatchedKind = 108;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1L);
       case ':':
-         jjmatchedKind = 150;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x800000L);
+         jjmatchedKind = 151;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1000000L);
       case ';':
-         return jjStopAtPos(0, 82);
+         return jjStopAtPos(0, 83);
       case '<':
-         jjmatchedKind = 88;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000020000000L, 0x20400L);
+         jjmatchedKind = 89;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x80000040000000L, 0x40800L);
       case '=':
-         jjmatchedKind = 85;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L, 0x0L);
-      case '>':
          jjmatchedKind = 86;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x500000080000000L, 0x5000L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L, 0x0L);
+      case '>':
+         jjmatchedKind = 87;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0xa00000100000000L, 0xa000L);
       case '?':
-         jjmatchedKind = 149;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x21c0000L);
+         jjmatchedKind = 150;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x4380000L);
       case '@':
-         return jjMoveStringLiteralDfa1_0(0x0L, 0xaaaa02942800000L, 0xaaaaL);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1555405285000000L, 0x15554L);
       case '[':
-         return jjStopAtPos(0, 80);
-      case ']':
          return jjStopAtPos(0, 81);
+      case ']':
+         return jjStopAtPos(0, 82);
       case '^':
-         jjmatchedKind = 112;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10L);
+         jjmatchedKind = 113;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x20L);
       case 'a':
-         return jjMoveStringLiteralDfa1_0(0x800L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x4000000800L, 0x0L, 0x0L);
       case 'b':
          return jjMoveStringLiteralDfa1_0(0xb000L, 0x0L, 0x0L);
       case 'c':
          return jjMoveStringLiteralDfa1_0(0x1f4000L, 0x0L, 0x0L);
       case 'd':
-         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x4000000L);
+         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x8000000L);
       case 'e':
          return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L, 0x0L);
       case 'f':
@@ -271,32 +271,32 @@ private int jjMoveStringLiteralDfa0_0(){
       case 'g':
          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L, 0x0L);
       case 'i':
-         return jjMoveStringLiteralDfa1_0(0xfe00000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x1be00000000L, 0x0L, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L, 0x0L);
       case 'p':
-         return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x1e00000000000L, 0x0L, 0x0L);
       case 'r':
-         return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L, 0x0L);
       case 's':
-         return jjMoveStringLiteralDfa1_0(0x3e000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x7c000000000000L, 0x0L, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa1_0(0x7c0000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0xf80000000000000L, 0x0L, 0x0L);
       case 'v':
-         return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L, 0x0L);
       case '{':
-         return jjStopAtPos(0, 78);
+         return jjStopAtPos(0, 79);
       case '|':
-         jjmatchedKind = 110;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L, 0x4L);
+         jjmatchedKind = 111;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000L, 0x8L);
       case '}':
-         return jjStopAtPos(0, 79);
+         return jjStopAtPos(0, 80);
       case '~':
-         return jjStopAtPos(0, 91);
+         return jjStopAtPos(0, 92);
       default :
          return jjMoveNfa_0(1, 0);
    }
@@ -310,55 +310,53 @@ private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){
    switch(curChar)
    {
       case '&':
-         if ((active1 & 0x1000000000L) != 0x0L)
-            return jjStopAtPos(1, 100);
+         if ((active1 & 0x2000000000L) != 0x0L)
+            return jjStopAtPos(1, 101);
          break;
       case '*':
-         if ((active1 & 0x10000000000000L) != 0x0L)
+         if ((active1 & 0x20000000000000L) != 0x0L)
          {
-            jjmatchedKind = 116;
+            jjmatchedKind = 117;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x100L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x200L);
       case '+':
-         if ((active1 & 0x4000000000L) != 0x0L)
-            return jjStopAtPos(1, 102);
-         break;
-      case '-':
          if ((active1 & 0x8000000000L) != 0x0L)
             return jjStopAtPos(1, 103);
          break;
+      case '-':
+         if ((active1 & 0x10000000000L) != 0x0L)
+            return jjStopAtPos(1, 104);
+         break;
       case '.':
-         if ((active2 & 0x2000000L) != 0x0L)
-            return jjStopAtPos(1, 153);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x1000000L);
+         if ((active2 & 0x4000000L) != 0x0L)
+            return jjStopAtPos(1, 154);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x2000000L);
       case ':':
-         if ((active2 & 0x100000L) != 0x0L)
-            return jjStopAtPos(1, 148);
-         else if ((active2 & 0x800000L) != 0x0L)
-            return jjStopAtPos(1, 151);
+         if ((active2 & 0x200000L) != 0x0L)
+            return jjStopAtPos(1, 149);
+         else if ((active2 & 0x1000000L) != 0x0L)
+            return jjStopAtPos(1, 152);
          break;
       case '<':
-         if ((active1 & 0x40000000000000L) != 0x0L)
+         if ((active1 & 0x80000000000000L) != 0x0L)
          {
-            jjmatchedKind = 118;
+            jjmatchedKind = 119;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
       case '=':
-         if ((active1 & 0x10000000L) != 0x0L)
-            return jjStopAtPos(1, 92);
-         else if ((active1 & 0x20000000L) != 0x0L)
+         if ((active1 & 0x20000000L) != 0x0L)
+            return jjStopAtPos(1, 93);
+         else if ((active1 & 0x40000000L) != 0x0L)
          {
-            jjmatchedKind = 93;
+            jjmatchedKind = 94;
             jjmatchedPos = 1;
          }
-         else if ((active1 & 0x80000000L) != 0x0L)
-            return jjStopAtPos(1, 95);
-         else if ((active1 & 0x200000000L) != 0x0L)
-            return jjStopAtPos(1, 97);
-         else if ((active1 & 0x1000000000000000L) != 0x0L)
-            return jjStopAtPos(1, 124);
+         else if ((active1 & 0x100000000L) != 0x0L)
+            return jjStopAtPos(1, 96);
+         else if ((active1 & 0x400000000L) != 0x0L)
+            return jjStopAtPos(1, 98);
          else if ((active1 & 0x2000000000000000L) != 0x0L)
             return jjStopAtPos(1, 125);
          else if ((active1 & 0x4000000000000000L) != 0x0L)
@@ -367,79 +365,83 @@ else if ((active1 & 0x8000000000000000L) != 0x0L)
             return jjStopAtPos(1, 127);
          else if ((active2 & 0x1L) != 0x0L)
             return jjStopAtPos(1, 128);
-         else if ((active2 & 0x4L) != 0x0L)
-            return jjStopAtPos(1, 130);
-         else if ((active2 & 0x10L) != 0x0L)
-            return jjStopAtPos(1, 132);
-         else if ((active2 & 0x40L) != 0x0L)
-            return jjStopAtPos(1, 134);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x20000L);
+         else if ((active2 & 0x2L) != 0x0L)
+            return jjStopAtPos(1, 129);
+         else if ((active2 & 0x8L) != 0x0L)
+            return jjStopAtPos(1, 131);
+         else if ((active2 & 0x20L) != 0x0L)
+            return jjStopAtPos(1, 133);
+         else if ((active2 & 0x80L) != 0x0L)
+            return jjStopAtPos(1, 135);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x40000L);
       case '>':
-         if ((active1 & 0x100000000000000L) != 0x0L)
+         if ((active1 & 0x200000000000000L) != 0x0L)
          {
-            jjmatchedKind = 120;
+            jjmatchedKind = 121;
             jjmatchedPos = 1;
          }
-         else if ((active2 & 0x10000L) != 0x0L)
-            return jjStopAtPos(1, 144);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x5000L);
+         else if ((active2 & 0x20000L) != 0x0L)
+            return jjStopAtPos(1, 145);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0xa000L);
       case '?':
-         if ((active2 & 0x80000L) != 0x0L)
+         if ((active2 & 0x100000L) != 0x0L)
          {
-            jjmatchedKind = 147;
+            jjmatchedKind = 148;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x40000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x80000L);
       case 'a':
-         return jjMoveStringLiteralDfa2_0(active0, 0x120008030000L, active1, 0x2000000000L, active2, 0x2L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x240008030000L, active1, 0x4000000000L, active2, 0x4L);
       case 'b':
-         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x2a00000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x5400000000000L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa2_0(active0, 0x1040000200000L, active1, 0x0L, active2, 0x4000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x2080000200000L, active1, 0x0L, active2, 0x8000000L);
       case 'f':
          if ((active0 & 0x200000000L) != 0x0L)
             return jjStartNfaWithStates_0(1, 33, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x100800000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x201000000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa2_0(active0, 0x2182000000040000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x4304000000040000L, active1, 0x0L, active2, 0x0L);
       case 'i':
          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x80000042000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x100000084000000L, active2, 0x1000L);
       case 'm':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x8000000000000L, active2, 0x80L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x10000000000000L, active2, 0x100L);
       case 'n':
-         return jjMoveStringLiteralDfa2_0(active0, 0xd002000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x19002000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x400000L) != 0x0L)
          {
             jjmatchedKind = 22;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x1800010180981000L, active1, 0x800000000L, active2, 0x8L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x3000020180981000L, active1, 0x1000000000L, active2, 0x10L);
       case 'p':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x20000000000000L, active2, 0x200L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x40000000000000L, active2, 0x400L);
       case 'r':
-         return jjMoveStringLiteralDfa2_0(active0, 0x640600000002000L, active1, 0xa00000000000000L, active2, 0xa000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc80c00000002000L, active1, 0x1400000000000000L, active2, 0x14000L);
       case 's':
          if ((active0 & 0x2000000000L) != 0x0L)
             return jjStartNfaWithStates_0(1, 37, 42);
+         else if ((active0 & 0x4000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(1, 38, 42);
          break;
       case 't':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x18000000000000L, active1, 0x0L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa2_0(active0, 0x880000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x1100000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 'x':
-         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x40L);
       case 'y':
-         return jjMoveStringLiteralDfa2_0(active0, 0x20000000008000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x40000000008000L, active1, 0x0L, active2, 0x0L);
       case '|':
-         if ((active1 & 0x400000000L) != 0x0L)
-            return jjStopAtPos(1, 98);
+         if ((active1 & 0x800000000L) != 0x0L)
+            return jjStopAtPos(1, 99);
          break;
       default :
          break;
@@ -457,85 +459,85 @@ private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '.':
-         if ((active2 & 0x1000000L) != 0x0L)
-            return jjStopAtPos(2, 152);
+         if ((active2 & 0x2000000L) != 0x0L)
+            return jjStopAtPos(2, 153);
          break;
       case '=':
-         if ((active2 & 0x100L) != 0x0L)
-            return jjStopAtPos(2, 136);
-         else if ((active2 & 0x400L) != 0x0L)
-            return jjStopAtPos(2, 138);
-         else if ((active2 & 0x1000L) != 0x0L)
-            return jjStopAtPos(2, 140);
-         else if ((active2 & 0x40000L) != 0x0L)
-            return jjStopAtPos(2, 146);
+         if ((active2 & 0x200L) != 0x0L)
+            return jjStopAtPos(2, 137);
+         else if ((active2 & 0x800L) != 0x0L)
+            return jjStopAtPos(2, 139);
+         else if ((active2 & 0x2000L) != 0x0L)
+            return jjStopAtPos(2, 141);
+         else if ((active2 & 0x80000L) != 0x0L)
+            return jjStopAtPos(2, 147);
          break;
       case '>':
-         if ((active1 & 0x400000000000000L) != 0x0L)
+         if ((active1 & 0x800000000000000L) != 0x0L)
          {
-            jjmatchedKind = 122;
+            jjmatchedKind = 123;
             jjmatchedPos = 2;
          }
-         else if ((active2 & 0x20000L) != 0x0L)
-            return jjStopAtPos(2, 145);
-         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x4000L);
+         else if ((active2 & 0x40000L) != 0x0L)
+            return jjStopAtPos(2, 146);
+         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x8000L);
       case 'a':
-         return jjMoveStringLiteralDfa3_0(active0, 0x44000000044000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x88000000044000L, active1, 0x0L, active2, 0x0L);
       case 'b':
-         return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
-         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa3_0(active0, 0x2000L, active1, 0x80000000000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2000L, active1, 0x100000000000000L, active2, 0x1000L);
       case 'f':
-         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x4000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x8000000L);
       case 'i':
-         return jjMoveStringLiteralDfa3_0(active0, 0x2810200000000000L, active1, 0xa02a00000000000L, active2, 0xa000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x5020400000000000L, active1, 0x1405400000000000L, active2, 0x14000L);
       case 'l':
-         return jjMoveStringLiteralDfa3_0(active0, 0x1000080008000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2000100008000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa3_0(active0, 0x20010030180000L, active1, 0x2000000000L, active2, 0x2L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x40020030180000L, active1, 0x4000000000L, active2, 0x4L);
       case 'o':
-         return jjMoveStringLiteralDfa3_0(active0, 0x2400040001000L, active1, 0x28000000000000L, active2, 0x2a0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x4800040001000L, active1, 0x50000000000000L, active2, 0x540L);
       case 'p':
          return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x80000000L) != 0x0L)
             return jjStartNfaWithStates_0(2, 31, 42);
-         else if ((active1 & 0x800000000L) != 0x0L)
+         else if ((active1 & 0x1000000000L) != 0x0L)
          {
-            jjmatchedKind = 99;
+            jjmatchedKind = 100;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x188000000000000L, active1, 0x0L, active2, 0x8L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x310000000000000L, active1, 0x0L, active2, 0x10L);
       case 's':
          return jjMoveStringLiteralDfa3_0(active0, 0x1001010800L, active1, 0x0L, active2, 0x0L);
       case 't':
-         if ((active0 & 0x4000000000L) != 0x0L)
+         if ((active0 & 0x8000000000L) != 0x0L)
          {
-            jjmatchedKind = 38;
+            jjmatchedKind = 39;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x800000L) != 0x0L)
+         else if ((active1 & 0x1000000L) != 0x0L)
          {
-            jjmatchedKind = 87;
+            jjmatchedKind = 88;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x2000000L) != 0x0L)
+         else if ((active1 & 0x4000000L) != 0x0L)
          {
-            jjmatchedKind = 89;
+            jjmatchedKind = 90;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x1028104028000L, active1, 0x140000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2050104028000L, active1, 0x280000000L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa3_0(active0, 0x200000002800000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x400000002800000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active0 & 0x40000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(2, 42, 42);
+         if ((active0 & 0x80000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(2, 43, 42);
          break;
       case 'y':
-         if ((active0 & 0x400000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(2, 58, 42);
+         if ((active0 & 0x800000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(2, 59, 42);
          break;
       default :
          break;
@@ -553,31 +555,31 @@ private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '=':
-         if ((active2 & 0x4000L) != 0x0L)
-            return jjStopAtPos(3, 142);
+         if ((active2 & 0x8000L) != 0x0L)
+            return jjStopAtPos(3, 143);
          break;
       case '_':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
       case 'a':
-         return jjMoveStringLiteralDfa4_0(active0, 0x1000000070202000L, active1, 0x0L, active2, 0x4000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000070202000L, active1, 0x0L, active2, 0x8000000L);
       case 'b':
          return jjMoveStringLiteralDfa4_0(active0, 0x800000L, active1, 0x0L, active2, 0x0L);
       case 'c':
-         return jjMoveStringLiteralDfa4_0(active0, 0x20000000020000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x40000000020000L, active1, 0x0L, active2, 0x0L);
       case 'd':
-         if ((active0 & 0x800000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 59, 42);
-         else if ((active1 & 0x2000000000L) != 0x0L)
+         if ((active0 & 0x1000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 60, 42);
+         else if ((active1 & 0x4000000000L) != 0x0L)
          {
-            jjmatchedKind = 101;
+            jjmatchedKind = 102;
             jjmatchedPos = 3;
          }
-         else if ((active1 & 0x8000000000000L) != 0x0L)
+         else if ((active1 & 0x10000000000000L) != 0x0L)
          {
-            jjmatchedKind = 115;
+            jjmatchedKind = 116;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x82L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x104L);
       case 'e':
          if ((active0 & 0x8000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 15, 42);
@@ -585,52 +587,52 @@ else if ((active0 & 0x10000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 16, 42);
          else if ((active0 & 0x1000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 24, 42);
-         else if ((active0 & 0x200000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 57, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x8004000000L, active1, 0x140000000L, active2, 0x0L);
+         else if ((active0 & 0x400000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 58, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x10004000000L, active1, 0x280000000L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
       case 'g':
-         if ((active0 & 0x10000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 40, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0xa00000000000000L, active2, 0xa000L);
+         if ((active0 & 0x20000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 41, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x1400000000000000L, active2, 0x14000L);
       case 'i':
-         return jjMoveStringLiteralDfa4_0(active0, 0x8020000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0x0L, active2, 0x0L);
       case 'k':
-         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         if ((active0 & 0x80000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 43, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x2000800400001000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x100000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 44, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x4001000400001000L, active1, 0x0L, active2, 0x0L);
       case 'm':
          if ((active0 & 0x2000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 25, 42);
          break;
       case 'n':
-         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x100000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 32, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x180000800000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x300000800000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x40000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 18, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0x0L, active2, 0x40L);
       case 's':
          return jjMoveStringLiteralDfa4_0(active0, 0x8084000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa4_0(active0, 0x14401000100800L, active1, 0x2a00000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x28801000100800L, active1, 0x5400000000000L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0x0L, active2, 0x0L);
       case 'v':
-         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active1 & 0x20000000000000L) != 0x0L)
+         if ((active1 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 117;
+            jjmatchedKind = 118;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x200L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
       default :
          break;
    }
@@ -647,23 +649,23 @@ private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0x2a2L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0x544L);
       case 'a':
-         return jjMoveStringLiteralDfa5_0(active0, 0x301000000000L, active1, 0x0L, active2, 0x8L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x601000000000L, active1, 0x0L, active2, 0x10L);
       case 'c':
-         return jjMoveStringLiteralDfa5_0(active0, 0x18000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x30000000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x8000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 27, 42);
-         else if ((active0 & 0x2000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 61, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x400400001000L, active1, 0x0L, active2, 0x0L);
+         else if ((active0 & 0x4000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 62, 42);
+         return jjMoveStringLiteralDfa5_0(active0, 0x800400001000L, active1, 0x0L, active2, 0x0L);
       case 'h':
          if ((active0 & 0x20000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 17, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0xa00000000000000L, active2, 0xa000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x1400000000000000L, active2, 0x14000L);
       case 'i':
-         return jjMoveStringLiteralDfa5_0(active0, 0x4800000100000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x9000000100000L, active1, 0x0L, active2, 0x0L);
       case 'k':
          if ((active0 & 0x2000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 13, 42);
@@ -678,36 +680,36 @@ else if ((active0 & 0x2000000000000000L) != 0x0L)
       case 'n':
          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'q':
-         if ((active1 & 0x40000000L) != 0x0L)
-            return jjStopAtPos(4, 94);
-         else if ((active1 & 0x100000000L) != 0x0L)
-            return jjStopAtPos(4, 96);
+         if ((active1 & 0x80000000L) != 0x0L)
+            return jjStopAtPos(4, 95);
+         else if ((active1 & 0x200000000L) != 0x0L)
+            return jjStopAtPos(4, 97);
          break;
       case 'r':
-         return jjMoveStringLiteralDfa5_0(active0, 0x1008800000800L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x2010800000800L, active1, 0x0L, active2, 0x0L);
       case 's':
          if ((active0 & 0x4000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 14, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
          if ((active0 & 0x80000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 19, 42);
          else if ((active0 & 0x40000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 30, 42);
-         else if ((active0 & 0x2000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 49, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0x80000000000000L, active2, 0x800L);
+         else if ((active0 & 0x4000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 50, 42);
+         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0x100000000000000L, active2, 0x1000L);
       case 'u':
-         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x4000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x8000000L);
       case 'v':
-         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active0 & 0x80000000000000L) != 0x0L)
+         if ((active0 & 0x100000000000000L) != 0x0L)
          {
-            jjmatchedKind = 55;
+            jjmatchedKind = 56;
             jjmatchedPos = 4;
          }
-         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0x2a00000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0x5400000000000L, active2, 0x0L);
       default :
          break;
    }
@@ -724,51 +726,51 @@ private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
       case 'a':
-         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0x2a2L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0x544L);
       case 'c':
-         if ((active0 & 0x800000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 47, 42);
-         else if ((active0 & 0x4000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 50, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x1000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 48, 42);
+         else if ((active0 & 0x8000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 51, 42);
+         return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
       case 'd':
          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x800000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 23, 42);
-         else if ((active0 & 0x20000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 41, 42);
+         else if ((active0 & 0x40000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 42, 42);
          break;
       case 'f':
-         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
       case 'g':
-         return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
       case 'h':
-         if ((active0 & 0x10000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 52, 42);
+         if ((active0 & 0x20000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 53, 42);
          break;
       case 'i':
-         return jjMoveStringLiteralDfa6_0(active0, 0x1040000000000000L, active1, 0x2a00000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x2080000000000000L, active1, 0x5400000000000L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x4000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x8000000L);
       case 'm':
          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         if ((active0 & 0x1000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 48, 42);
+         if ((active0 & 0x2000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 49, 42);
          return jjMoveStringLiteralDfa6_0(active0, 0x1000100000L, active1, 0x0L, active2, 0x0L);
       case 'r':
-         return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       case 's':
-         if ((active0 & 0x100000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 56, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
+         if ((active0 & 0x200000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 57, 42);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
       case 't':
          if ((active0 & 0x800000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 35, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x8200000000000L, active1, 0xa00000000000000L, active2, 0xa000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L, active1, 0x1400000000000000L, active2, 0x14000L);
       default :
          break;
    }
@@ -785,38 +787,38 @@ private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0xa00000000000000L, active2, 0xa000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x1400000000000000L, active2, 0x14000L);
       case 'a':
-         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
          return jjMoveStringLiteralDfa7_0(active0, 0x1000000800L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         if ((active0 & 0x100000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(6, 44, 42);
-         else if ((active0 & 0x200000000000L) != 0x0L)
+         if ((active0 & 0x200000000000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 45, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x40000400000000L, active1, 0x0L, active2, 0x0L);
+         else if ((active0 & 0x400000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(6, 46, 42);
+         return jjMoveStringLiteralDfa7_0(active0, 0x80000400000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
          if ((active0 & 0x1000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 12, 42);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       case 's':
          if ((active0 & 0x4000000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 26, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x82a00000000000L, active2, 0xaaaL);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x105400000000000L, active2, 0x1554L);
       case 't':
          if ((active0 & 0x200000L) != 0x0L)
          {
             jjmatchedKind = 21;
             jjmatchedPos = 6;
          }
-         return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x4000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x8000000L);
       case 'u':
          return jjMoveStringLiteralDfa7_0(active0, 0x100000L, active1, 0x0L, active2, 0x0L);
       case 'y':
@@ -839,35 +841,35 @@ private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case ':':
-         if ((active2 & 0x4000000L) != 0x0L)
-            return jjStopAtPos(7, 154);
+         if ((active2 & 0x8000000L) != 0x0L)
+            return jjStopAtPos(7, 155);
          break;
       case 'c':
-         return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x100000L) != 0x0L)
             return jjStartNfaWithStates_0(7, 20, 42);
-         else if ((active0 & 0x1000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(7, 60, 42);
-         return jjMoveStringLiteralDfa8_0(active0, 0x401000000000L, active1, 0x2a00000000000L, active2, 0x0L);
+         else if ((active0 & 0x2000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(7, 61, 42);
+         return jjMoveStringLiteralDfa8_0(active0, 0x801000000000L, active1, 0x5400000000000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
       case 'i':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
       case 'n':
-         return jjMoveStringLiteralDfa8_0(active0, 0x60000400000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0xc0000400000000L, active1, 0x0L, active2, 0x0L);
       case 'p':
-         if ((active0 & 0x8000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(7, 51, 42);
+         if ((active0 & 0x10000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(7, 52, 42);
          break;
       case 's':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x22a2L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4544L);
       case 't':
          if ((active0 & 0x800L) != 0x0L)
             return jjStartNfaWithStates_0(7, 11, 42);
          break;
       case 'u':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
       default :
          break;
    }
@@ -884,28 +886,28 @@ private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x2a00000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x5400000000000L, active2, 0x0L);
       case 'd':
-         if ((active0 & 0x400000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 46, 42);
+         if ((active0 & 0x800000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 47, 42);
          break;
       case 'e':
-         if ((active0 & 0x8000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 39, 42);
+         if ((active0 & 0x10000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 40, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
       case 'h':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
       case 'i':
-         return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0x80000000000000L, active2, 0xaa2L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0x100000000000000L, active2, 0x1544L);
       case 'n':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
       case 'o':
          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         if ((active0 & 0x40000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 54, 42);
+         if ((active0 & 0x80000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 55, 42);
          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       default :
          break;
@@ -923,29 +925,29 @@ private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x400000000000L, active2, 0x0L);
       case 'f':
          if ((active0 & 0x1000000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 36, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
       case 'g':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0x2a2L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0x544L);
       case 'i':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
       case 'n':
-         if ((active2 & 0x8L) != 0x0L)
-            return jjStopAtPos(9, 131);
+         if ((active2 & 0x10L) != 0x0L)
+            return jjStopAtPos(9, 132);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x1000000000000L, active2, 0x0L);
       case 's':
          if ((active0 & 0x400000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 34, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
       case 'x':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x4000000000000L, active2, 0x0L);
       case 'z':
-         return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       default :
          break;
    }
@@ -962,34 +964,34 @@ private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case 'e':
-         return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
       case 'i':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
       case 'n':
-         if ((active2 & 0x2L) != 0x0L)
-            return jjStopAtPos(10, 129);
-         else if ((active2 & 0x20L) != 0x0L)
-            return jjStopAtPos(10, 133);
-         else if ((active2 & 0x80L) != 0x0L)
-            return jjStopAtPos(10, 135);
-         else if ((active2 & 0x200L) != 0x0L)
-            return jjStopAtPos(10, 137);
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x200000000000L, active2, 0x0L);
+         if ((active2 & 0x4L) != 0x0L)
+            return jjStopAtPos(10, 130);
+         else if ((active2 & 0x40L) != 0x0L)
+            return jjStopAtPos(10, 134);
+         else if ((active2 & 0x100L) != 0x0L)
+            return jjStopAtPos(10, 136);
+         else if ((active2 & 0x400L) != 0x0L)
+            return jjStopAtPos(10, 138);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x400000000000L, active2, 0x0L);
       case 'o':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x4000000000000L, active2, 0x0L);
       case 'r':
-         if ((active1 & 0x800000000000L) != 0x0L)
-            return jjStopAtPos(10, 111);
+         if ((active1 & 0x1000000000000L) != 0x0L)
+            return jjStopAtPos(10, 112);
          break;
       case 't':
-         if ((active1 & 0x80000000000000L) != 0x0L)
+         if ((active1 & 0x100000000000000L) != 0x0L)
          {
-            jjmatchedKind = 119;
+            jjmatchedKind = 120;
             jjmatchedPos = 10;
          }
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
       default :
          break;
    }
@@ -1006,26 +1008,26 @@ private int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
       case 'd':
-         if ((active0 & 0x20000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(11, 53, 42);
-         else if ((active1 & 0x200000000000L) != 0x0L)
-            return jjStopAtPos(11, 109);
+         if ((active0 & 0x40000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(11, 54, 42);
+         else if ((active1 & 0x400000000000L) != 0x0L)
+            return jjStopAtPos(11, 110);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
       case 'r':
-         if ((active1 & 0x2000000000000L) != 0x0L)
-            return jjStopAtPos(11, 113);
+         if ((active1 & 0x4000000000000L) != 0x0L)
+            return jjStopAtPos(11, 114);
          break;
       case 't':
-         if ((active1 & 0x200000000000000L) != 0x0L)
+         if ((active1 & 0x400000000000000L) != 0x0L)
          {
-            jjmatchedKind = 121;
+            jjmatchedKind = 122;
             jjmatchedPos = 11;
          }
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x4000L);
       default :
          break;
    }
@@ -1042,11 +1044,11 @@ private int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x4000L);
       case 'a':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x1000L);
       case 'n':
-         return jjMoveStringLiteralDfa13_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x1000000000000000L, active2, 0x10000L);
       default :
          break;
    }
@@ -1063,11 +1065,11 @@ private int jjMoveStringLiteralDfa13_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x4000L);
       case 'e':
-         return jjMoveStringLiteralDfa14_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x1000000000000000L, active2, 0x10000L);
       case 's':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x1000L);
       default :
          break;
    }
@@ -1084,9 +1086,9 @@ private int jjMoveStringLiteralDfa14_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'd':
-         return jjMoveStringLiteralDfa15_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x1000000000000000L, active2, 0x10000L);
       case 's':
-         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0x2800L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0x5000L);
       default :
          break;
    }
@@ -1103,11 +1105,11 @@ private int jjMoveStringLiteralDfa15_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa16_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x1000000000000000L, active2, 0x10000L);
       case 'i':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x1000L);
       case 's':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x4000L);
       default :
          break;
    }
@@ -1124,11 +1126,11 @@ private int jjMoveStringLiteralDfa16_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x1000L);
       case 'i':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x4000L);
       case 's':
-         return jjMoveStringLiteralDfa17_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x1000000000000000L, active2, 0x10000L);
       default :
          break;
    }
@@ -1145,12 +1147,12 @@ private int jjMoveStringLiteralDfa17_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x4000L);
       case 'h':
-         return jjMoveStringLiteralDfa18_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x1000000000000000L, active2, 0x10000L);
       case 'n':
-         if ((active2 & 0x800L) != 0x0L)
-            return jjStopAtPos(17, 139);
+         if ((active2 & 0x1000L) != 0x0L)
+            return jjStopAtPos(17, 140);
          break;
       default :
          break;
@@ -1168,10 +1170,10 @@ private int jjMoveStringLiteralDfa18_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa19_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa19_0(active1, 0x1000000000000000L, active2, 0x10000L);
       case 'n':
-         if ((active2 & 0x2000L) != 0x0L)
-            return jjStopAtPos(18, 141);
+         if ((active2 & 0x4000L) != 0x0L)
+            return jjStopAtPos(18, 142);
          break;
       default :
          break;
@@ -1189,7 +1191,7 @@ private int jjMoveStringLiteralDfa19_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'f':
-         return jjMoveStringLiteralDfa20_0(active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa20_0(active1, 0x1000000000000000L, active2, 0x10000L);
       default :
          break;
    }
@@ -1206,12 +1208,12 @@ private int jjMoveStringLiteralDfa20_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 't':
-         if ((active1 & 0x800000000000000L) != 0x0L)
+         if ((active1 & 0x1000000000000000L) != 0x0L)
          {
-            jjmatchedKind = 123;
+            jjmatchedKind = 124;
             jjmatchedPos = 20;
          }
-         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x10000L);
       default :
          break;
    }
@@ -1228,7 +1230,7 @@ private int jjMoveStringLiteralDfa21_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa22_0(active2, 0x8000L);
+         return jjMoveStringLiteralDfa22_0(active2, 0x10000L);
       default :
          break;
    }
@@ -1245,7 +1247,7 @@ private int jjMoveStringLiteralDfa22_0(long old2, long active2){
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa23_0(active2, 0x8000L);
+         return jjMoveStringLiteralDfa23_0(active2, 0x10000L);
       default :
          break;
    }
@@ -1262,7 +1264,7 @@ private int jjMoveStringLiteralDfa23_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa24_0(active2, 0x8000L);
+         return jjMoveStringLiteralDfa24_0(active2, 0x10000L);
       default :
          break;
    }
@@ -1279,7 +1281,7 @@ private int jjMoveStringLiteralDfa24_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa25_0(active2, 0x8000L);
+         return jjMoveStringLiteralDfa25_0(active2, 0x10000L);
       default :
          break;
    }
@@ -1296,7 +1298,7 @@ private int jjMoveStringLiteralDfa25_0(long old2, long active2){
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa26_0(active2, 0x8000L);
+         return jjMoveStringLiteralDfa26_0(active2, 0x10000L);
       default :
          break;
    }
@@ -1313,7 +1315,7 @@ private int jjMoveStringLiteralDfa26_0(long old2, long active2){
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa27_0(active2, 0x8000L);
+         return jjMoveStringLiteralDfa27_0(active2, 0x10000L);
       default :
          break;
    }
@@ -1330,8 +1332,8 @@ private int jjMoveStringLiteralDfa27_0(long old2, long active2){
    switch(curChar)
    {
       case 'n':
-         if ((active2 & 0x8000L) != 0x0L)
-            return jjStopAtPos(27, 143);
+         if ((active2 & 0x10000L) != 0x0L)
+            return jjStopAtPos(27, 144);
          break;
       default :
          break;
@@ -1425,8 +1427,8 @@ else if (curChar == 47)
                      { jjAddStates(13, 14); }
                   else if (curChar == 36)
                   {
-                     if (kind > 73)
-                        kind = 73;
+                     if (kind > 74)
+                        kind = 74;
                      { jjCheckNAdd(42); }
                   }
                   else if (curChar == 34)
@@ -1441,14 +1443,14 @@ else if (curChar == 60)
                      { jjCheckNAddStates(0, 3); }
                   if ((0x3fe000000000000L & l) != 0x0L)
                   {
-                     if (kind > 62)
-                        kind = 62;
+                     if (kind > 63)
+                        kind = 63;
                      { jjCheckNAddTwoStates(15, 16); }
                   }
                   else if (curChar == 48)
                   {
-                     if (kind > 62)
-                        kind = 62;
+                     if (kind > 63)
+                        kind = 63;
                      { jjCheckNAddStates(18, 21); }
                   }
                   else if (curChar == 34)
@@ -1515,15 +1517,15 @@ else if (curChar == 34)
                case 14:
                   if ((0x3fe000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 15:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 17:
@@ -1533,8 +1535,8 @@ else if (curChar == 34)
                case 18:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 67)
-                     kind = 67;
+                  if (kind > 68)
+                     kind = 68;
                   { jjCheckNAddStates(28, 30); }
                   break;
                case 20:
@@ -1544,8 +1546,8 @@ else if (curChar == 34)
                case 21:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 67)
-                     kind = 67;
+                  if (kind > 68)
+                     kind = 68;
                   { jjCheckNAddTwoStates(21, 22); }
                   break;
                case 23:
@@ -1560,8 +1562,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(15, 17); }
                   break;
                case 27:
-                  if (curChar == 39 && kind > 70)
-                     kind = 70;
+                  if (curChar == 39 && kind > 71)
+                     kind = 71;
                   break;
                case 28:
                   if (curChar == 34)
@@ -1575,8 +1577,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(22, 24); }
                   break;
                case 32:
-                  if (curChar == 34 && kind > 71)
-                     kind = 71;
+                  if (curChar == 34 && kind > 72)
+                     kind = 72;
                   break;
                case 33:
                case 35:
@@ -1588,8 +1590,8 @@ else if (curChar == 34)
                      { jjCheckNAddStates(31, 33); }
                   break;
                case 36:
-                  if (curChar == 34 && kind > 72)
-                     kind = 72;
+                  if (curChar == 34 && kind > 73)
+                     kind = 73;
                   break;
                case 37:
                   if (curChar == 34)
@@ -1610,15 +1612,15 @@ else if (curChar == 34)
                case 41:
                   if (curChar != 36)
                      break;
-                  if (kind > 73)
-                     kind = 73;
+                  if (kind > 74)
+                     kind = 74;
                   { jjCheckNAdd(42); }
                   break;
                case 42:
                   if ((0x3ff001000000000L & l) == 0x0L)
                      break;
-                  if (kind > 73)
-                     kind = 73;
+                  if (kind > 74)
+                     kind = 74;
                   { jjCheckNAdd(42); }
                   break;
                case 43:
@@ -1632,15 +1634,15 @@ else if (curChar == 34)
                case 45:
                   if (curChar != 46)
                      break;
-                  if (kind > 67)
-                     kind = 67;
+                  if (kind > 68)
+                     kind = 68;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 46:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 67)
-                     kind = 67;
+                  if (kind > 68)
+                     kind = 68;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 48:
@@ -1650,8 +1652,8 @@ else if (curChar == 34)
                case 49:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 67)
-                     kind = 67;
+                  if (kind > 68)
+                     kind = 68;
                   { jjCheckNAddTwoStates(49, 22); }
                   break;
                case 50:
@@ -1665,8 +1667,8 @@ else if (curChar == 34)
                case 53:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 67)
-                     kind = 67;
+                  if (kind > 68)
+                     kind = 68;
                   { jjCheckNAddTwoStates(53, 22); }
                   break;
                case 54:
@@ -1676,36 +1678,36 @@ else if (curChar == 34)
                case 56:
                   if (curChar != 48)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddStates(18, 21); }
                   break;
                case 58:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 60:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 61:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAdd(16); }
                   break;
                case 62:
                   if ((0xff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddTwoStates(62, 16); }
                   break;
                case 63:
@@ -1775,8 +1777,8 @@ else if (curChar < 128)
                case 42:
                   if ((0x7fffffe87fffffeL & l) == 0x0L)
                      break;
-                  if (kind > 73)
-                     kind = 73;
+                  if (kind > 74)
+                     kind = 74;
                   { jjCheckNAdd(42); }
                   break;
                case 9:
@@ -1785,21 +1787,21 @@ else if (curChar < 128)
                case 15:
                   if (curChar != 95)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 16:
-                  if ((0x88920000889200L & l) != 0x0L && kind > 62)
-                     kind = 62;
+                  if ((0x88920000889200L & l) != 0x0L && kind > 63)
+                     kind = 63;
                   break;
                case 19:
                   if ((0x2000000020L & l) != 0x0L)
                      { jjAddStates(43, 44); }
                   break;
                case 22:
-                  if ((0x80005000800050L & l) != 0x0L && kind > 67)
-                     kind = 67;
+                  if ((0x80005000800050L & l) != 0x0L && kind > 68)
+                     kind = 68;
                   break;
                case 24:
                   if ((0xffffffffefffffffL & l) != 0x0L)
@@ -1835,8 +1837,8 @@ else if (curChar < 128)
                      { jjAddStates(47, 48); }
                   break;
                case 55:
-                  if ((0x5000000050L & l) != 0x0L && kind > 67)
-                     kind = 67;
+                  if ((0x5000000050L & l) != 0x0L && kind > 68)
+                     kind = 68;
                   break;
                case 57:
                   if ((0x100000001000000L & l) != 0x0L)
@@ -1845,22 +1847,22 @@ else if (curChar < 128)
                case 58:
                   if ((0x7e8000007eL & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 59:
                   if ((0x400000004L & l) == 0x0L)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 60:
                   if (curChar != 95)
                      break;
-                  if (kind > 62)
-                     kind = 62;
+                  if (kind > 63)
+                     kind = 63;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 65:
@@ -1904,8 +1906,8 @@ else if (curChar < 128)
                   }
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
                   {
-                     if (kind > 73)
-                        kind = 73;
+                     if (kind > 74)
+                        kind = 74;
                      { jjCheckNAdd(42); }
                   }
                   break;
@@ -1938,8 +1940,8 @@ else if (curChar < 128)
                case 42:
                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
                      break;
-                  if (kind > 73)
-                     kind = 73;
+                  if (kind > 74)
+                     kind = 74;
                   { jjCheckNAdd(42); }
                   break;
                case 65:
@@ -1988,21 +1990,21 @@ else if (curChar < 128)
 "\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\163", "\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\167\151\164\143\150", 
-"\163\171\156\143\150\162\157\156\151\172\145\144", "\164\162\141\156\163\151\145\156\164", "\164\150\162\157\167", 
-"\164\150\162\157\167\163", "\164\162\165\145", "\164\162\171", "\166\157\151\144", 
-"\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, 
-null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", 
-"\54", "\56", "\75", "\76", "\100\147\164", "\74", "\100\154\164", "\41", "\176", 
-"\75\75", "\74\75", "\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75", 
-"\174\174", "\100\157\162", "\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53", "\55", 
-"\52", "\57", "\46", "\100\142\151\164\167\151\163\145\137\141\156\144", "\174", 
-"\100\142\151\164\167\151\163\145\137\157\162", "\136", "\100\142\151\164\167\151\163\145\137\170\157\162", "\45", 
-"\100\155\157\144", "\52\52", "\100\160\157\167", "\74\74", 
+"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\163", "\141\163", 
+"\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\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", 
+"\164\162\141\156\163\151\145\156\164", "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\165\145", 
+"\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+"\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", 
+"\100\147\164", "\74", "\100\154\164", "\41", "\176", "\75\75", "\74\75", 
+"\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75", "\174\174", "\100\157\162", 
+"\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", 
+"\100\142\151\164\167\151\163\145\137\141\156\144", "\174", "\100\142\151\164\167\151\163\145\137\157\162", "\136", 
+"\100\142\151\164\167\151\163\145\137\170\157\162", "\45", "\100\155\157\144", "\52\52", "\100\160\157\167", "\74\74", 
 "\100\154\145\146\164\137\163\150\151\146\164", "\76\76", "\100\162\151\147\150\164\137\163\150\151\146\164", "\76\76\76", 
 "\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", 
 "\100\141\156\144\137\141\163\163\151\147\156", "\174\75", "\100\157\162\137\141\163\163\151\147\156", "\136\75", 
@@ -2286,10 +2288,10 @@ public void SwitchTo(int lexState)
    -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 = {
-   0x7ffffffffffff801L, 0xfffffffffffff3c8L, 0x7ffffffL, 
+   0xfffffffffffff801L, 0xffffffffffffe790L, 0xfffffffL, 
 };
 static final long[] jjtoSkip = {
    0x7feL, 0x0L, 0x0L, 
diff --git a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
index 23b758f..57960a9 100644
--- a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
+++ b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
@@ -445,6 +445,7 @@ TOKEN : /* RESERVED WORDS AND LITERALS */
 | < IMPORT: "import" >
 | < INSTANCEOF: "instanceof" >
 | < IS: "is" >
+| < AS: "as" >
 | < INT: "int" >
 | < INTERFACE: "interface" >
 | < LONG: "long" >
@@ -985,11 +986,16 @@ void EqualityExpression() :
 }
 
 void InstanceOfExpression() :
-{}
+{ Token t = null; }
 {
   RelationalExpression()
-  [(<INSTANCEOF> | <IS>) Type()
-    { jjtThis.kind = INSTANCEOF; } #BinaryExpression(2) ]
+  [
+    (t = <INSTANCEOF> | t = <IS>) Type()
+      { jjtThis.kind = t.kind; } #BinaryExpression(2)
+  |
+    t = <AS> Type()
+      { jjtThis.kind = t.kind; } #BinaryExpression(2)
+  ]
 }
 
 void RelationalExpression() :

From c27afa12d62ec141c5418618d88010443f78ce11 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 23 Apr 2026 14:15:08 +0800
Subject: [PATCH 06/27] fix: stop default-args over-backtracking

//"{}"
void hi(String name, int age = 18) {
    print("name: $name, age: $age")
}
hi("user")
---
 .../bsh/preprocess/DefaultArgsDesugar.java    | 111 ++++++++++++++++--
 1 file changed, 98 insertions(+), 13 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/DefaultArgsDesugar.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/DefaultArgsDesugar.java
index c920adf..26960c7 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/DefaultArgsDesugar.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/DefaultArgsDesugar.java
@@ -134,9 +134,8 @@ private static MethodShape tryParseMethodShape(String source, int openParen) {
             return null;
         }
 
-        int bodyStart = skipThrowsClause(source, next);
-        bodyStart = skipWsAndCommentsForward(source, bodyStart);
-        if (bodyStart >= source.length() || source.charAt(bodyStart) != '{') {
+        int bodyStart = findMethodBodyStart(source, closeParen + 1);
+        if (bodyStart < 0) {
             return null;
         }
 
@@ -170,8 +169,10 @@ private static MethodRewrite tryRewriteMethod(
         int declStart = shape.declStart;
         int closeParen = findMatching(source, openParen, '(', ')');
         String prefix = source.substring(declStart, openParen);
-        int next = skipWsAndCommentsForward(source, closeParen + 1);
-        int bodyStart = skipWsAndCommentsForward(source, skipThrowsClause(source, next));
+        int bodyStart = findMethodBodyStart(source, closeParen + 1);
+        if (bodyStart < 0) {
+            return null;
+        }
         String betweenParenAndBody = source.substring(closeParen + 1, bodyStart);
         int bodyEnd = findMatching(source, bodyStart, '{', '}');
         String body = source.substring(bodyStart, bodyEnd + 1);
@@ -542,11 +543,50 @@ private static int findDeclarationStart(String source, int methodNameStart) {
             if (ch == ';' || ch == '{' || ch == '}') {
                 break;
             }
+            if (ch == '\n' || ch == '\r') {
+                int lineStart = i;
+                while (lineStart > 0) {
+                    char c = source.charAt(lineStart - 1);
+                    if (c == '\n' || c == '\r') {
+                        break;
+                    }
+                    lineStart--;
+                }
+
+                String line = source.substring(lineStart, i).trim();
+                if (line.isEmpty()) {
+                    break;
+                }
+                if (line.startsWith("@") || isModifierOnlyLine(line)) {
+                    i--;
+                    continue;
+                }
+                break;
+            }
             i--;
         }
         return i;
     }
 
+    private static boolean isModifierOnlyLine(String line) {
+        if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) {
+            return false;
+        }
+        String[] tokens = line.split("\\s+");
+        if (tokens.length == 0) {
+            return false;
+        }
+        for (String token : tokens) {
+            if (token.isEmpty()) {
+                continue;
+            }
+            if (!METHOD_MODIFIERS.contains(token)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     private static int skipThrowsClause(String source, int index) {
         int i = skipWsAndCommentsForward(source, index);
         if (!startsWithWord(source, i, "throws")) {
@@ -555,19 +595,64 @@ private static int skipThrowsClause(String source, int index) {
 
         i += "throws".length();
         int len = source.length();
+        boolean needType = true;
         while (i < len) {
-            int skip = skipLiteralOrComment(source, i);
-            if (skip > i) {
-                i = skip;
-                continue;
+            i = skipWsAndCommentsForward(source, i);
+            if (i >= len) {
+                return -1;
             }
+
             char ch = source.charAt(i);
-            if (ch == '{' || ch == ';') {
-                return i;
+            if (ch == '{') {
+                return needType ? -1 : i;
             }
-            i++;
+            if (ch == ';') {
+                return -1;
+            }
+
+            if (needType) {
+                if (!Character.isJavaIdentifierStart(ch)) {
+                    return -1;
+                }
+                i++;
+                while (i < len) {
+                    char c = source.charAt(i);
+                    if (Character.isJavaIdentifierPart(c) || c == '.' || c == '$') {
+                        i++;
+                        continue;
+                    }
+                    break;
+                }
+                needType = false;
+                continue;
+            }
+
+            if (ch == ',') {
+                needType = true;
+                i++;
+                continue;
+            }
+            return -1;
         }
-        return i;
+        return -1;
+    }
+
+    private static int findMethodBodyStart(String source, int afterCloseParen) {
+        int next = skipWsAndCommentsForward(source, afterCloseParen);
+        if (next >= source.length()) {
+            return -1;
+        }
+        if (startsWithWord(source, next, "throws")) {
+            int afterThrows = skipThrowsClause(source, next);
+            if (afterThrows < 0) {
+                return -1;
+            }
+            next = skipWsAndCommentsForward(source, afterThrows);
+        }
+        if (next < source.length() && source.charAt(next) == '{') {
+            return next;
+        }
+        return -1;
     }
 
     private static boolean startsWithWord(String source, int index, String word) {

From f3ff807223b92e3e892043fb52b33db4c3a85b97 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 23 Apr 2026 15:02:11 +0800
Subject: [PATCH 07/27] feat: introduce when/else branch expression

---
 README.md                                     |   28 +-
 .../src/main/java/bsh/BSHWhenEntry.java       |   51 +
 .../src/main/java/bsh/BSHWhenExpression.java  |  102 +
 .../src/main/java/bsh/Parser.java             | 2586 +++++++++--------
 .../src/main/java/bsh/ParserConstants.java    |  187 +-
 .../src/main/java/bsh/ParserTokenManager.java |  678 ++---
 .../main/java/bsh/ParserTreeConstants.java    |   46 +-
 .../src/main/jjtree/bsh.jjt                   |   20 +
 8 files changed, 2083 insertions(+), 1615 deletions(-)
 create mode 100644 bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenEntry.java
 create mode 100644 bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenExpression.java

diff --git a/README.md b/README.md
index 968425d..2a4f6cd 100644
--- a/README.md
+++ b/README.md
@@ -104,8 +104,10 @@ val name = "BeanShell"
 var lang = "BeanShell"
 var str1 = "Hello, $lang"
 print(str1) // "Hello, BeanShell"
+// 表达式
 var str2 = "1 + 2 = ${1 + 2}"
-print(str2)  // "1 + 2 = 3"
+print(str2) // "1 + 2 = 3"
+// 转义
 var str3 = "price=\$9"
 print(str3) // "price=$9"
 
@@ -118,11 +120,31 @@ hi("user", 1) // name: user, age: 1
 
 // 类型判断
 print(123 is Number) // true
-// 等价: print(123 instanceof Number) // true
+// 等价
+print(123 instanceof Number) // true
 
 // 类型转换
 print("1" as int) // 1
-// 等价: print((int) "1") // 1
+// 等价
+print((int) "1") // 1
+
+// 条件分支
+var num = 2
+var out1 = when (num) {
+    1 -> "one"
+    2, 3 -> "small"
+    else -> "other"
+}
+print(out1) // "small"
+// 等价
+var out2
+switch (num) {
+    case 1: out2 = "one"; break;
+    case 2:
+    case 3: out2 = "small"; break;
+    default: out2 = "other";
+}
+print(out2) // "small"
 ```
 
 ## 致谢
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenEntry.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenEntry.java
new file mode 100644
index 0000000..c79ee68
--- /dev/null
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenEntry.java
@@ -0,0 +1,51 @@
+/*****************************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one                *
+ * or more contributor license agreements.  See the NOTICE file              *
+ * distributed with this work for additional information                     *
+ * regarding copyright ownership.  The ASF licenses this file                *
+ * to you 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.                                                        *
+ *                                                                           *
+ *                                                                           *
+ * This file is part of the BeanShell Java Scripting distribution.           *
+ * Documentation and updates may be found at http://www.beanshell.org/       *
+ * Patrick Niemeyer (pat@pat.net)                                            *
+ * Author of Learning Java, O'Reilly & Associates                            *
+ *                                                                           *
+ *****************************************************************************/
+package bsh;
+
+class BSHWhenEntry extends SimpleNode
+{
+    boolean isElse;
+    int numConditions;
+
+    BSHWhenEntry(int id) { super(id); }
+
+    public Object eval(
+        CallStack callstack, Interpreter interpreter ) throws EvalError
+    {
+        return evalResult(callstack, interpreter);
+    }
+
+    Object evalResult(
+        CallStack callstack, Interpreter interpreter ) throws EvalError
+    {
+        return jjtGetChild(numConditions).eval(callstack, interpreter);
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + ": " + (isElse ? "else" : "case");
+    }
+}
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenExpression.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenExpression.java
new file mode 100644
index 0000000..83163db
--- /dev/null
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHWhenExpression.java
@@ -0,0 +1,102 @@
+/*****************************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one                *
+ * or more contributor license agreements.  See the NOTICE file              *
+ * distributed with this work for additional information                     *
+ * regarding copyright ownership.  The ASF licenses this file                *
+ * to you 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.                                                        *
+ *                                                                           *
+ *                                                                           *
+ * This file is part of the BeanShell Java Scripting distribution.           *
+ * Documentation and updates may be found at http://www.beanshell.org/       *
+ * Patrick Niemeyer (pat@pat.net)                                            *
+ * Author of Learning Java, O'Reilly & Associates                            *
+ *                                                                           *
+ *****************************************************************************/
+package bsh;
+
+class BSHWhenExpression extends SimpleNode implements ParserConstants
+{
+
+    BSHWhenExpression(int id) { super(id); }
+
+    public Object eval( CallStack callstack, Interpreter interpreter )
+        throws EvalError
+    {
+        int numChildren = jjtGetNumChildren();
+        if ( numChildren < 2 )
+            throw new EvalException("Empty when expression.", this, callstack);
+
+        for ( int i = 1; i < numChildren; i++ ) {
+            BSHWhenEntry entry = (BSHWhenEntry) jjtGetChild(i);
+            if ( !entry.isElse )
+                continue;
+            if ( i != numChildren - 1 )
+                throw new EvalException(
+                    "Else branch must be the last one in when expression.",
+                    this, callstack );
+        }
+
+        Node whenExp = jjtGetChild(0);
+        Object whenVal = whenExp.eval(callstack, interpreter);
+
+        for ( int i = 1; i < numChildren; i++ ) {
+            BSHWhenEntry entry = (BSHWhenEntry) jjtGetChild(i);
+            if ( entry.isElse )
+                return entry.evalResult(callstack, interpreter);
+
+            for ( int c = 0; c < entry.numConditions; c++ ) {
+                Object targetVal = entry.jjtGetChild(c).eval(callstack, interpreter);
+                if ( primitiveEquals(whenVal, targetVal, callstack, whenExp) )
+                    return entry.evalResult(callstack, interpreter);
+            }
+        }
+
+        throw new EvalException("No matching when branch.", this, callstack);
+    }
+
+    private boolean primitiveEquals(
+        Object whenVal, Object targetVal,
+        CallStack callstack, Node whenExp )
+        throws EvalError
+    {
+        if ( whenVal == Primitive.VOID || targetVal == Primitive.VOID )
+            return false;
+
+        if ( whenVal == Primitive.NULL )
+            whenVal = null;
+        if ( targetVal == Primitive.NULL )
+            targetVal = null;
+
+        if ( whenVal == null || targetVal == null )
+            return whenVal == targetVal;
+
+        if ( whenVal instanceof Primitive || targetVal instanceof Primitive )
+            try {
+                Object result = Operators.binaryOperation(
+                    whenVal, targetVal, ParserConstants.EQ );
+                result = Primitive.unwrap( result );
+                return result.equals( Boolean.TRUE );
+            } catch ( UtilEvalError e ) {
+                throw e.toEvalError(
+                    "When value: " + whenExp.getText() + ": ",
+                    this, callstack );
+            }
+        return whenVal.equals( targetVal );
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + ": when";
+    }
+}
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
index d3f9ef2..9bcfba5 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
@@ -949,6 +949,7 @@ final public void VariableInitializer() throws ParseException {
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -996,6 +997,7 @@ final public void ArrayInitializer() throws ParseException {/*@bgen(jjtree) Arra
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -2550,6 +2552,7 @@ final public void ConditionalExpression() throws ParseException {
         case SHORT:
         case TRUE:
         case VOID:
+        case WHEN:
         case INTEGER_LITERAL:
         case FLOATING_POINT_LITERAL:
         case CHARACTER_LITERAL:
@@ -2758,6 +2761,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -2810,6 +2814,181 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
     }
 }
 
+  final public void WhenExpression() throws ParseException {/*@bgen(jjtree) WhenExpression */
+  BSHWhenExpression jjtn000 = new BSHWhenExpression(JJTWHENEXPRESSION);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+  jjtreeOpenNodeScope(jjtn000);
+    try {
+      jj_consume_token(WHEN);
+      jj_consume_token(LPAREN);
+      Expression();
+      jj_consume_token(RPAREN);
+      jj_consume_token(LBRACE);
+      label_24:
+      while (true) {
+        WhenEntry();
+        switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
+        case BOOLEAN:
+        case BYTE:
+        case CHAR:
+        case DOUBLE:
+        case ELSE:
+        case FALSE:
+        case FLOAT:
+        case INT:
+        case LONG:
+        case NEW:
+        case NULL:
+        case SHORT:
+        case TRUE:
+        case VOID:
+        case WHEN:
+        case INTEGER_LITERAL:
+        case FLOATING_POINT_LITERAL:
+        case CHARACTER_LITERAL:
+        case STRING_LITERAL:
+        case LONG_STRING_LITERAL:
+        case IDENTIFIER:
+        case LPAREN:
+        case LBRACE:
+        case LBRACKET:
+        case BANG:
+        case TILDE:
+        case INCR:
+        case DECR:
+        case PLUS:
+        case MINUS:{
+          break;
+          }
+        default:
+          jj_la1[72] = jj_gen;
+          break label_24;
+        }
+      }
+      jj_consume_token(RBRACE);
+    } catch (Throwable jjte000) {
+if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof ParseException) {
+      throw (ParseException)jjte000;
+    }
+    if (jjte000 instanceof RuntimeException) {
+      throw (RuntimeException)jjte000;
+    }
+    throw (Error)jjte000;
+    } finally {
+if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+      if (jjtree.nodeCreated()) {
+       jjtreeCloseNodeScope(jjtn000);
+      }
+    }
+    }
+}
+
+  final public void WhenEntry() throws ParseException {/*@bgen(jjtree) WhenEntry */
+  BSHWhenEntry jjtn000 = new BSHWhenEntry(JJTWHENENTRY);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+  jjtreeOpenNodeScope(jjtn000);int count = 0;
+    try {
+      switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
+      case ELSE:{
+        jj_consume_token(ELSE);
+jjtn000.isElse = true;
+        jj_consume_token(ARROW);
+        Expression();
+        break;
+        }
+      case BOOLEAN:
+      case BYTE:
+      case CHAR:
+      case DOUBLE:
+      case FALSE:
+      case FLOAT:
+      case INT:
+      case LONG:
+      case NEW:
+      case NULL:
+      case SHORT:
+      case TRUE:
+      case VOID:
+      case WHEN:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case CHARACTER_LITERAL:
+      case STRING_LITERAL:
+      case LONG_STRING_LITERAL:
+      case IDENTIFIER:
+      case LPAREN:
+      case LBRACE:
+      case LBRACKET:
+      case BANG:
+      case TILDE:
+      case INCR:
+      case DECR:
+      case PLUS:
+      case MINUS:{
+        Expression();
+count = 1;
+        label_25:
+        while (true) {
+          switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
+          case COMMA:{
+            break;
+            }
+          default:
+            jj_la1[73] = jj_gen;
+            break label_25;
+          }
+          jj_consume_token(COMMA);
+          Expression();
+count++;
+        }
+        jj_consume_token(ARROW);
+        Expression();
+jjtree.closeNodeScope(jjtn000, true);
+                      jjtc000 = false;
+                      if (jjtree.nodeCreated()) {
+                       jjtreeCloseNodeScope(jjtn000);
+                      }
+jjtn000.numConditions = count;
+        break;
+        }
+      default:
+        jj_la1[74] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } catch (Throwable jjte000) {
+if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof ParseException) {
+      throw (ParseException)jjte000;
+    }
+    if (jjte000 instanceof RuntimeException) {
+      throw (RuntimeException)jjte000;
+    }
+    throw (Error)jjte000;
+    } finally {
+if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+      if (jjtree.nodeCreated()) {
+       jjtreeCloseNodeScope(jjtn000);
+      }
+    }
+    }
+}
+
   final public void PrimaryPrefix() throws ParseException {
     switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
     case FALSE:
@@ -2830,6 +3009,10 @@ final public void PrimaryPrefix() throws ParseException {
       jj_consume_token(RPAREN);
       break;
       }
+    case WHEN:{
+      WhenExpression();
+      break;
+      }
     case NEW:
     case LBRACE:
     case LBRACKET:{
@@ -2837,7 +3020,7 @@ final public void PrimaryPrefix() throws ParseException {
       break;
       }
     default:
-      jj_la1[72] = jj_gen;
+      jj_la1[75] = jj_gen;
       if (jj_2_13(2147483647)) {
         MethodInvocation();
       } else if (jj_2_14(2147483647)) {
@@ -2849,7 +3032,7 @@ final public void PrimaryPrefix() throws ParseException {
           break;
           }
         default:
-          jj_la1[73] = jj_gen;
+          jj_la1[76] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2890,6 +3073,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
           case SHORT:
           case TRUE:
           case VOID:
+          case WHEN:
           case INTEGER_LITERAL:
           case FLOATING_POINT_LITERAL:
           case CHARACTER_LITERAL:
@@ -2910,7 +3094,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
             break;
             }
           default:
-            jj_la1[74] = jj_gen;
+            jj_la1[77] = jj_gen;
             ;
           }
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2933,6 +3117,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               case SHORT:
               case TRUE:
               case VOID:
+              case WHEN:
               case INTEGER_LITERAL:
               case FLOATING_POINT_LITERAL:
               case CHARACTER_LITERAL:
@@ -2952,7 +3137,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[75] = jj_gen;
+                jj_la1[78] = jj_gen;
                 ;
               }
 jjtn000.slice = true; jjtn000.step = true;
@@ -2975,6 +3160,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               case SHORT:
               case TRUE:
               case VOID:
+              case WHEN:
               case INTEGER_LITERAL:
               case FLOATING_POINT_LITERAL:
               case CHARACTER_LITERAL:
@@ -2995,7 +3181,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[76] = jj_gen;
+                jj_la1[79] = jj_gen;
                 ;
               }
               switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3016,6 +3202,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 case SHORT:
                 case TRUE:
                 case VOID:
+                case WHEN:
                 case INTEGER_LITERAL:
                 case FLOATING_POINT_LITERAL:
                 case CHARACTER_LITERAL:
@@ -3035,26 +3222,26 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                   break;
                   }
                 default:
-                  jj_la1[77] = jj_gen;
+                  jj_la1[80] = jj_gen;
                   ;
                 }
                 break;
                 }
               default:
-                jj_la1[78] = jj_gen;
+                jj_la1[81] = jj_gen;
                 ;
               }
               break;
               }
             default:
-              jj_la1[79] = jj_gen;
+              jj_la1[82] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
             break;
             }
           default:
-            jj_la1[80] = jj_gen;
+            jj_la1[83] = jj_gen;
             ;
           }
           jj_consume_token(RBRACKET);
@@ -3067,7 +3254,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
           break;
           }
         default:
-          jj_la1[84] = jj_gen;
+          jj_la1[87] = jj_gen;
           if (getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET) {
             jj_consume_token(COLON_COLON);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3080,7 +3267,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[81] = jj_gen;
+              jj_la1[84] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -3092,7 +3279,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
 jjtn000.operation = BSHPrimarySuffix.METHODREF;
     jjtn000.field = t.image;
           } else if (jj_2_16(2)) {
-            jj_consume_token(154);
+            jj_consume_token(155);
             t = jj_consume_token(IDENTIFIER);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
             case LPAREN:{
@@ -3100,7 +3287,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[82] = jj_gen;
+              jj_la1[85] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3120,7 +3307,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[83] = jj_gen;
+              jj_la1[86] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3145,7 +3332,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[85] = jj_gen;
+              jj_la1[88] = jj_gen;
               if (jj_2_18(2)) {
                 jj_consume_token(DOT);
                 AllocationExpression();
@@ -3314,7 +3501,7 @@ final public void Literal() throws ParseException {/*@bgen(jjtree) Literal */
         break;
         }
       default:
-        jj_la1[86] = jj_gen;
+        jj_la1[89] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3355,7 +3542,7 @@ final public boolean BooleanLiteral() throws ParseException {
       break;
       }
     default:
-      jj_la1[87] = jj_gen;
+      jj_la1[90] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
@@ -3391,6 +3578,7 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -3410,7 +3598,7 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
         break;
         }
       default:
-        jj_la1[88] = jj_gen;
+        jj_la1[91] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -3441,15 +3629,15 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
 // leave these on the stack for Arguments() to handle
   final public void ArgumentList() throws ParseException {
     Expression();
-    label_24:
+    label_26:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case COMMA:{
         break;
         }
       default:
-        jj_la1[89] = jj_gen;
-        break label_24;
+        jj_la1[92] = jj_gen;
+        break label_26;
       }
       jj_consume_token(COMMA);
       Expression();
@@ -3496,7 +3684,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[90] = jj_gen;
+            jj_la1[93] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3508,7 +3696,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[91] = jj_gen;
+          jj_la1[94] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3520,7 +3708,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[92] = jj_gen;
+        jj_la1[95] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3555,7 +3743,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
   jjtreeOpenNodeScope(jjtn000);
     try {
       if (jj_2_22(2)) {
-        label_25:
+        label_27:
         while (true) {
           jj_consume_token(LBRACKET);
           Expression();
@@ -3563,14 +3751,14 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
 jjtn000.addDefinedDimension();
           if (jj_2_20(2)) {
           } else {
-            break label_25;
+            break label_27;
           }
         }
-        label_26:
+        label_28:
         while (true) {
           if (jj_2_21(2)) {
           } else {
-            break label_26;
+            break label_28;
           }
           jj_consume_token(LBRACKET);
           jj_consume_token(RBRACKET);
@@ -3579,7 +3767,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
       } else {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case LBRACKET:{
-          label_27:
+          label_29:
           while (true) {
             jj_consume_token(LBRACKET);
             jj_consume_token(RBRACKET);
@@ -3589,8 +3777,8 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
               break;
               }
             default:
-              jj_la1[93] = jj_gen;
-              break label_27;
+              jj_la1[96] = jj_gen;
+              break label_29;
             }
           }
           ArrayInitializer();
@@ -3607,7 +3795,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
           break;
           }
         default:
-          jj_la1[94] = jj_gen;
+          jj_la1[97] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3664,6 +3852,7 @@ void Statement() throws ParseException {
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -3700,7 +3889,7 @@ void Statement() throws ParseException {
         break;
         }
       default:
-        jj_la1[95] = jj_gen;
+        jj_la1[98] = jj_gen;
         if (isRegularForStatement()) {
           ForStatement();
         } else {
@@ -3734,7 +3923,7 @@ void Statement() throws ParseException {
             break;
             }
           default:
-            jj_la1[96] = jj_gen;
+            jj_la1[99] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3794,15 +3983,15 @@ final public void Block() throws ParseException {/*@bgen(jjtree) Block */
         break;
         }
       default:
-        jj_la1[97] = jj_gen;
+        jj_la1[100] = jj_gen;
         ;
       }
       jj_consume_token(LBRACE);
-      label_28:
+      label_30:
       while (true) {
         if (jj_2_25(1)) {
         } else {
-          break label_28;
+          break label_30;
         }
         BlockStatement();
       }
@@ -3860,7 +4049,7 @@ final public void BlockStatement() throws ParseException {
         break;
         }
       default:
-        jj_la1[98] = jj_gen;
+        jj_la1[101] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3878,7 +4067,7 @@ final public void MethodDeclTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[99] = jj_gen;
+      jj_la1[102] = jj_gen;
       if (isImplicitMethodTerminator()) {
 
       } else {
@@ -3895,7 +4084,7 @@ final public void StatementTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[100] = jj_gen;
+      jj_la1[103] = jj_gen;
       ;
     }
 }
@@ -3915,23 +4104,23 @@ final public void SwitchStatement() throws ParseException {/*@bgen(jjtree) Switc
       Expression();
       jj_consume_token(RPAREN);
       jj_consume_token(LBRACE);
-      label_29:
+      label_31:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CASE:
-        case 155:{
+        case 156:{
           break;
           }
         default:
-          jj_la1[101] = jj_gen;
-          break label_29;
+          jj_la1[104] = jj_gen;
+          break label_31;
         }
         SwitchLabel();
-        label_30:
+        label_32:
         while (true) {
           if (jj_2_31(1)) {
           } else {
-            break label_30;
+            break label_32;
           }
           BlockStatement();
         }
@@ -3974,8 +4163,8 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         jj_consume_token(COLON);
         break;
         }
-      case 155:{
-        jj_consume_token(155);
+      case 156:{
+        jj_consume_token(156);
 jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                if (jjtree.nodeCreated()) {
@@ -3985,7 +4174,7 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         break;
         }
       default:
-        jj_la1[102] = jj_gen;
+        jj_la1[105] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4030,7 +4219,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[103] = jj_gen;
+        jj_la1[106] = jj_gen;
         if (jj_2_32(1)) {
           Statement();
         } else {
@@ -4045,7 +4234,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[104] = jj_gen;
+        jj_la1[107] = jj_gen;
         ;
       }
     } catch (Throwable jjte000) {
@@ -4188,6 +4377,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
       case TRUE:
       case VOID:
       case VOLATILE:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -4208,7 +4398,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[105] = jj_gen;
+        jj_la1[108] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4226,6 +4416,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -4246,7 +4437,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[106] = jj_gen;
+        jj_la1[109] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4264,6 +4455,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -4284,7 +4476,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[107] = jj_gen;
+        jj_la1[110] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -4348,7 +4540,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[108] = jj_gen;
+            jj_la1[111] = jj_gen;
             ;
           }
           Type();
@@ -4366,7 +4558,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[109] = jj_gen;
+          jj_la1[112] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4413,6 +4605,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
       case SHORT:
       case TRUE:
       case VOID:
+      case WHEN:
       case INTEGER_LITERAL:
       case FLOATING_POINT_LITERAL:
       case CHARACTER_LITERAL:
@@ -4432,7 +4625,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[110] = jj_gen;
+        jj_la1[113] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4454,15 +4647,15 @@ final public void TypedVariableDeclaration() throws ParseException {/*@bgen(jjtr
       mods = Modifiers(Modifiers.FIELD, false);
       Type();
       VariableDeclarator();
-      label_31:
+      label_33:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case COMMA:{
           break;
           }
         default:
-          jj_la1[111] = jj_gen;
-          break label_31;
+          jj_la1[114] = jj_gen;
+          break label_33;
         }
         jj_consume_token(COMMA);
         VariableDeclarator();
@@ -4504,15 +4697,15 @@ final public void StatementExpressionList() throws ParseException {/*@bgen(jjtre
   jjtreeOpenNodeScope(jjtn000);
     try {
       StatementExpression();
-      label_32:
+      label_34:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case COMMA:{
           break;
           }
         default:
-          jj_la1[112] = jj_gen;
-          break label_32;
+          jj_la1[115] = jj_gen;
+          break label_34;
         }
         jj_consume_token(COMMA);
         StatementExpression();
@@ -4763,19 +4956,19 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[113] = jj_gen;
+        jj_la1[116] = jj_gen;
         ;
       }
       Block();
-      label_33:
+      label_35:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CATCH:{
           break;
           }
         default:
-          jj_la1[114] = jj_gen;
-          break label_33;
+          jj_la1[117] = jj_gen;
+          break label_35;
         }
         jj_consume_token(CATCH);
         jj_consume_token(LPAREN);
@@ -4792,7 +4985,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[115] = jj_gen;
+        jj_la1[118] = jj_gen;
         ;
       }
 jjtree.closeNodeScope(jjtn000, true);
@@ -4839,19 +5032,19 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[116] = jj_gen;
+          jj_la1[119] = jj_gen;
           ;
         }
         Type();
-        label_34:
+        label_36:
         while (true) {
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
           case BIT_OR:{
             break;
             }
           default:
-            jj_la1[117] = jj_gen;
-            break label_34;
+            jj_la1[120] = jj_gen;
+            break label_36;
           }
           jj_consume_token(BIT_OR);
           Type();
@@ -4876,7 +5069,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[118] = jj_gen;
+          jj_la1[121] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4913,15 +5106,15 @@ final public void TryWithResources() throws ParseException {/*@bgen(jjtree) TryW
     try {
       jj_consume_token(LPAREN);
       AutoCloseable();
-      label_35:
+      label_37:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case SEMICOLON:{
           break;
           }
         default:
-          jj_la1[119] = jj_gen;
-          break label_35;
+          jj_la1[122] = jj_gen;
+          break label_37;
         }
         jj_consume_token(SEMICOLON);
         AutoCloseable();
@@ -4967,7 +5160,7 @@ final public void AutoCloseable() throws ParseException {/*@bgen(jjtree) AutoClo
           break;
           }
         default:
-          jj_la1[120] = jj_gen;
+          jj_la1[123] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5376,144 +5569,188 @@ private boolean jj_2_38(int xla)
     finally { jj_save(37, xla); }
   }
 
-  private boolean jj_3R_262()
+  private boolean jj_3R_256()
+ {
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_257()
  {
     if (jj_3R_263()) return true;
     return false;
   }
 
-  private boolean jj_3R_168()
+  private boolean jj_3R_170()
  {
-    if (jj_3R_170()) return true;
+    if (jj_3R_172()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_171()) { jj_scanpos = xsp; break; }
+      if (jj_3R_173()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
   private boolean jj_3R_255()
  {
-    if (jj_scan_token(FINAL)) return true;
+    if (jj_3R_262()) return true;
     return false;
   }
 
-  private boolean jj_3R_171()
+  private boolean jj_3_33()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_115()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(105)) {
+    if (jj_3_33()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(106)) return true;
+    if (jj_3R_142()) return true;
     }
-    if (jj_3R_170()) return true;
     return false;
   }
 
-  private boolean jj_3_34()
+  private boolean jj_3R_173()
  {
-    if (jj_3R_53()) return true;
-    if (jj_3R_44()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(106)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(107)) return true;
+    }
+    if (jj_3R_172()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_142()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_264()) jj_scanpos = xsp;
+    if (jj_3R_46()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_170()
+  private boolean jj_3R_172()
  {
-    if (jj_3R_172()) return true;
+    if (jj_3R_174()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_173()) { jj_scanpos = xsp; break; }
+      if (jj_3R_175()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_173()
+  private boolean jj_3R_175()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(107)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(108)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(115)) {
+    if (jj_scan_token(109)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(116)) return true;
+    if (jj_scan_token(116)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(117)) return true;
     }
     }
     }
-    if (jj_3R_172()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
-  private boolean jj_3R_97()
+  private boolean jj_3R_262()
  {
-    if (jj_3R_53()) return true;
-    if (jj_3R_44()) return true;
-    if (jj_3R_60()) return true;
     Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_230()) { jj_scanpos = xsp; break; }
+    xsp = jj_scanpos;
+    if (jj_3R_270()) {
+    jj_scanpos = xsp;
+    if (jj_3R_271()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_172()
+  private boolean jj_3R_270()
  {
-    if (jj_3R_174()) return true;
+    if (jj_3R_99()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_174()
+ {
+    if (jj_3R_176()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_175()) { jj_scanpos = xsp; break; }
+      if (jj_3R_177()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3_32()
+  private boolean jj_3R_271()
  {
-    if (jj_3R_57()) return true;
+    if (jj_3R_272()) return true;
     return false;
   }
 
-  private boolean jj_3R_175()
+  private boolean jj_3R_264()
+ {
+    if (jj_scan_token(FINAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_177()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(117)) {
+    if (jj_scan_token(118)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(118)) return true;
+    if (jj_scan_token(119)) return true;
     }
-    if (jj_3R_174()) return true;
+    if (jj_3R_176()) return true;
     return false;
   }
 
-  private boolean jj_3R_263()
+  private boolean jj_3_34()
  {
-    if (jj_3R_107()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_267()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_55()) return true;
+    if (jj_3R_46()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_174()
+  private boolean jj_3R_176()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_176()) {
-    jj_scanpos = xsp;
-    if (jj_3R_177()) {
-    jj_scanpos = xsp;
     if (jj_3R_178()) {
     jj_scanpos = xsp;
     if (jj_3R_179()) {
     jj_scanpos = xsp;
-    if (jj_3R_180()) return true;
+    if (jj_3R_180()) {
+    jj_scanpos = xsp;
+    if (jj_3R_181()) {
+    jj_scanpos = xsp;
+    if (jj_3R_182()) return true;
     }
     }
     }
@@ -5521,92 +5758,84 @@ private boolean jj_3R_174()
     return false;
   }
 
-  private boolean jj_3R_176()
+  private boolean jj_3R_178()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(105)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(106)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(92)) {
+    if (jj_scan_token(107)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(93)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(91)) return true;
+    if (jj_scan_token(92)) return true;
     }
     }
     }
-    if (jj_3R_174()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_254()
- {
-    if (jj_3R_263()) return true;
+    if (jj_3R_176()) return true;
     return false;
   }
 
-  private boolean jj_3R_177()
+  private boolean jj_3R_179()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(103)) {
+    if (jj_scan_token(104)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(104)) return true;
+    if (jj_scan_token(105)) return true;
     }
-    if (jj_3R_183()) return true;
+    if (jj_3R_185()) return true;
     return false;
   }
 
-  private boolean jj_3R_114()
+  private boolean jj_3R_99()
  {
-    if (jj_scan_token(BREAK)) return true;
+    if (jj_3R_55()) return true;
+    if (jj_3R_46()) return true;
+    if (jj_3R_62()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_35()) {
-    jj_scanpos = xsp;
-    if (jj_3R_152()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_239()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_178()
- {
-    if (jj_3R_181()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_245()
+  private boolean jj_3R_180()
  {
-    if (jj_scan_token(ELSE)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_3R_183()) return true;
     return false;
   }
 
-  private boolean jj_3_35()
+  private boolean jj_3R_181()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(SEMICOLON)) return true;
+    if (jj_3R_184()) return true;
     return false;
   }
 
-  private boolean jj_3R_179()
+  private boolean jj_3_32()
  {
-    if (jj_3R_182()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_152()
+  private boolean jj_3R_272()
  {
-    if (jj_3R_40()) return true;
+    if (jj_3R_109()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_276()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_180()
+  private boolean jj_3R_182()
  {
-    if (jj_3R_183()) return true;
+    if (jj_3R_185()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_184()) jj_scanpos = xsp;
+    if (jj_3R_186()) jj_scanpos = xsp;
     return false;
   }
 
@@ -5614,298 +5843,400 @@ private boolean jj_3_10()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_46()) {
+    if (jj_3R_48()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(74)) return true;
+    if (jj_scan_token(75)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     return false;
   }
 
-  private boolean jj_3R_230()
+  private boolean jj_3R_48()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_60()) return true;
+    if (jj_3R_57()) return true;
     return false;
   }
 
-  private boolean jj_3R_115()
+  private boolean jj_3R_263()
  {
-    if (jj_scan_token(CONTINUE)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_36()) {
-    jj_scanpos = xsp;
-    if (jj_3R_153()) return true;
-    }
+    if (jj_3R_272()) return true;
     return false;
   }
 
-  private boolean jj_3R_267()
+  private boolean jj_3R_184()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_107()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_46()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_176()) return true;
     return false;
   }
 
-  private boolean jj_3R_46()
+  private boolean jj_3_11()
  {
-    if (jj_3R_55()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_46()) return true;
+    if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_182()
+  private boolean jj_3R_116()
  {
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_44()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_174()) return true;
+    if (jj_scan_token(BREAK)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_35()) {
+    jj_scanpos = xsp;
+    if (jj_3R_154()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3_11()
+  private boolean jj_3R_185()
  {
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_44()) return true;
-    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_188()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_12()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3_36()
+  private boolean jj_3R_254()
+ {
+    if (jj_scan_token(ELSE)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3_35()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_153()
+  private boolean jj_3R_154()
  {
-    if (jj_3R_40()) return true;
+    if (jj_3R_42()) return true;
     return false;
   }
 
-  private boolean jj_3R_183()
+  private boolean jj_3R_200()
  {
-    if (jj_3R_186()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_12()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_40()) return true;
+    if (jj_3R_210()) return true;
     return false;
   }
 
-  private boolean jj_3R_116()
+  private boolean jj_3R_186()
  {
-    if (jj_scan_token(RETURN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_154()) jj_scanpos = xsp;
-    if (jj_3R_40()) return true;
+    if (jj_scan_token(104)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(105)) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_196()
+  private boolean jj_3R_239()
  {
-    if (jj_3R_38()) return true;
-    if (jj_3R_205()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_62()) return true;
     return false;
   }
 
-  private boolean jj_3R_184()
+  private boolean jj_3R_117()
  {
+    if (jj_scan_token(CONTINUE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(103)) {
+    if (jj_3_36()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(104)) return true;
+    if (jj_3R_155()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_181()
+  private boolean jj_3R_183()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_185()) {
+    if (jj_3R_187()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(74)) return true;
+    if (jj_scan_token(75)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_187()) {
+    if (jj_3R_189()) {
     jj_scanpos = xsp;
-    if (jj_3R_188()) return true;
+    if (jj_3R_190()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_117()
+  private boolean jj_3R_276()
  {
-    if (jj_scan_token(SYNCHRONIZED)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_50()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_109()) return true;
     return false;
   }
 
-  private boolean jj_3R_185()
+  private boolean jj_3R_187()
  {
-    if (jj_3R_55()) return true;
+    if (jj_3R_57()) return true;
     return false;
   }
 
-  private boolean jj_3R_154()
+  private boolean jj_3_36()
  {
-    if (jj_3R_51()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_187()
+  private boolean jj_3R_189()
  {
-    if (jj_3R_50()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3_12()
+  private boolean jj_3R_155()
  {
-    if (jj_3R_47()) return true;
+    if (jj_3R_42()) return true;
     return false;
   }
 
-  private boolean jj_3R_118()
+  private boolean jj_3_12()
  {
-    if (jj_scan_token(THROW)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_49()) return true;
     return false;
   }
 
-  private boolean jj_3R_186()
+  private boolean jj_3R_199()
  {
+    if (jj_scan_token(WHEN)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_scan_token(LBRACE)) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    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()) {
-    jj_scanpos = xsp;
-    if (jj_3R_194()) return true;
-    }
-    }
-    }
-    }
+    if (jj_3R_209()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_209()) { jj_scanpos = xsp; break; }
     }
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_189()
+  private boolean jj_3R_118()
  {
-    if (jj_3R_195()) return true;
+    if (jj_scan_token(RETURN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_156()) jj_scanpos = xsp;
+    if (jj_3R_42()) return true;
     return false;
   }
 
   private boolean jj_3R_190()
  {
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_191()
+  private boolean jj_3R_209()
  {
-    if (jj_3R_49()) return true;
+    if (jj_3R_216()) return true;
     return false;
   }
 
-  private boolean jj_3R_188()
+  private boolean jj_3R_216()
  {
-    if (jj_3R_51()) return true;
-    return false;
-  }
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_225()) {
+    jj_scanpos = xsp;
+    if (jj_3R_226()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_225()
+ {
+    if (jj_scan_token(ELSE)) return true;
+    if (jj_scan_token(ARROW)) return true;
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_119()
+ {
+    if (jj_scan_token(SYNCHRONIZED)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_52()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_226()
+ {
+    if (jj_3R_53()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_233()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(ARROW)) return true;
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_156()
+ {
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_188()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_191()) {
+    jj_scanpos = xsp;
+    if (jj_3R_192()) {
+    jj_scanpos = xsp;
+    if (jj_3R_193()) {
+    jj_scanpos = xsp;
+    if (jj_3R_194()) {
+    jj_scanpos = xsp;
+    if (jj_3R_195()) {
+    jj_scanpos = xsp;
+    if (jj_3R_196()) {
+    jj_scanpos = xsp;
+    if (jj_3R_197()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_191()
+ {
+    if (jj_3R_198()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_120()
+ {
+    if (jj_scan_token(THROW)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_3R_42()) return true;
+    return false;
+  }
 
   private boolean jj_3R_192()
  {
-    if (jj_3R_196()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
   private boolean jj_3R_193()
  {
-    if (jj_3R_44()) return true;
+    if (jj_3R_199()) return true;
     return false;
   }
 
-  private boolean jj_3R_119()
+  private boolean jj_3R_194()
+ {
+    if (jj_3R_51()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_195()
+ {
+    if (jj_3R_200()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_196()
+ {
+    if (jj_3R_46()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_121()
  {
     if (jj_scan_token(TRY)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_155()) jj_scanpos = xsp;
-    if (jj_3R_50()) return true;
+    if (jj_3R_157()) jj_scanpos = xsp;
+    if (jj_3R_52()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_249()) { jj_scanpos = xsp; break; }
+      if (jj_3R_258()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_250()) jj_scanpos = xsp;
+    if (jj_3R_259()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_194()
+  private boolean jj_3R_197()
  {
-    if (jj_3R_38()) return true;
+    if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_249()
+  private boolean jj_3R_258()
  {
     if (jj_scan_token(CATCH)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_256()) return true;
+    if (jj_3R_265()) return true;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_50()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_250()
+  private boolean jj_3R_259()
  {
     if (jj_scan_token(FINALLY)) return true;
-    if (jj_3R_50()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
   private boolean jj_3_13()
  {
-    if (jj_3R_38()) return true;
+    if (jj_3R_40()) return true;
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_48()) {
+    if (jj_3R_50()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(78)) return true;
+    if (jj_scan_token(79)) return true;
     }
     return false;
   }
 
   private boolean jj_3_14()
  {
-    if (jj_3R_44()) return true;
+    if (jj_3R_46()) return true;
     if (jj_scan_token(DOT)) return true;
     if (jj_scan_token(CLASS)) return true;
     return false;
   }
 
-  private boolean jj_3R_155()
+  private boolean jj_3R_157()
  {
-    if (jj_3R_158()) return true;
+    if (jj_3R_160()) return true;
     return false;
   }
 
@@ -5913,27 +6244,34 @@ private boolean jj_3_37()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_58()) jj_scanpos = xsp;
-    if (jj_3R_44()) return true;
+    if (jj_3R_60()) jj_scanpos = xsp;
+    if (jj_3R_46()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_59()) { jj_scanpos = xsp; break; }
+      if (jj_3R_61()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_256()
+  private boolean jj_3R_265()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_37()) {
     jj_scanpos = xsp;
-    if (jj_3R_266()) return true;
+    if (jj_3R_275()) return true;
     }
     return false;
   }
 
+  private boolean jj_3R_233()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
   private boolean jj_3_15()
  {
     if (jj_scan_token(DOT)) return true;
@@ -5941,24 +6279,24 @@ private boolean jj_3_15()
     return false;
   }
 
-  private boolean jj_3R_47()
+  private boolean jj_3R_49()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_15()) {
     jj_scanpos = xsp;
-    if (jj_3R_71()) {
+    if (jj_3R_73()) {
     jj_scanpos = xsp;
     jj_lookingAhead = true;
     jj_semLA = getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET;
     jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_72()) {
+    if (!jj_semLA || jj_3R_74()) {
     jj_scanpos = xsp;
     if (jj_3_16()) {
     jj_scanpos = xsp;
     if (jj_3_17()) {
     jj_scanpos = xsp;
-    if (jj_3R_73()) {
+    if (jj_3R_75()) {
     jj_scanpos = xsp;
     if (jj_3_18()) return true;
     }
@@ -5970,51 +6308,51 @@ private boolean jj_3R_47()
     return false;
   }
 
-  private boolean jj_3R_266()
+  private boolean jj_3R_275()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_71()
+  private boolean jj_3R_73()
  {
     if (jj_scan_token(LBRACKET)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_206()) jj_scanpos = xsp;
+    if (jj_3R_211()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_207()) jj_scanpos = xsp;
+    if (jj_3R_212()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_59()
+  private boolean jj_3R_61()
  {
     if (jj_scan_token(BIT_OR)) return true;
-    if (jj_3R_44()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_158()
+  private boolean jj_3R_160()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_264()) return true;
+    if (jj_3R_273()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_265()) { jj_scanpos = xsp; break; }
+      if (jj_3R_274()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_206()
+  private boolean jj_3R_211()
  {
-    if (jj_3R_51()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_58()
+  private boolean jj_3R_60()
  {
     if (jj_scan_token(FINAL)) return true;
     return false;
@@ -6022,106 +6360,112 @@ private boolean jj_3R_58()
 
   private boolean jj_3_38()
  {
-    if (jj_3R_44()) return true;
-    if (jj_3R_60()) return true;
+    if (jj_3R_46()) return true;
+    if (jj_3R_62()) return true;
     return false;
   }
 
-  private boolean jj_3R_207()
+  private boolean jj_3R_212()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_215()) {
+    if (jj_3R_221()) {
     jj_scanpos = xsp;
-    if (jj_3R_216()) return true;
+    if (jj_3R_222()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_215()
+  private boolean jj_3R_221()
  {
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_222()) jj_scanpos = xsp;
+    if (jj_3R_230()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_264()
+  private boolean jj_3R_273()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_38()) {
     jj_scanpos = xsp;
-    if (jj_3R_268()) return true;
+    if (jj_3R_277()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_216()
+  private boolean jj_3R_222()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_223()) jj_scanpos = xsp;
+    if (jj_3R_231()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_224()) jj_scanpos = xsp;
+    if (jj_3R_232()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_48()
+  private boolean jj_3R_50()
  {
-    if (jj_3R_51()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_72()
+  private boolean jj_3R_74()
  {
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(74)) {
+    if (jj_scan_token(75)) {
     jj_scanpos = xsp;
     if (jj_scan_token(43)) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_222()
+  private boolean jj_3R_230()
  {
-    if (jj_3R_51()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_224()
+  private boolean jj_3R_232()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_226()) jj_scanpos = xsp;
+    if (jj_3R_235()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_268()
+  private boolean jj_3_1()
+ {
+    if (jj_3R_38()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_277()
  {
-    if (jj_3R_60()) return true;
+    if (jj_3R_62()) return true;
     return false;
   }
 
   private boolean jj_3_16()
  {
-    if (jj_scan_token(154)) return true;
+    if (jj_scan_token(155)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_208()) jj_scanpos = xsp;
+    if (jj_3R_213()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_265()
+  private boolean jj_3R_274()
  {
     if (jj_scan_token(SEMICOLON)) return true;
-    if (jj_3R_264()) return true;
+    if (jj_3R_273()) return true;
     return false;
   }
 
@@ -6131,101 +6475,36 @@ private boolean jj_3_17()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_209()) jj_scanpos = xsp;
+    if (jj_3R_214()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_73()
+  private boolean jj_3R_75()
  {
     if (jj_scan_token(LBRACE)) return true;
-    if (jj_3R_51()) return true;
+    if (jj_3R_53()) return true;
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3_1()
+  private boolean jj_3R_55()
  {
-    if (jj_3R_36()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_79()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
   private boolean jj_3_18()
  {
     if (jj_scan_token(DOT)) return true;
-    if (jj_3R_49()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_223()
- {
-    if (jj_3R_51()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_208()
- {
-    if (jj_3R_205()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_226()
- {
     if (jj_3R_51()) return true;
     return false;
   }
 
-  private boolean jj_3R_209()
- {
-    if (jj_3R_205()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_195()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_197()) {
-    jj_scanpos = xsp;
-    if (jj_3R_198()) {
-    jj_scanpos = xsp;
-    if (jj_3R_199()) {
-    jj_scanpos = xsp;
-    if (jj_3R_200()) {
-    jj_scanpos = xsp;
-    if (jj_3R_201()) {
-    jj_scanpos = xsp;
-    if (jj_3R_202()) {
-    jj_scanpos = xsp;
-    if (jj_3R_203()) {
-    jj_scanpos = xsp;
-    if (jj_3R_204()) return true;
-    }
-    }
-    }
-    }
-    }
-    }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_197()
- {
-    if (jj_scan_token(INTEGER_LITERAL)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_53()
- {
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_77()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_77()
+  private boolean jj_3R_79()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -6266,299 +6545,324 @@ private boolean jj_3R_77()
     return false;
   }
 
-  private boolean jj_3R_198()
+  private boolean jj_3R_231()
  {
-    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_95()
+  private boolean jj_3R_213()
+ {
+    if (jj_3R_210()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_235()
  {
     if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_214()
+ {
+    if (jj_3R_210()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_198()
+ {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_120()) {
+    if (jj_3R_201()) {
     jj_scanpos = xsp;
-    if (jj_3R_121()) return true;
+    if (jj_3R_202()) {
+    jj_scanpos = xsp;
+    if (jj_3R_203()) {
+    jj_scanpos = xsp;
+    if (jj_3R_204()) {
+    jj_scanpos = xsp;
+    if (jj_3R_205()) {
+    jj_scanpos = xsp;
+    if (jj_3R_206()) {
+    jj_scanpos = xsp;
+    if (jj_3R_207()) {
+    jj_scanpos = xsp;
+    if (jj_3R_208()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
     }
     return false;
   }
 
-  private boolean jj_3R_199()
+  private boolean jj_3R_201()
  {
-    if (jj_scan_token(CHARACTER_LITERAL)) return true;
+    if (jj_scan_token(INTEGER_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_120()
+  private boolean jj_3R_97()
  {
+    if (jj_3R_55()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_141()) {
+    if (jj_3R_122()) {
     jj_scanpos = xsp;
-    if (jj_3R_142()) return true;
+    if (jj_3R_123()) return true;
     }
-    if (jj_3R_50()) return true;
     return false;
   }
 
-  private boolean jj_3R_141()
+  private boolean jj_3R_122()
  {
-    if (jj_scan_token(CLASS)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_236()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_237()) jj_scanpos = xsp;
+    if (jj_3R_143()) {
+    jj_scanpos = xsp;
+    if (jj_3R_144()) return true;
+    }
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_200()
+  private boolean jj_3R_202()
  {
-    if (jj_scan_token(STRING_LITERAL)) return true;
+    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_236()
+  private boolean jj_3R_143()
+ {
+    if (jj_scan_token(CLASS)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_245()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_246()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_245()
  {
     if (jj_scan_token(EXTENDS)) return true;
-    if (jj_3R_38()) return true;
+    if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_237()
+  private boolean jj_3R_246()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
-    if (jj_3R_81()) return true;
+    if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_142()
+  private boolean jj_3R_144()
  {
     if (jj_scan_token(INTERFACE)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_238()) jj_scanpos = xsp;
+    if (jj_3R_247()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_121()
+  private boolean jj_3R_123()
  {
     if (jj_scan_token(ENUM)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_231()) jj_scanpos = xsp;
-    if (jj_3R_232()) return true;
+    if (jj_3R_240()) jj_scanpos = xsp;
+    if (jj_3R_241()) return true;
     return false;
   }
 
-  private boolean jj_3R_238()
+  private boolean jj_3R_247()
  {
     if (jj_scan_token(EXTENDS)) return true;
-    if (jj_3R_81()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_201()
- {
-    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
+    if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_231()
+  private boolean jj_3R_240()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
-    if (jj_3R_81()) return true;
+    if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_202()
+  private boolean jj_3R_203()
  {
-    if (jj_3R_210()) return true;
+    if (jj_scan_token(CHARACTER_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_203()
+  private boolean jj_3R_204()
  {
-    if (jj_scan_token(44)) return true;
+    if (jj_scan_token(STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_251()
+  private boolean jj_3R_260()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_257()) jj_scanpos = xsp;
+    if (jj_3R_266()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_258()) jj_scanpos = xsp;
+    if (jj_3R_267()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_204()
+  private boolean jj_3R_205()
  {
-    if (jj_scan_token(60)) return true;
+    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_210()
+  private boolean jj_3R_241()
  {
+    if (jj_scan_token(LBRACE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_217()) {
-    jj_scanpos = xsp;
-    if (jj_3R_218()) return true;
+    if (jj_3R_248()) jj_scanpos = xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_249()) { jj_scanpos = xsp; break; }
     }
+    xsp = jj_scanpos;
+    if (jj_3R_250()) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_217()
+  private boolean jj_3R_206()
  {
-    if (jj_scan_token(TRUE)) return true;
+    if (jj_3R_215()) return true;
     return false;
   }
 
-  private boolean jj_3R_218()
+  private boolean jj_3R_266()
  {
-    if (jj_scan_token(FALSE)) return true;
+    if (jj_3R_210()) return true;
     return false;
   }
 
-  private boolean jj_3R_232()
+  private boolean jj_3R_207()
  {
-    if (jj_scan_token(LBRACE)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_239()) jj_scanpos = xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_240()) { jj_scanpos = xsp; break; }
-    }
-    xsp = jj_scanpos;
-    if (jj_3R_241()) jj_scanpos = xsp;
-    if (jj_scan_token(RBRACE)) return true;
+    if (jj_scan_token(44)) return true;
     return false;
   }
 
-  private boolean jj_3R_257()
+  private boolean jj_3R_248()
  {
-    if (jj_3R_205()) return true;
+    if (jj_3R_260()) return true;
     return false;
   }
 
-  private boolean jj_3R_239()
+  private boolean jj_3R_208()
  {
-    if (jj_3R_251()) return true;
+    if (jj_scan_token(60)) return true;
     return false;
   }
 
-  private boolean jj_3R_96()
+  private boolean jj_3R_98()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_55()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_122()) {
+    if (jj_3R_124()) {
     jj_scanpos = xsp;
-    if (jj_3R_123()) return true;
+    if (jj_3R_125()) return true;
     }
-    if (jj_3R_55()) return true;
+    if (jj_3R_57()) return true;
     xsp = jj_scanpos;
-    if (jj_3R_227()) jj_scanpos = xsp;
+    if (jj_3R_236()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_228()) {
+    if (jj_3R_237()) {
     jj_scanpos = xsp;
-    if (jj_3R_229()) return true;
+    if (jj_3R_238()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_122()
+  private boolean jj_3R_124()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_123()
+  private boolean jj_3R_125()
  {
-    if (jj_3R_54()) return true;
+    if (jj_3R_56()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_205()
+  private boolean jj_3R_215()
  {
-    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;
+    if (jj_3R_223()) {
+    jj_scanpos = xsp;
+    if (jj_3R_224()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_258()
+  private boolean jj_3R_223()
  {
-    if (jj_3R_50()) return true;
+    if (jj_scan_token(TRUE)) return true;
     return false;
   }
 
-  private boolean jj_3R_227()
+  private boolean jj_3R_224()
  {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_81()) return true;
+    if (jj_scan_token(FALSE)) return true;
     return false;
   }
 
-  private boolean jj_3R_228()
+  private boolean jj_3R_267()
  {
-    if (jj_3R_50()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3_3()
+  private boolean jj_3R_236()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_214()
+  private boolean jj_3R_237()
  {
-    if (jj_3R_221()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_221()
+  private boolean jj_3_3()
  {
-    if (jj_3R_51()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_225()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(LPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_99()
+  private boolean jj_3R_101()
  {
     if (jj_scan_token(PACKAGE)) return true;
-    if (jj_3R_38()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_240()
- {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_251()) return true;
+    if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_225()
+  private boolean jj_3R_249()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_51()) return true;
+    if (jj_3R_260()) return true;
     return false;
   }
 
@@ -6567,158 +6871,272 @@ private boolean jj_3_4()
     if (jj_scan_token(IMPORT)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_37()) jj_scanpos = xsp;
-    if (jj_3R_38()) return true;
-    xsp = jj_scanpos;
     if (jj_3R_39()) jj_scanpos = xsp;
     if (jj_3R_40()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_41()) jj_scanpos = xsp;
+    if (jj_3R_42()) return true;
     return false;
   }
 
-  private boolean jj_3R_98()
+  private boolean jj_3R_100()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_4()) {
     jj_scanpos = xsp;
-    if (jj_3R_124()) return true;
+    if (jj_3R_126()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_49()
+  private boolean jj_3R_238()
+ {
+    if (jj_3R_242()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_126()
+ {
+    if (jj_scan_token(IMPORT)) return true;
+    if (jj_scan_token(STAR)) return true;
+    if (jj_3R_42()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_210()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_220()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_39()
+ {
+    if (jj_scan_token(STATIC)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_220()
+ {
+    if (jj_3R_229()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_229()
+ {
+    if (jj_3R_53()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_234()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_62()
+ {
+    if (jj_scan_token(IDENTIFIER)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_243()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_244()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_234()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_243()
+ {
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_244()
+ {
+    if (jj_scan_token(ASSIGN)) return true;
+    if (jj_3R_44()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_41()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(STAR)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_51()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_74()) {
+    if (jj_3R_76()) {
     jj_scanpos = xsp;
-    if (jj_3R_75()) return true;
+    if (jj_3R_77()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_74()
+  private boolean jj_3R_76()
  {
     if (jj_scan_token(NEW)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_211()) {
+    if (jj_3R_217()) {
     jj_scanpos = xsp;
-    if (jj_3R_212()) {
+    if (jj_3R_218()) {
     jj_scanpos = xsp;
-    if (jj_3R_213()) return true;
+    if (jj_3R_219()) return true;
     }
     }
     return false;
   }
 
-  private boolean jj_3R_229()
+  private boolean jj_3R_250()
  {
-    if (jj_3R_233()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_2()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_124()
+  private boolean jj_3_5()
  {
-    if (jj_scan_token(IMPORT)) return true;
-    if (jj_scan_token(STAR)) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_43()) return true;
     return false;
   }
 
-  private boolean jj_3R_211()
+  private boolean jj_3R_44()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_5()) {
+    jj_scanpos = xsp;
+    if (jj_3R_70()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_70()
+ {
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_217()
  {
-    if (jj_3R_100()) return true;
     if (jj_3R_102()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_212()
+  private boolean jj_3_2()
  {
     if (jj_3R_38()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_218()
+ {
+    if (jj_3R_40()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_219()) {
+    if (jj_3R_227()) {
     jj_scanpos = xsp;
-    if (jj_3R_220()) return true;
+    if (jj_3R_228()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_219()
+  private boolean jj_3R_227()
  {
-    if (jj_3R_102()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_37()
+  private boolean jj_3R_43()
  {
-    if (jj_scan_token(STATIC)) return true;
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_69()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(85)) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_220()
+  private boolean jj_3R_228()
  {
-    if (jj_3R_205()) return true;
+    if (jj_3R_210()) return true;
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_19()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_75()
+  private boolean jj_3R_77()
  {
-    if (jj_3R_102()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_213()
+  private boolean jj_3R_219()
  {
-    if (jj_3R_102()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_60()
+  private boolean jj_3R_69()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_44()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_234()) { jj_scanpos = xsp; break; }
+      if (jj_3_6()) { jj_scanpos = xsp; break; }
     }
-    xsp = jj_scanpos;
-    if (jj_3R_235()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_234()
+  private boolean jj_3R_57()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_82()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_102()
+  private boolean jj_3R_104()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_22()) {
     jj_scanpos = xsp;
-    if (jj_3R_135()) {
+    if (jj_3R_137()) {
     jj_scanpos = xsp;
-    if (jj_3R_136()) return true;
+    if (jj_3R_138()) return true;
     }
     }
     return false;
   }
 
-  private boolean jj_3R_235()
- {
-    if (jj_scan_token(ASSIGN)) return true;
-    if (jj_3R_42()) return true;
-    return false;
-  }
-
   private boolean jj_3_22()
  {
     Token xsp;
@@ -6734,45 +7152,17 @@ private boolean jj_3_22()
     return false;
   }
 
-  private boolean jj_3R_39()
- {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_scan_token(STAR)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_241()
- {
-    if (jj_scan_token(SEMICOLON)) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_2()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3_5()
- {
-    if (jj_3R_41()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_42()
+  private boolean jj_3_6()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_5()) {
-    jj_scanpos = xsp;
-    if (jj_3R_68()) return true;
-    }
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_44()) return true;
     return false;
   }
 
   private boolean jj_3_20()
  {
     if (jj_scan_token(LBRACKET)) return true;
-    if (jj_3R_51()) return true;
+    if (jj_3R_53()) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
@@ -6784,89 +7174,101 @@ private boolean jj_3_21()
     return false;
   }
 
-  private boolean jj_3R_68()
+  private boolean jj_3R_82()
  {
-    if (jj_3R_51()) return true;
+    if (jj_3R_106()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_107()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_106()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_7()) {
+    jj_scanpos = xsp;
+    if (jj_3R_140()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_141()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_135()
+  private boolean jj_3R_137()
  {
     Token xsp;
-    if (jj_3R_144()) return true;
+    if (jj_3R_146()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_144()) { jj_scanpos = xsp; break; }
+      if (jj_3R_146()) { jj_scanpos = xsp; break; }
     }
-    if (jj_3R_41()) return true;
+    if (jj_3R_43()) return true;
     return false;
   }
 
-  private boolean jj_3_2()
+  private boolean jj_3_7()
  {
-    if (jj_3R_36()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_45()) jj_scanpos = xsp;
+    if (jj_3R_46()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_47()) jj_scanpos = xsp;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
   private boolean jj_3_19()
  {
-    if (jj_3R_50()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_144()
+  private boolean jj_3R_146()
  {
     if (jj_scan_token(LBRACKET)) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_136()
+  private boolean jj_3R_138()
  {
-    if (jj_3R_41()) return true;
+    if (jj_3R_43()) return true;
     return false;
   }
 
-  private boolean jj_3R_41()
+  private boolean jj_3R_140()
  {
-    if (jj_scan_token(LBRACE)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_67()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(84)) jj_scanpos = xsp;
-    if (jj_scan_token(RBRACE)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_67()
+  private boolean jj_3R_141()
  {
-    if (jj_3R_42()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_6()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3_23()
+  private boolean jj_3R_47()
  {
-    if (jj_3R_52()) return true;
+    if (jj_scan_token(ELLIPSIS)) return true;
     return false;
   }
 
-  private boolean jj_3R_55()
+  private boolean jj_3_23()
  {
-    if (jj_scan_token(LPAREN)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_80()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_54()) return true;
     return false;
   }
 
-  private boolean jj_3R_57()
+  private boolean jj_3R_59()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -6874,11 +7276,7 @@ private boolean jj_3R_57()
     jj_scanpos = xsp;
     if (jj_3_24()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(83)) {
-    jj_scanpos = xsp;
-    if (jj_3R_82()) {
-    jj_scanpos = xsp;
-    if (jj_3R_83()) {
+    if (jj_scan_token(84)) {
     jj_scanpos = xsp;
     if (jj_3R_84()) {
     jj_scanpos = xsp;
@@ -6886,14 +7284,14 @@ private boolean jj_3R_57()
     jj_scanpos = xsp;
     if (jj_3R_86()) {
     jj_scanpos = xsp;
-    jj_lookingAhead = true;
-    jj_semLA = isRegularForStatement();
-    jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_87()) {
+    if (jj_3R_87()) {
     jj_scanpos = xsp;
     if (jj_3R_88()) {
     jj_scanpos = xsp;
-    if (jj_3R_89()) {
+    jj_lookingAhead = true;
+    jj_semLA = isRegularForStatement();
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_89()) {
     jj_scanpos = xsp;
     if (jj_3R_90()) {
     jj_scanpos = xsp;
@@ -6903,7 +7301,11 @@ private boolean jj_3R_57()
     jj_scanpos = xsp;
     if (jj_3R_93()) {
     jj_scanpos = xsp;
-    if (jj_3R_94()) return true;
+    if (jj_3R_94()) {
+    jj_scanpos = xsp;
+    if (jj_3R_95()) {
+    jj_scanpos = xsp;
+    if (jj_3R_96()) return true;
     }
     }
     }
@@ -6922,79 +7324,44 @@ private boolean jj_3R_57()
     return false;
   }
 
-  private boolean jj_3_6()
- {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_42()) return true;
-    return false;
-  }
-
   private boolean jj_3_24()
  {
-    if (jj_3R_50()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_80()
+  private boolean jj_3R_45()
  {
-    if (jj_3R_104()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_105()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_104()
+  private boolean jj_3R_46()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_7()) {
+    if (jj_3R_71()) {
     jj_scanpos = xsp;
-    if (jj_3R_138()) return true;
+    if (jj_3R_72()) return true;
     }
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_139()) { jj_scanpos = xsp; break; }
+      if (jj_3_8()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3_7()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_43()) jj_scanpos = xsp;
-    if (jj_3R_44()) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_45()) jj_scanpos = xsp;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_82()
- {
-    if (jj_3R_107()) return true;
-    if (jj_3R_40()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_83()
+  private boolean jj_3R_107()
  {
-    if (jj_3R_108()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_106()) return true;
     return false;
   }
 
   private boolean jj_3R_84()
  {
     if (jj_3R_109()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_138()
- {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_42()) return true;
     return false;
   }
 
@@ -7004,22 +7371,15 @@ private boolean jj_3R_85()
     return false;
   }
 
-  private boolean jj_3R_86()
- {
-    if (jj_3R_111()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_139()
+  private boolean jj_3R_71()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_3R_102()) return true;
     return false;
   }
 
-  private boolean jj_3R_45()
+  private boolean jj_3R_86()
  {
-    if (jj_scan_token(ELLIPSIS)) return true;
+    if (jj_3R_111()) return true;
     return false;
   }
 
@@ -7029,15 +7389,16 @@ private boolean jj_3R_87()
     return false;
   }
 
-  private boolean jj_3R_88()
+  private boolean jj_3_8()
  {
-    if (jj_3R_113()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_43()
+  private boolean jj_3R_88()
  {
-    if (jj_scan_token(FINAL)) return true;
+    if (jj_3R_113()) return true;
     return false;
   }
 
@@ -7047,31 +7408,32 @@ private boolean jj_3R_89()
     return false;
   }
 
-  private boolean jj_3R_44()
+  private boolean jj_3R_56()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_69()) {
+    if (jj_3R_80()) {
     jj_scanpos = xsp;
-    if (jj_3R_70()) return true;
-    }
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_8()) { jj_scanpos = xsp; break; }
+    if (jj_3R_81()) return true;
     }
     return false;
   }
 
+  private boolean jj_3R_80()
+ {
+    if (jj_scan_token(VOID)) return true;
+    return false;
+  }
+
   private boolean jj_3R_90()
  {
     if (jj_3R_115()) return true;
     return false;
   }
 
-  private boolean jj_3R_105()
+  private boolean jj_3R_81()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_104()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
@@ -7087,15 +7449,50 @@ private boolean jj_3R_92()
     return false;
   }
 
-  private boolean jj_3R_69()
+  private boolean jj_3R_93()
  {
-    if (jj_3R_100()) return true;
+    if (jj_3R_118()) return true;
     return false;
   }
 
-  private boolean jj_3R_93()
+  private boolean jj_3R_102()
  {
-    if (jj_3R_118()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_127()) {
+    jj_scanpos = xsp;
+    if (jj_3R_128()) {
+    jj_scanpos = xsp;
+    if (jj_3R_129()) {
+    jj_scanpos = xsp;
+    if (jj_3R_130()) {
+    jj_scanpos = xsp;
+    if (jj_3R_131()) {
+    jj_scanpos = xsp;
+    if (jj_3R_132()) {
+    jj_scanpos = xsp;
+    if (jj_3R_133()) {
+    jj_scanpos = xsp;
+    if (jj_3R_134()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_127()
+ {
+    if (jj_scan_token(BOOLEAN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_128()
+ {
+    if (jj_scan_token(CHAR)) return true;
     return false;
   }
 
@@ -7105,104 +7502,80 @@ private boolean jj_3R_94()
     return false;
   }
 
-  private boolean jj_3_8()
+  private boolean jj_3R_129()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(BYTE)) return true;
     return false;
   }
 
-  private boolean jj_3R_52()
+  private boolean jj_3R_72()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_54()
+  private boolean jj_3R_130()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_78()) {
-    jj_scanpos = xsp;
-    if (jj_3R_79()) return true;
-    }
+    if (jj_scan_token(SHORT)) return true;
     return false;
   }
 
-  private boolean jj_3R_78()
+  private boolean jj_3R_95()
  {
-    if (jj_scan_token(VOID)) return true;
+    if (jj_3R_120()) return true;
     return false;
   }
 
-  private boolean jj_3R_79()
+  private boolean jj_3R_131()
  {
-    if (jj_3R_44()) return true;
+    if (jj_scan_token(INT)) return true;
     return false;
   }
 
-  private boolean jj_3R_100()
+  private boolean jj_3R_132()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_125()) {
-    jj_scanpos = xsp;
-    if (jj_3R_126()) {
-    jj_scanpos = xsp;
-    if (jj_3R_127()) {
-    jj_scanpos = xsp;
-    if (jj_3R_128()) {
-    jj_scanpos = xsp;
-    if (jj_3R_129()) {
-    jj_scanpos = xsp;
-    if (jj_3R_130()) {
-    jj_scanpos = xsp;
-    if (jj_3R_131()) {
-    jj_scanpos = xsp;
-    if (jj_3R_132()) return true;
-    }
-    }
-    }
-    }
-    }
-    }
-    }
+    if (jj_scan_token(LONG)) return true;
     return false;
   }
 
-  private boolean jj_3R_125()
+  private boolean jj_3R_96()
  {
-    if (jj_scan_token(BOOLEAN)) return true;
+    if (jj_3R_121()) return true;
     return false;
   }
 
-  private boolean jj_3R_126()
+  private boolean jj_3R_133()
  {
-    if (jj_scan_token(CHAR)) return true;
+    if (jj_scan_token(FLOAT)) return true;
     return false;
   }
 
-  private boolean jj_3R_127()
+  private boolean jj_3R_134()
  {
-    if (jj_scan_token(BYTE)) return true;
+    if (jj_scan_token(DOUBLE)) return true;
     return false;
   }
 
-  private boolean jj_3R_70()
+  private boolean jj_3R_54()
  {
-    if (jj_3R_38()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_128()
+  private boolean jj_3R_40()
  {
-    if (jj_scan_token(SHORT)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_9()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_50()
+  private boolean jj_3R_52()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7216,47 +7589,41 @@ private boolean jj_3R_50()
     return false;
   }
 
-  private boolean jj_3R_129()
- {
-    if (jj_scan_token(INT)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_130()
- {
-    if (jj_scan_token(LONG)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_131()
+  private boolean jj_3_9()
  {
-    if (jj_scan_token(FLOAT)) return true;
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_132()
+  private boolean jj_3R_83()
  {
-    if (jj_scan_token(DOUBLE)) return true;
+    if (jj_3R_40()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_108()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_36()
+  private boolean jj_3R_38()
  {
     Token xsp;
     xsp = jj_scanpos;
-    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_3_30()) {
     jj_scanpos = xsp;
-    if (jj_3R_65()) {
+    if (jj_3R_67()) {
     jj_scanpos = xsp;
-    if (jj_3R_66()) return true;
+    if (jj_3R_68()) return true;
     }
     }
     }
@@ -7266,45 +7633,43 @@ private boolean jj_3R_36()
     return false;
   }
 
-  private boolean jj_3R_61()
+  private boolean jj_3R_63()
  {
-    if (jj_3R_95()) return true;
+    if (jj_3R_97()) return true;
     return false;
   }
 
-  private boolean jj_3R_38()
+  private boolean jj_3R_64()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_9()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_98()) return true;
     return false;
   }
 
-  private boolean jj_3R_62()
+  private boolean jj_3R_53()
  {
-    if (jj_3R_96()) return true;
+    if (jj_3R_78()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_103()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3_9()
+  private boolean jj_3R_65()
  {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_98()) return true;
     return false;
   }
 
-  private boolean jj_3R_63()
+  private boolean jj_3R_103()
  {
-    if (jj_3R_96()) return true;
+    if (jj_3R_136()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
   private boolean jj_3_26()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_55()) return true;
     Token xsp;
     xsp = jj_scanpos;
     if (jj_scan_token(14)) {
@@ -7317,147 +7682,82 @@ private boolean jj_3_26()
     return false;
   }
 
-  private boolean jj_3R_64()
+  private boolean jj_3R_108()
  {
-    if (jj_3R_97()) return true;
+    if (jj_scan_token(COMMA)) return true;
     if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_81()
+  private boolean jj_3R_66()
  {
-    if (jj_3R_38()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_106()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_99()) return true;
+    if (jj_3R_42()) return true;
     return false;
   }
 
   private boolean jj_3_25()
  {
-    if (jj_3R_36()) return true;
+    if (jj_3R_38()) return true;
     return false;
   }
 
   private boolean jj_3_27()
  {
-    if (jj_3R_53()) return true;
-    if (jj_3R_54()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    return false;
-  }
-
-  private boolean jj_3_30()
- {
-    if (jj_3R_57()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_65()
- {
-    if (jj_3R_98()) return true;
-    return false;
-  }
-
-  private boolean jj_3_28()
- {
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_3R_55()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_56()) jj_scanpos = xsp;
-    if (jj_scan_token(LBRACE)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_66()
- {
-    if (jj_3R_99()) return true;
-    return false;
-  }
-
-  private boolean jj_3_29()
- {
-    if (jj_3R_53()) return true;
-    if (jj_3R_44()) return true;
+    if (jj_3R_56()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(LPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_51()
- {
-    if (jj_3R_76()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_101()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_101()
- {
-    if (jj_3R_134()) return true;
-    if (jj_3R_51()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_106()
- {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_38()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_134()
+  private boolean jj_3R_136()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(86)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(127)) {
+    if (jj_scan_token(87)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(137)) {
+    if (jj_scan_token(128)) {
     jj_scanpos = xsp;
     if (jj_scan_token(138)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(128)) {
+    if (jj_scan_token(139)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(135)) {
+    if (jj_scan_token(129)) {
     jj_scanpos = xsp;
     if (jj_scan_token(136)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(125)) {
+    if (jj_scan_token(137)) {
     jj_scanpos = xsp;
     if (jj_scan_token(126)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(129)) {
+    if (jj_scan_token(127)) {
     jj_scanpos = xsp;
     if (jj_scan_token(130)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(133)) {
+    if (jj_scan_token(131)) {
     jj_scanpos = xsp;
     if (jj_scan_token(134)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(131)) {
+    if (jj_scan_token(135)) {
     jj_scanpos = xsp;
     if (jj_scan_token(132)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(139)) {
+    if (jj_scan_token(133)) {
     jj_scanpos = xsp;
     if (jj_scan_token(140)) {
     jj_scanpos = xsp;
     if (jj_scan_token(141)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(147)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(142)) {
     jj_scanpos = xsp;
+    if (jj_scan_token(148)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(143)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(144)) return true;
+    if (jj_scan_token(144)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(145)) return true;
     }
     }
     }
@@ -7482,105 +7782,107 @@ private boolean jj_3R_134()
     return false;
   }
 
-  private boolean jj_3R_233()
+  private boolean jj_3_30()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(83)) {
-    jj_scanpos = xsp;
-    jj_lookingAhead = true;
-    jj_semLA = isImplicitMethodTerminator();
-    jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_242()) return true;
-    }
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_242()
+  private boolean jj_3R_67()
  {
+    if (jj_3R_100()) return true;
     return false;
   }
 
-  private boolean jj_3R_40()
+  private boolean jj_3_28()
  {
+    if (jj_3R_55()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_57()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(83)) jj_scanpos = xsp;
+    if (jj_3R_58()) jj_scanpos = xsp;
+    if (jj_scan_token(LBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_76()
+  private boolean jj_3R_68()
  {
-    if (jj_3R_103()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_133()) jj_scanpos = xsp;
+    if (jj_3R_101()) return true;
     return false;
   }
 
-  private boolean jj_3R_56()
+  private boolean jj_3_29()
  {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_81()) return true;
+    if (jj_3R_55()) return true;
+    if (jj_3R_46()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_103()
+  private boolean jj_3R_78()
+ {
+    if (jj_3R_105()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_135()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_105()
  {
-    if (jj_3R_137()) return true;
+    if (jj_3R_139()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_143()) { jj_scanpos = xsp; break; }
+      if (jj_3R_145()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_107()
+  private boolean jj_3R_242()
  {
-    if (jj_3R_51()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(84)) {
+    jj_scanpos = xsp;
+    jj_lookingAhead = true;
+    jj_semLA = isImplicitMethodTerminator();
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_251()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_143()
+  private boolean jj_3R_145()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(148)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(149)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(146)) return true;
+    if (jj_scan_token(150)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(147)) return true;
     }
     }
-    if (jj_3R_137()) return true;
+    if (jj_3R_139()) return true;
     return false;
   }
 
-  private boolean jj_3R_137()
+  private boolean jj_3R_251()
  {
-    if (jj_3R_145()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_146()) { jj_scanpos = xsp; break; }
-    }
     return false;
   }
 
-  private boolean jj_3R_146()
+  private boolean jj_3R_42()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(99)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(100)) return true;
-    }
-    if (jj_3R_145()) return true;
+    if (jj_scan_token(84)) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_145()
+  private boolean jj_3R_139()
  {
     if (jj_3R_147()) return true;
     Token xsp;
@@ -7594,28 +7896,19 @@ private boolean jj_3R_145()
   private boolean jj_3R_148()
  {
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(101)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(102)) return true;
-    }
-    if (jj_3R_147()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_108()
- {
-    if (jj_scan_token(SWITCH)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) 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_243()) { jj_scanpos = xsp; break; }
+    xsp = jj_scanpos;
+    if (jj_scan_token(100)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(101)) return true;
     }
-    if (jj_scan_token(RBRACE)) return true;
+    if (jj_3R_147()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_58()
+ {
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_83()) return true;
     return false;
   }
 
@@ -7630,14 +7923,9 @@ private boolean jj_3R_147()
     return false;
   }
 
-  private boolean jj_3R_243()
+  private boolean jj_3R_109()
  {
-    if (jj_3R_252()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_31()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_53()) return true;
     return false;
   }
 
@@ -7645,201 +7933,211 @@ private boolean jj_3R_150()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(111)) {
+    if (jj_scan_token(102)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(112)) return true;
+    if (jj_scan_token(103)) return true;
     }
     if (jj_3R_149()) return true;
     return false;
   }
 
-  private boolean jj_3R_252()
+  private boolean jj_3R_149()
  {
+    if (jj_3R_151()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_259()) {
-    jj_scanpos = xsp;
-    if (jj_3R_260()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_152()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_259()
+  private boolean jj_3R_152()
  {
-    if (jj_scan_token(CASE)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(COLON)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(112)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(113)) return true;
+    }
+    if (jj_3R_151()) return true;
     return false;
   }
 
-  private boolean jj_3R_260()
+  private boolean jj_3R_135()
  {
-    if (jj_scan_token(155)) return true;
+    if (jj_scan_token(HOOK)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_78()) return true;
     return false;
   }
 
-  private boolean jj_3R_133()
+  private boolean jj_3R_151()
  {
-    if (jj_scan_token(HOOK)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_76()) return true;
+    if (jj_3R_153()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_158()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_149()
+  private boolean jj_3R_110()
  {
-    if (jj_3R_151()) return true;
+    if (jj_scan_token(SWITCH)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) 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_156()) { jj_scanpos = xsp; break; }
+      if (jj_3R_252()) { jj_scanpos = xsp; break; }
     }
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_156()
+  private boolean jj_3R_158()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(113)) {
+    if (jj_scan_token(114)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(114)) return true;
+    if (jj_scan_token(115)) return true;
     }
-    if (jj_3R_151()) return true;
+    if (jj_3R_153()) return true;
     return false;
   }
 
-  private boolean jj_3_31()
+  private boolean jj_3R_153()
  {
-    if (jj_3R_36()) return true;
+    if (jj_3R_159()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_161()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_109()
+  private boolean jj_3R_161()
  {
-    if (jj_scan_token(IF)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(RPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_244()) {
+    if (jj_scan_token(110)) {
     jj_scanpos = xsp;
-    if (jj_3_32()) return true;
+    if (jj_scan_token(111)) return true;
     }
-    xsp = jj_scanpos;
-    if (jj_3R_245()) jj_scanpos = xsp;
+    if (jj_3R_159()) return true;
     return false;
   }
 
-  private boolean jj_3R_151()
+  private boolean jj_3R_252()
  {
-    if (jj_3R_157()) return true;
+    if (jj_3R_261()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_159()) { jj_scanpos = xsp; break; }
+      if (jj_3_31()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_159()
+  private boolean jj_3R_261()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(109)) {
+    if (jj_3R_268()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(110)) return true;
+    if (jj_3R_269()) return true;
     }
-    if (jj_3R_157()) return true;
     return false;
   }
 
-  private boolean jj_3R_110()
+  private boolean jj_3R_268()
  {
-    if (jj_scan_token(WHILE)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_scan_token(CASE)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(COLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_157()
+  private boolean jj_3R_269()
  {
-    if (jj_3R_160()) return true;
+    if (jj_scan_token(156)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_159()
+ {
+    if (jj_3R_162()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_161()) { jj_scanpos = xsp; break; }
+      if (jj_3R_163()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_161()
+  private boolean jj_3R_163()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(93)) {
+    if (jj_scan_token(94)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(98)) return true;
+    if (jj_scan_token(99)) return true;
     }
-    if (jj_3R_160()) return true;
+    if (jj_3R_162()) return true;
     return false;
   }
 
-  private boolean jj_3R_111()
+  private boolean jj_3_31()
  {
-    if (jj_scan_token(DO)) return true;
-    if (jj_3R_57()) return true;
-    if (jj_scan_token(WHILE)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_38()) return true;
     return false;
   }
 
-  private boolean jj_3R_160()
+  private boolean jj_3R_111()
  {
-    if (jj_3R_162()) return true;
+    if (jj_scan_token(IF)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_163()) jj_scanpos = xsp;
+    if (jj_3R_253()) {
+    jj_scanpos = xsp;
+    if (jj_3_32()) return true;
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_254()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_112()
+  private boolean jj_3R_162()
  {
-    if (jj_scan_token(FOR)) return true;
-    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_164()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_246()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMICOLON)) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_247()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMICOLON)) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_248()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_3R_165()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_163()
+  private boolean jj_3R_165()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_166()) {
+    if (jj_3R_168()) {
     jj_scanpos = xsp;
-    if (jj_3R_167()) return true;
+    if (jj_3R_169()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_166()
+  private boolean jj_3R_168()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7847,138 +8145,113 @@ private boolean jj_3R_166()
     jj_scanpos = xsp;
     if (jj_scan_token(37)) return true;
     }
-    if (jj_3R_44()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_167()
- {
-    if (jj_scan_token(AS)) return true;
-    if (jj_3R_44()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_244()
+  private boolean jj_3R_112()
  {
-    if (jj_scan_token(SEMICOLON)) return true;
+    if (jj_scan_token(WHILE)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_247()
+  private boolean jj_3R_169()
  {
-    if (jj_3R_51()) return true;
+    if (jj_scan_token(AS)) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_162()
+  private boolean jj_3R_164()
  {
-    if (jj_3R_164()) return true;
+    if (jj_3R_166()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_165()) { jj_scanpos = xsp; break; }
+      if (jj_3R_167()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_248()
+  private boolean jj_3R_113()
  {
-    if (jj_3R_254()) return true;
+    if (jj_scan_token(DO)) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(WHILE)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_42()) return true;
     return false;
   }
 
-  private boolean jj_3R_165()
+  private boolean jj_3R_167()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(89)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(90)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(87)) {
+    if (jj_scan_token(91)) {
     jj_scanpos = xsp;
     if (jj_scan_token(88)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(94)) {
+    if (jj_scan_token(89)) {
     jj_scanpos = xsp;
     if (jj_scan_token(95)) {
     jj_scanpos = xsp;
     if (jj_scan_token(96)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(97)) return true;
-    }
+    if (jj_scan_token(97)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(98)) return true;
     }
     }
     }
     }
     }
     }
-    if (jj_3R_164()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_246()
- {
-    if (jj_3R_253()) return true;
-    return false;
-  }
-
-  private boolean jj_3_33()
- {
-    if (jj_scan_token(FOR)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_51()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_57()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_113()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_33()) {
-    jj_scanpos = xsp;
-    if (jj_3R_140()) return true;
     }
+    if (jj_3R_166()) return true;
     return false;
   }
 
-  private boolean jj_3R_140()
+  private boolean jj_3R_114()
  {
     if (jj_scan_token(FOR)) return true;
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3R_255()) jj_scanpos = xsp;
-    if (jj_3R_44()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_51()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_256()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_257()) jj_scanpos = xsp;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_164()
+  private boolean jj_3R_166()
  {
-    if (jj_3R_168()) return true;
+    if (jj_3R_170()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_169()) { jj_scanpos = xsp; break; }
+      if (jj_3R_171()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_169()
+  private boolean jj_3R_171()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(119)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(120)) {
     jj_scanpos = xsp;
     if (jj_scan_token(121)) {
@@ -7987,30 +8260,21 @@ private boolean jj_3R_169()
     jj_scanpos = xsp;
     if (jj_scan_token(123)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(124)) return true;
+    if (jj_scan_token(124)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(125)) return true;
     }
     }
     }
     }
     }
-    if (jj_3R_168()) return true;
+    if (jj_3R_170()) return true;
     return false;
   }
 
   private boolean jj_3R_253()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_261()) {
-    jj_scanpos = xsp;
-    if (jj_3R_262()) return true;
-    }
-    return false;
-  }
-
-  private boolean jj_3R_261()
- {
-    if (jj_3R_97()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
@@ -8028,7 +8292,7 @@ private boolean jj_3R_261()
   private boolean jj_lookingAhead = false;
   private boolean jj_semLA;
   private int jj_gen;
-  final private int[] jj_la1 = new int[121];
+  final private int[] jj_la1 = new int[124];
   static private int[] jj_la1_0;
   static private int[] jj_la1_1;
   static private int[] jj_la1_2;
@@ -8042,19 +8306,19 @@ private boolean jj_3R_261()
 	   jj_la1_init_4();
 	}
 	private static void jj_la1_init_0() {
-	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
+	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x49849000,0x0,0x49849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_1() {
-	   jj_la1_1 = new int[] {0x0,0x20d9c400,0x20d9c400,0x0,0x4,0x0,0x100,0x4,0x100,0x0,0x80000,0x0,0x0,0x0,0x10040280,0x2000000,0x80000,0x80000,0x0,0x8,0x0,0x0,0x94041a80,0x94041a80,0x0,0x0,0x40280,0x0,0x0,0x0,0x40280,0x10040280,0x40280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x70,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x94041a80,0x0,0x940c1a80,0x94001800,0x0,0x94041a80,0x94041a80,0x94041a80,0x94041a80,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x94001000,0x4000000,0x94041a80,0x0,0x0,0x40280,0x800,0x0,0x0,0xd4241a82,0x9420000,0x80000,0x2008,0x0,0x0,0x0,0x0,0x0,0x0,0xb4ddde80,0x94041a80,0x94041a80,0x0,0x0,0x94041a80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_1 = new int[] {0x0,0x20d9c400,0x20d9c400,0x0,0x4,0x0,0x100,0x4,0x100,0x0,0x80000,0x0,0x0,0x0,0x10040280,0x2000000,0x80000,0x80000,0x0,0x8,0x0,0x0,0x54041a80,0x54041a80,0x0,0x0,0x40280,0x0,0x0,0x0,0x40280,0x10040280,0x40280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x70,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x54041a80,0x0,0x540c1a80,0x54041a80,0x0,0x54041a80,0x54001800,0x0,0x54041a80,0x54041a80,0x54041a80,0x54041a80,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x14001000,0x4000000,0x54041a80,0x0,0x0,0x40280,0x800,0x0,0x0,0xd4241a82,0x9420000,0x80000,0x2008,0x0,0x0,0x0,0x0,0x0,0x0,0x74ddde80,0x54041a80,0x54041a80,0x0,0x0,0x54041a80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_2() {
-	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x8000,0x400,0x100000,0x80000,0x400,0x0,0x8000,0x0,0x200000,0x0,0x20000,0x400000,0x1802a790,0x1802a790,0x100000,0x100000,0x400,0x0,0x0,0x400,0x400,0x400,0x0,0x100000,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x0,0x0,0xc7800000,0xc7800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18000000,0x0,0x0,0x0,0x18000000,0x2a790,0x2400,0x1802a790,0x2a390,0x400,0x1802a790,0x1802a790,0x1802a790,0x1802a790,0x0,0x0,0x0,0x400,0x2000,0x2000,0x20000,0x8000,0x390,0x0,0x1802a790,0x100000,0x2a000,0x28400,0x28000,0x20000,0x28000,0x180aa790,0x0,0x0,0x0,0x80000,0x80000,0x0,0x0,0x80000,0x0,0x1802a790,0x1802a790,0x1802a790,0x0,0x0,0x1802a790,0x100000,0x100000,0x2000,0x0,0x0,0x0,0x0,0x400,0x80000,0x400,};
+	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x10000,0x800,0x200000,0x100000,0x800,0x0,0x10000,0x0,0x400000,0x0,0x40000,0x800000,0x30054f21,0x30054f21,0x200000,0x200000,0x800,0x0,0x0,0x800,0x800,0x800,0x0,0x200000,0x800000,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x0,0x0,0x8f000000,0x8f000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x0,0x30000000,0x54f21,0x4800,0x30054f21,0x30054f21,0x200000,0x30054f21,0x54721,0x800,0x30054f21,0x30054f21,0x30054f21,0x30054f21,0x0,0x0,0x0,0x800,0x4000,0x4000,0x40000,0x10000,0x721,0x0,0x30054f21,0x200000,0x54000,0x50800,0x50000,0x40000,0x50000,0x30154f21,0x0,0x0,0x0,0x100000,0x100000,0x0,0x0,0x100000,0x0,0x30054f21,0x30054f21,0x30054f21,0x0,0x0,0x30054f21,0x200000,0x200000,0x4000,0x0,0x0,0x0,0x0,0x800,0x100000,0x800,};
 	}
 	private static void jj_la1_init_3() {
-	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe0000000,0xe0000000,0x0,0x0,0x0,0x18,0x18,0x60,0x60,0x18000,0x18000,0x60000,0x60000,0x6000,0x6000,0x4,0x4,0x0,0x0,0x0,0x3,0x3,0x1f800000,0x1f800000,0x600,0x600,0x181800,0x181800,0x600000,0x600000,0x600,0x180,0x180,0x180,0x780,0x0,0x0,0x780,0x0,0x0,0x780,0x780,0x780,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x780,0x780,0x780,0x0,0x0,0x780,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,};
+	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0xc0000000,0x0,0x0,0x0,0x30,0x30,0xc0,0xc0,0x30000,0x30000,0xc0000,0xc0000,0xc000,0xc000,0x8,0x8,0x0,0x0,0x0,0x7,0x7,0x3f000000,0x3f000000,0xc00,0xc00,0x303000,0x303000,0xc00000,0xc00000,0xc00,0x300,0x300,0x300,0xf00,0x0,0x0,0xf00,0xf00,0x0,0xf00,0x0,0x0,0xf00,0xf00,0xf00,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0xf00,0xf00,0x0,0x0,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_4() {
-	   jj_la1_4 = new int[] {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,0x2000000,0x0,0x0,0x0,0x0,0x0,0x9ffff,0x9ffff,0x400000,0x340000,0x340000,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,0x800000,0x1800000,0x1800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_4 = new int[] {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,0x4000000,0x0,0x0,0x0,0x0,0x0,0x13ffff,0x13ffff,0x800000,0x680000,0x680000,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,0x1000000,0x3000000,0x3000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
   private final JJCalls[] jj_2_rtns = new JJCalls[38];
   private boolean jj_rescan = false;
@@ -8071,7 +8335,7 @@ public Parser(final java.io.InputStream stream, final java.nio.charset.Charset e
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8086,7 +8350,7 @@ public void ReInit(final java.io.InputStream stream, final java.nio.charset.Char
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8100,7 +8364,7 @@ public Parser(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 121; i++)
+   for (int i = 0; i < 124; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8124,7 +8388,7 @@ public void ReInit(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 121; i++)
+   for (int i = 0; i < 124; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8139,7 +8403,7 @@ public Parser(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8152,7 +8416,7 @@ public void ReInit(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 121; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8297,12 +8561,12 @@ private void jj_add_error_token(int kind, int pos) {
    */
   public ParseException generateParseException() {
     jj_expentries.clear();
-    boolean[] la1tokens = new boolean[156];
+    boolean[] la1tokens = new boolean[157];
     if (jj_kind >= 0) {
       la1tokens[jj_kind] = true;
       jj_kind = -1;
     }
-    for (int i = 0; i < 121; i++) {
+    for (int i = 0; i < 124; i++) {
       if (jj_la1[i] == jj_gen) {
         for (int j = 0; j < 32; j++) {
           if ((jj_la1_0[i] & (1<<j)) != 0) {
@@ -8323,7 +8587,7 @@ public ParseException generateParseException() {
         }
       }
     }
-    for (int i = 0; i < 156; i++) {
+    for (int i = 0; i < 157; i++) {
       if (la1tokens[i]) {
         jj_expentry = new int[1];
         jj_expentry[0] = i;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
index c88706a..708bb29 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
@@ -148,189 +148,191 @@ public interface ParserConstants {
   /** RegularExpression Id. */
   int VOLATILE = 61;
   /** RegularExpression Id. */
-  int WHILE = 62;
+  int WHEN = 62;
   /** RegularExpression Id. */
-  int INTEGER_LITERAL = 63;
+  int WHILE = 63;
   /** RegularExpression Id. */
-  int DECIMAL_LITERAL = 64;
+  int INTEGER_LITERAL = 64;
   /** RegularExpression Id. */
-  int HEX_LITERAL = 65;
+  int DECIMAL_LITERAL = 65;
   /** RegularExpression Id. */
-  int BINARY_LITERAL = 66;
+  int HEX_LITERAL = 66;
   /** RegularExpression Id. */
-  int OCTAL_LITERAL = 67;
+  int BINARY_LITERAL = 67;
   /** RegularExpression Id. */
-  int FLOATING_POINT_LITERAL = 68;
+  int OCTAL_LITERAL = 68;
   /** RegularExpression Id. */
-  int EXPONENT = 69;
+  int FLOATING_POINT_LITERAL = 69;
   /** RegularExpression Id. */
-  int ESCAPE = 70;
+  int EXPONENT = 70;
   /** RegularExpression Id. */
-  int CHARACTER_LITERAL = 71;
+  int ESCAPE = 71;
   /** RegularExpression Id. */
-  int STRING_LITERAL = 72;
+  int CHARACTER_LITERAL = 72;
   /** RegularExpression Id. */
-  int LONG_STRING_LITERAL = 73;
+  int STRING_LITERAL = 73;
   /** RegularExpression Id. */
-  int IDENTIFIER = 74;
+  int LONG_STRING_LITERAL = 74;
   /** RegularExpression Id. */
-  int LETTER = 75;
+  int IDENTIFIER = 75;
   /** RegularExpression Id. */
-  int DIGIT = 76;
+  int LETTER = 76;
   /** RegularExpression Id. */
-  int LPAREN = 77;
+  int DIGIT = 77;
   /** RegularExpression Id. */
-  int RPAREN = 78;
+  int LPAREN = 78;
   /** RegularExpression Id. */
-  int LBRACE = 79;
+  int RPAREN = 79;
   /** RegularExpression Id. */
-  int RBRACE = 80;
+  int LBRACE = 80;
   /** RegularExpression Id. */
-  int LBRACKET = 81;
+  int RBRACE = 81;
   /** RegularExpression Id. */
-  int RBRACKET = 82;
+  int LBRACKET = 82;
   /** RegularExpression Id. */
-  int SEMICOLON = 83;
+  int RBRACKET = 83;
   /** RegularExpression Id. */
-  int COMMA = 84;
+  int SEMICOLON = 84;
   /** RegularExpression Id. */
-  int DOT = 85;
+  int COMMA = 85;
   /** RegularExpression Id. */
-  int ASSIGN = 86;
+  int DOT = 86;
   /** RegularExpression Id. */
-  int GT = 87;
+  int ASSIGN = 87;
   /** RegularExpression Id. */
-  int GTX = 88;
+  int GT = 88;
   /** RegularExpression Id. */
-  int LT = 89;
+  int GTX = 89;
   /** RegularExpression Id. */
-  int LTX = 90;
+  int LT = 90;
   /** RegularExpression Id. */
-  int BANG = 91;
+  int LTX = 91;
   /** RegularExpression Id. */
-  int TILDE = 92;
+  int BANG = 92;
   /** RegularExpression Id. */
-  int EQ = 93;
+  int TILDE = 93;
   /** RegularExpression Id. */
-  int LE = 94;
+  int EQ = 94;
   /** RegularExpression Id. */
-  int LEX = 95;
+  int LE = 95;
   /** RegularExpression Id. */
-  int GE = 96;
+  int LEX = 96;
   /** RegularExpression Id. */
-  int GEX = 97;
+  int GE = 97;
   /** RegularExpression Id. */
-  int NE = 98;
+  int GEX = 98;
   /** RegularExpression Id. */
-  int BOOL_OR = 99;
+  int NE = 99;
   /** RegularExpression Id. */
-  int BOOL_ORX = 100;
+  int BOOL_OR = 100;
   /** RegularExpression Id. */
-  int BOOL_AND = 101;
+  int BOOL_ORX = 101;
   /** RegularExpression Id. */
-  int BOOL_ANDX = 102;
+  int BOOL_AND = 102;
   /** RegularExpression Id. */
-  int INCR = 103;
+  int BOOL_ANDX = 103;
   /** RegularExpression Id. */
-  int DECR = 104;
+  int INCR = 104;
   /** RegularExpression Id. */
-  int PLUS = 105;
+  int DECR = 105;
   /** RegularExpression Id. */
-  int MINUS = 106;
+  int PLUS = 106;
   /** RegularExpression Id. */
-  int STAR = 107;
+  int MINUS = 107;
   /** RegularExpression Id. */
-  int SLASH = 108;
+  int STAR = 108;
   /** RegularExpression Id. */
-  int BIT_AND = 109;
+  int SLASH = 109;
   /** RegularExpression Id. */
-  int BIT_ANDX = 110;
+  int BIT_AND = 110;
   /** RegularExpression Id. */
-  int BIT_OR = 111;
+  int BIT_ANDX = 111;
   /** RegularExpression Id. */
-  int BIT_ORX = 112;
+  int BIT_OR = 112;
   /** RegularExpression Id. */
-  int XOR = 113;
+  int BIT_ORX = 113;
   /** RegularExpression Id. */
-  int XORX = 114;
+  int XOR = 114;
   /** RegularExpression Id. */
-  int MOD = 115;
+  int XORX = 115;
   /** RegularExpression Id. */
-  int MODX = 116;
+  int MOD = 116;
   /** RegularExpression Id. */
-  int POWER = 117;
+  int MODX = 117;
   /** RegularExpression Id. */
-  int POWERX = 118;
+  int POWER = 118;
   /** RegularExpression Id. */
-  int LSHIFT = 119;
+  int POWERX = 119;
   /** RegularExpression Id. */
-  int LSHIFTX = 120;
+  int LSHIFT = 120;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFT = 121;
+  int LSHIFTX = 121;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTX = 122;
+  int RSIGNEDSHIFT = 122;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFT = 123;
+  int RSIGNEDSHIFTX = 123;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTX = 124;
+  int RUNSIGNEDSHIFT = 124;
   /** RegularExpression Id. */
-  int PLUSASSIGN = 125;
+  int RUNSIGNEDSHIFTX = 125;
   /** RegularExpression Id. */
-  int MINUSASSIGN = 126;
+  int PLUSASSIGN = 126;
   /** RegularExpression Id. */
-  int STARASSIGN = 127;
+  int MINUSASSIGN = 127;
   /** RegularExpression Id. */
-  int SLASHASSIGN = 128;
+  int STARASSIGN = 128;
   /** RegularExpression Id. */
-  int ANDASSIGN = 129;
+  int SLASHASSIGN = 129;
   /** RegularExpression Id. */
-  int ANDASSIGNX = 130;
+  int ANDASSIGN = 130;
   /** RegularExpression Id. */
-  int ORASSIGN = 131;
+  int ANDASSIGNX = 131;
   /** RegularExpression Id. */
-  int ORASSIGNX = 132;
+  int ORASSIGN = 132;
   /** RegularExpression Id. */
-  int XORASSIGN = 133;
+  int ORASSIGNX = 133;
   /** RegularExpression Id. */
-  int XORASSIGNX = 134;
+  int XORASSIGN = 134;
   /** RegularExpression Id. */
-  int MODASSIGN = 135;
+  int XORASSIGNX = 135;
   /** RegularExpression Id. */
-  int MODASSIGNX = 136;
+  int MODASSIGN = 136;
   /** RegularExpression Id. */
-  int POWERASSIGN = 137;
+  int MODASSIGNX = 137;
   /** RegularExpression Id. */
-  int POWERASSIGNX = 138;
+  int POWERASSIGN = 138;
   /** RegularExpression Id. */
-  int LSHIFTASSIGN = 139;
+  int POWERASSIGNX = 139;
   /** RegularExpression Id. */
-  int LSHIFTASSIGNX = 140;
+  int LSHIFTASSIGN = 140;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGN = 141;
+  int LSHIFTASSIGNX = 141;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGNX = 142;
+  int RSIGNEDSHIFTASSIGN = 142;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGN = 143;
+  int RSIGNEDSHIFTASSIGNX = 143;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGNX = 144;
+  int RUNSIGNEDSHIFTASSIGN = 144;
   /** RegularExpression Id. */
-  int ARROW = 145;
+  int RUNSIGNEDSHIFTASSIGNX = 145;
   /** RegularExpression Id. */
-  int SPACESHIP = 146;
+  int ARROW = 146;
   /** RegularExpression Id. */
-  int NULLCOALESCEASSIGN = 147;
+  int SPACESHIP = 147;
   /** RegularExpression Id. */
-  int NULLCOALESCE = 148;
+  int NULLCOALESCEASSIGN = 148;
   /** RegularExpression Id. */
-  int ELVIS = 149;
+  int NULLCOALESCE = 149;
   /** RegularExpression Id. */
-  int HOOK = 150;
+  int ELVIS = 150;
   /** RegularExpression Id. */
-  int COLON = 151;
+  int HOOK = 151;
   /** RegularExpression Id. */
-  int COLON_COLON = 152;
+  int COLON = 152;
   /** RegularExpression Id. */
-  int ELLIPSIS = 153;
+  int COLON_COLON = 153;
+  /** RegularExpression Id. */
+  int ELLIPSIS = 154;
 
   /** Lexical state. */
   int DEFAULT = 0;
@@ -399,6 +401,7 @@ public interface ParserConstants {
     "\"try\"",
     "\"void\"",
     "\"volatile\"",
+    "\"when\"",
     "\"while\"",
     "<INTEGER_LITERAL>",
     "<DECIMAL_LITERAL>",
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
index 10b08cb..3925eb9 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
@@ -38,41 +38,41 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
    switch (pos)
    {
       case 0:
-         if ((active1 & 0x80000042000000L) != 0x0L || (active2 & 0x40800L) != 0x0L)
+         if ((active1 & 0x100000084000000L) != 0x0L || (active2 & 0x81000L) != 0x0L)
             return 75;
-         if ((active1 & 0x200000L) != 0x0L || (active2 & 0x2000000L) != 0x0L)
+         if ((active1 & 0x400000L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
             return 18;
-         if ((active1 & 0x100000000000L) != 0x0L || (active2 & 0x1L) != 0x0L)
+         if ((active1 & 0x200000000000L) != 0x0L || (active2 & 0x2L) != 0x0L)
             return 64;
-         if ((active0 & 0x7ffffffffffff800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0xfffffffffffff800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
          {
-            jjmatchedKind = 74;
+            jjmatchedKind = 75;
             return 42;
          }
          if ((active0 & 0x3eL) != 0x0L)
             return 0;
          return -1;
       case 1:
-         if ((active1 & 0x80000000000000L) != 0x0L || (active2 & 0x800L) != 0x0L)
+         if ((active1 & 0x100000000000000L) != 0x0L || (active2 & 0x1000L) != 0x0L)
             return 75;
          if ((active0 & 0x6200c00000L) != 0x0L)
             return 42;
-         if ((active0 & 0x7fffff9dff3ff800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0xffffff9dff3ff800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
          {
             if (jjmatchedPos != 1)
             {
-               jjmatchedKind = 74;
+               jjmatchedKind = 75;
                jjmatchedPos = 1;
             }
             return 42;
          }
          return -1;
       case 2:
-         if ((active0 & 0x77fff61d7fbff800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0xf7fff61d7fbff800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
          {
             if (jjmatchedPos != 2)
             {
-               jjmatchedKind = 74;
+               jjmatchedKind = 75;
                jjmatchedPos = 2;
             }
             return 42;
@@ -81,26 +81,26 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
             return 42;
          return -1;
       case 3:
-         if ((active0 & 0x1400120103058000L) != 0x0L)
+         if ((active0 & 0x5400120103058000L) != 0x0L)
             return 42;
-         if ((active0 & 0x63ffe51c7cba7800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0xa3ffe51c7cba7800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
          {
             if (jjmatchedPos != 3)
             {
-               jjmatchedKind = 74;
+               jjmatchedKind = 75;
                jjmatchedPos = 3;
             }
             return 42;
          }
          return -1;
       case 4:
-         if ((active0 & 0x43040000780a6000L) != 0x0L)
+         if ((active0 & 0x83040000780a6000L) != 0x0L)
             return 42;
-         if ((active0 & 0x20fbe51c04b01800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0x20fbe51c04b01800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
          {
             if (jjmatchedPos != 4)
             {
-               jjmatchedKind = 74;
+               jjmatchedKind = 75;
                jjmatchedPos = 4;
             }
             return 42;
@@ -109,9 +109,9 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
       case 5:
          if ((active0 & 0x22b040800800000L) != 0x0L)
             return 42;
-         if ((active0 & 0x20d0e11424301800L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0x20d0e11424301800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
          {
-            jjmatchedKind = 74;
+            jjmatchedKind = 75;
             jjmatchedPos = 5;
             return 42;
          }
@@ -121,12 +121,12 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
          {
             if (jjmatchedPos != 6)
             {
-               jjmatchedKind = 74;
+               jjmatchedKind = 75;
                jjmatchedPos = 6;
             }
             return 42;
          }
-         if ((active0 & 0x600024201000L) != 0x0L || (active2 & 0x8000000L) != 0x0L)
+         if ((active0 & 0x600024201000L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
             return 42;
          return -1;
       case 7:
@@ -134,7 +134,7 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
             return 42;
          if ((active0 & 0xc0811400000000L) != 0x0L)
          {
-            jjmatchedKind = 74;
+            jjmatchedKind = 75;
             jjmatchedPos = 7;
             return 42;
          }
@@ -144,7 +144,7 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
             return 42;
          if ((active0 & 0x40001400000000L) != 0x0L)
          {
-            jjmatchedKind = 74;
+            jjmatchedKind = 75;
             jjmatchedPos = 8;
             return 42;
          }
@@ -154,7 +154,7 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
             return 42;
          if ((active0 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 74;
+            jjmatchedKind = 75;
             jjmatchedPos = 9;
             return 42;
          }
@@ -164,7 +164,7 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
          {
             if (jjmatchedPos != 10)
             {
-               jjmatchedKind = 74;
+               jjmatchedKind = 75;
                jjmatchedPos = 10;
             }
             return 42;
@@ -201,61 +201,61 @@ private int jjMoveStringLiteralDfa0_0(){
       case ' ':
          return jjStartNfaWithStates_0(0, 1, 0);
       case '!':
-         jjmatchedKind = 91;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L, 0x0L);
+         jjmatchedKind = 92;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000L, 0x0L);
       case '%':
-         jjmatchedKind = 115;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x80L);
+         jjmatchedKind = 116;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x100L);
       case '&':
-         jjmatchedKind = 109;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000L, 0x2L);
+         jjmatchedKind = 110;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000L, 0x4L);
       case '(':
-         return jjStopAtPos(0, 77);
-      case ')':
          return jjStopAtPos(0, 78);
+      case ')':
+         return jjStopAtPos(0, 79);
       case '*':
-         jjmatchedKind = 107;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x8020000000000000L, 0x200L);
+         jjmatchedKind = 108;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L, 0x401L);
       case '+':
-         jjmatchedKind = 105;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000008000000000L, 0x0L);
+         jjmatchedKind = 106;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000010000000000L, 0x0L);
       case ',':
-         return jjStopAtPos(0, 84);
+         return jjStopAtPos(0, 85);
       case '-':
-         jjmatchedKind = 106;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000010000000000L, 0x20000L);
+         jjmatchedKind = 107;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000020000000000L, 0x40000L);
       case '.':
-         jjmatchedKind = 85;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2000000L);
+         jjmatchedKind = 86;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x4000000L);
       case '/':
-         jjmatchedKind = 108;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1L);
+         jjmatchedKind = 109;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2L);
       case ':':
-         jjmatchedKind = 151;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1000000L);
+         jjmatchedKind = 152;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2000000L);
       case ';':
-         return jjStopAtPos(0, 83);
+         return jjStopAtPos(0, 84);
       case '<':
-         jjmatchedKind = 89;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x80000040000000L, 0x40800L);
+         jjmatchedKind = 90;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000080000000L, 0x81000L);
       case '=':
-         jjmatchedKind = 86;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L, 0x0L);
-      case '>':
          jjmatchedKind = 87;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0xa00000100000000L, 0xa000L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L, 0x0L);
+      case '>':
+         jjmatchedKind = 88;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1400000200000000L, 0x14000L);
       case '?':
-         jjmatchedKind = 150;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x4380000L);
+         jjmatchedKind = 151;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x8700000L);
       case '@':
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x1555405285000000L, 0x15554L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2aaa80a50a000000L, 0x2aaa8L);
       case '[':
-         return jjStopAtPos(0, 81);
-      case ']':
          return jjStopAtPos(0, 82);
+      case ']':
+         return jjStopAtPos(0, 83);
       case '^':
-         jjmatchedKind = 113;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x20L);
+         jjmatchedKind = 114;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x40L);
       case 'a':
          return jjMoveStringLiteralDfa1_0(0x4000000800L, 0x0L, 0x0L);
       case 'b':
@@ -263,7 +263,7 @@ private int jjMoveStringLiteralDfa0_0(){
       case 'c':
          return jjMoveStringLiteralDfa1_0(0x1f4000L, 0x0L, 0x0L);
       case 'd':
-         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x8000000L);
+         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x10000000L);
       case 'e':
          return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L, 0x0L);
       case 'f':
@@ -287,16 +287,16 @@ private int jjMoveStringLiteralDfa0_0(){
       case 'v':
          return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x0L, 0x0L);
       case '{':
-         return jjStopAtPos(0, 79);
+         return jjStopAtPos(0, 80);
       case '|':
-         jjmatchedKind = 111;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000L, 0x8L);
+         jjmatchedKind = 112;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000L, 0x10L);
       case '}':
-         return jjStopAtPos(0, 80);
+         return jjStopAtPos(0, 81);
       case '~':
-         return jjStopAtPos(0, 92);
+         return jjStopAtPos(0, 93);
       default :
          return jjMoveNfa_0(1, 0);
    }
@@ -310,55 +310,53 @@ private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){
    switch(curChar)
    {
       case '&':
-         if ((active1 & 0x2000000000L) != 0x0L)
-            return jjStopAtPos(1, 101);
+         if ((active1 & 0x4000000000L) != 0x0L)
+            return jjStopAtPos(1, 102);
          break;
       case '*':
-         if ((active1 & 0x20000000000000L) != 0x0L)
+         if ((active1 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 117;
+            jjmatchedKind = 118;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x200L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
       case '+':
-         if ((active1 & 0x8000000000L) != 0x0L)
-            return jjStopAtPos(1, 103);
-         break;
-      case '-':
          if ((active1 & 0x10000000000L) != 0x0L)
             return jjStopAtPos(1, 104);
          break;
+      case '-':
+         if ((active1 & 0x20000000000L) != 0x0L)
+            return jjStopAtPos(1, 105);
+         break;
       case '.':
-         if ((active2 & 0x4000000L) != 0x0L)
-            return jjStopAtPos(1, 154);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x2000000L);
+         if ((active2 & 0x8000000L) != 0x0L)
+            return jjStopAtPos(1, 155);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x4000000L);
       case ':':
-         if ((active2 & 0x200000L) != 0x0L)
-            return jjStopAtPos(1, 149);
-         else if ((active2 & 0x1000000L) != 0x0L)
-            return jjStopAtPos(1, 152);
+         if ((active2 & 0x400000L) != 0x0L)
+            return jjStopAtPos(1, 150);
+         else if ((active2 & 0x2000000L) != 0x0L)
+            return jjStopAtPos(1, 153);
          break;
       case '<':
-         if ((active1 & 0x80000000000000L) != 0x0L)
+         if ((active1 & 0x100000000000000L) != 0x0L)
          {
-            jjmatchedKind = 119;
+            jjmatchedKind = 120;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
       case '=':
-         if ((active1 & 0x20000000L) != 0x0L)
-            return jjStopAtPos(1, 93);
-         else if ((active1 & 0x40000000L) != 0x0L)
+         if ((active1 & 0x40000000L) != 0x0L)
+            return jjStopAtPos(1, 94);
+         else if ((active1 & 0x80000000L) != 0x0L)
          {
-            jjmatchedKind = 94;
+            jjmatchedKind = 95;
             jjmatchedPos = 1;
          }
-         else if ((active1 & 0x100000000L) != 0x0L)
-            return jjStopAtPos(1, 96);
-         else if ((active1 & 0x400000000L) != 0x0L)
-            return jjStopAtPos(1, 98);
-         else if ((active1 & 0x2000000000000000L) != 0x0L)
-            return jjStopAtPos(1, 125);
+         else if ((active1 & 0x200000000L) != 0x0L)
+            return jjStopAtPos(1, 97);
+         else if ((active1 & 0x800000000L) != 0x0L)
+            return jjStopAtPos(1, 99);
          else if ((active1 & 0x4000000000000000L) != 0x0L)
             return jjStopAtPos(1, 126);
          else if ((active1 & 0x8000000000000000L) != 0x0L)
@@ -367,49 +365,51 @@ else if ((active2 & 0x1L) != 0x0L)
             return jjStopAtPos(1, 128);
          else if ((active2 & 0x2L) != 0x0L)
             return jjStopAtPos(1, 129);
-         else if ((active2 & 0x8L) != 0x0L)
-            return jjStopAtPos(1, 131);
-         else if ((active2 & 0x20L) != 0x0L)
-            return jjStopAtPos(1, 133);
-         else if ((active2 & 0x80L) != 0x0L)
-            return jjStopAtPos(1, 135);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x40000L);
+         else if ((active2 & 0x4L) != 0x0L)
+            return jjStopAtPos(1, 130);
+         else if ((active2 & 0x10L) != 0x0L)
+            return jjStopAtPos(1, 132);
+         else if ((active2 & 0x40L) != 0x0L)
+            return jjStopAtPos(1, 134);
+         else if ((active2 & 0x100L) != 0x0L)
+            return jjStopAtPos(1, 136);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x80000L);
       case '>':
-         if ((active1 & 0x200000000000000L) != 0x0L)
+         if ((active1 & 0x400000000000000L) != 0x0L)
          {
-            jjmatchedKind = 121;
+            jjmatchedKind = 122;
             jjmatchedPos = 1;
          }
-         else if ((active2 & 0x20000L) != 0x0L)
-            return jjStopAtPos(1, 145);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0xa000L);
+         else if ((active2 & 0x40000L) != 0x0L)
+            return jjStopAtPos(1, 146);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x14000L);
       case '?':
-         if ((active2 & 0x100000L) != 0x0L)
+         if ((active2 & 0x200000L) != 0x0L)
          {
-            jjmatchedKind = 148;
+            jjmatchedKind = 149;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x80000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x100000L);
       case 'a':
-         return jjMoveStringLiteralDfa2_0(active0, 0x240008030000L, active1, 0x4000000000L, active2, 0x4L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x240008030000L, active1, 0x8000000000L, active2, 0x8L);
       case 'b':
-         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x5400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0xa800000000000L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa2_0(active0, 0x2080000200000L, active1, 0x0L, active2, 0x8000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x2080000200000L, active1, 0x0L, active2, 0x10000000L);
       case 'f':
          if ((active0 & 0x200000000L) != 0x0L)
             return jjStartNfaWithStates_0(1, 33, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x201000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x402000000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa2_0(active0, 0x4304000000040000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc304000000040000L, active1, 0x0L, active2, 0x0L);
       case 'i':
          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x100000084000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x200000108000000L, active2, 0x2000L);
       case 'm':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x10000000000000L, active2, 0x100L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x20000000000000L, active2, 0x200L);
       case 'n':
          return jjMoveStringLiteralDfa2_0(active0, 0x19002000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
@@ -418,11 +418,11 @@ else if ((active2 & 0x20000L) != 0x0L)
             jjmatchedKind = 22;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x3000020180981000L, active1, 0x1000000000L, active2, 0x10L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x3000020180981000L, active1, 0x2000000000L, active2, 0x20L);
       case 'p':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x40000000000000L, active2, 0x400L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'r':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc80c00000002000L, active1, 0x1400000000000000L, active2, 0x14000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc80c00000002000L, active1, 0x2800000000000000L, active2, 0x28000L);
       case 's':
          if ((active0 & 0x2000000000L) != 0x0L)
             return jjStartNfaWithStates_0(1, 37, 42);
@@ -436,12 +436,12 @@ else if ((active0 & 0x4000000000L) != 0x0L)
       case 'w':
          return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 'x':
-         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x40L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x80L);
       case 'y':
          return jjMoveStringLiteralDfa2_0(active0, 0x40000000008000L, active1, 0x0L, active2, 0x0L);
       case '|':
-         if ((active1 & 0x800000000L) != 0x0L)
-            return jjStopAtPos(1, 99);
+         if ((active1 & 0x1000000000L) != 0x0L)
+            return jjStopAtPos(1, 100);
          break;
       default :
          break;
@@ -459,28 +459,28 @@ private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '.':
-         if ((active2 & 0x2000000L) != 0x0L)
-            return jjStopAtPos(2, 153);
+         if ((active2 & 0x4000000L) != 0x0L)
+            return jjStopAtPos(2, 154);
          break;
       case '=':
-         if ((active2 & 0x200L) != 0x0L)
-            return jjStopAtPos(2, 137);
-         else if ((active2 & 0x800L) != 0x0L)
-            return jjStopAtPos(2, 139);
-         else if ((active2 & 0x2000L) != 0x0L)
-            return jjStopAtPos(2, 141);
-         else if ((active2 & 0x80000L) != 0x0L)
-            return jjStopAtPos(2, 147);
+         if ((active2 & 0x400L) != 0x0L)
+            return jjStopAtPos(2, 138);
+         else if ((active2 & 0x1000L) != 0x0L)
+            return jjStopAtPos(2, 140);
+         else if ((active2 & 0x4000L) != 0x0L)
+            return jjStopAtPos(2, 142);
+         else if ((active2 & 0x100000L) != 0x0L)
+            return jjStopAtPos(2, 148);
          break;
       case '>':
-         if ((active1 & 0x800000000000000L) != 0x0L)
+         if ((active1 & 0x1000000000000000L) != 0x0L)
          {
-            jjmatchedKind = 123;
+            jjmatchedKind = 124;
             jjmatchedPos = 2;
          }
-         else if ((active2 & 0x40000L) != 0x0L)
-            return jjStopAtPos(2, 146);
-         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x8000L);
+         else if ((active2 & 0x80000L) != 0x0L)
+            return jjStopAtPos(2, 147);
+         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x10000L);
       case 'a':
          return jjMoveStringLiteralDfa3_0(active0, 0x88000000044000L, active1, 0x0L, active2, 0x0L);
       case 'b':
@@ -488,28 +488,28 @@ else if ((active2 & 0x40000L) != 0x0L)
       case 'c':
          return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa3_0(active0, 0x2000L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x4000000000002000L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'f':
-         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x8000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x10000000L);
       case 'i':
-         return jjMoveStringLiteralDfa3_0(active0, 0x5020400000000000L, active1, 0x1405400000000000L, active2, 0x14000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x9020400000000000L, active1, 0x280a800000000000L, active2, 0x28000L);
       case 'l':
          return jjMoveStringLiteralDfa3_0(active0, 0x2000100008000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa3_0(active0, 0x40020030180000L, active1, 0x4000000000L, active2, 0x4L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x40020030180000L, active1, 0x8000000000L, active2, 0x8L);
       case 'o':
-         return jjMoveStringLiteralDfa3_0(active0, 0x4800040001000L, active1, 0x50000000000000L, active2, 0x540L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x4800040001000L, active1, 0xa0000000000000L, active2, 0xa80L);
       case 'p':
          return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x80000000L) != 0x0L)
             return jjStartNfaWithStates_0(2, 31, 42);
-         else if ((active1 & 0x1000000000L) != 0x0L)
+         else if ((active1 & 0x2000000000L) != 0x0L)
          {
-            jjmatchedKind = 100;
+            jjmatchedKind = 101;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x310000000000000L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x310000000000000L, active1, 0x0L, active2, 0x20L);
       case 's':
          return jjMoveStringLiteralDfa3_0(active0, 0x1001010800L, active1, 0x0L, active2, 0x0L);
       case 't':
@@ -518,17 +518,17 @@ else if ((active1 & 0x1000000000L) != 0x0L)
             jjmatchedKind = 39;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x1000000L) != 0x0L)
+         else if ((active1 & 0x2000000L) != 0x0L)
          {
-            jjmatchedKind = 88;
+            jjmatchedKind = 89;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x4000000L) != 0x0L)
+         else if ((active1 & 0x8000000L) != 0x0L)
          {
-            jjmatchedKind = 90;
+            jjmatchedKind = 91;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x2050104028000L, active1, 0x280000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2050104028000L, active1, 0x500000000L, active2, 0x0L);
       case 'u':
          return jjMoveStringLiteralDfa3_0(active0, 0x400000002800000L, active1, 0x0L, active2, 0x0L);
       case 'w':
@@ -555,13 +555,13 @@ private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '=':
-         if ((active2 & 0x8000L) != 0x0L)
-            return jjStopAtPos(3, 143);
+         if ((active2 & 0x10000L) != 0x0L)
+            return jjStopAtPos(3, 144);
          break;
       case '_':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
       case 'a':
-         return jjMoveStringLiteralDfa4_0(active0, 0x2000000070202000L, active1, 0x0L, active2, 0x8000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000000070202000L, active1, 0x0L, active2, 0x10000000L);
       case 'b':
          return jjMoveStringLiteralDfa4_0(active0, 0x800000L, active1, 0x0L, active2, 0x0L);
       case 'c':
@@ -569,17 +569,17 @@ private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long a
       case 'd':
          if ((active0 & 0x1000000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 60, 42);
-         else if ((active1 & 0x4000000000L) != 0x0L)
+         else if ((active1 & 0x8000000000L) != 0x0L)
          {
-            jjmatchedKind = 102;
+            jjmatchedKind = 103;
             jjmatchedPos = 3;
          }
-         else if ((active1 & 0x10000000000000L) != 0x0L)
+         else if ((active1 & 0x20000000000000L) != 0x0L)
          {
-            jjmatchedKind = 116;
+            jjmatchedKind = 117;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x104L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x208L);
       case 'e':
          if ((active0 & 0x8000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 15, 42);
@@ -589,13 +589,13 @@ else if ((active0 & 0x1000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 24, 42);
          else if ((active0 & 0x400000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 58, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x10004000000L, active1, 0x280000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x10004000000L, active1, 0x500000000L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'g':
          if ((active0 & 0x20000000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 41, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x1400000000000000L, active2, 0x14000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x2800000000000000L, active2, 0x28000L);
       case 'i':
          return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0x0L, active2, 0x0L);
       case 'k':
@@ -603,12 +603,14 @@ else if ((active0 & 0x400000000000000L) != 0x0L)
       case 'l':
          if ((active0 & 0x100000000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 44, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x4001000400001000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x8001000400001000L, active1, 0x0L, active2, 0x0L);
       case 'm':
          if ((active0 & 0x2000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 25, 42);
          break;
       case 'n':
+         if ((active0 & 0x4000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 62, 42);
          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x100000000L) != 0x0L)
@@ -617,22 +619,22 @@ else if ((active0 & 0x400000000000000L) != 0x0L)
       case 'r':
          if ((active0 & 0x40000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 18, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0x0L, active2, 0x40L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0x0L, active2, 0x80L);
       case 's':
          return jjMoveStringLiteralDfa4_0(active0, 0x8084000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa4_0(active0, 0x28801000100800L, active1, 0x5400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x28801000100800L, active1, 0xa800000000000L, active2, 0x0L);
       case 'u':
          return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0x0L, active2, 0x0L);
       case 'v':
          return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active1 & 0x40000000000000L) != 0x0L)
+         if ((active1 & 0x80000000000000L) != 0x0L)
          {
-            jjmatchedKind = 118;
+            jjmatchedKind = 119;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
       default :
          break;
    }
@@ -649,21 +651,21 @@ private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0x544L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0xa88L);
       case 'a':
-         return jjMoveStringLiteralDfa5_0(active0, 0x601000000000L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x601000000000L, active1, 0x0L, active2, 0x20L);
       case 'c':
          return jjMoveStringLiteralDfa5_0(active0, 0x30000000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x8000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 27, 42);
-         else if ((active0 & 0x4000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 62, 42);
+         else if ((active0 & 0x8000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 63, 42);
          return jjMoveStringLiteralDfa5_0(active0, 0x800400001000L, active1, 0x0L, active2, 0x0L);
       case 'h':
          if ((active0 & 0x20000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 17, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x1400000000000000L, active2, 0x14000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x2800000000000000L, active2, 0x28000L);
       case 'i':
          return jjMoveStringLiteralDfa5_0(active0, 0x9000000100000L, active1, 0x0L, active2, 0x0L);
       case 'k':
@@ -680,10 +682,10 @@ else if ((active0 & 0x4000000000000000L) != 0x0L)
       case 'n':
          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'q':
-         if ((active1 & 0x80000000L) != 0x0L)
-            return jjStopAtPos(4, 95);
-         else if ((active1 & 0x200000000L) != 0x0L)
-            return jjStopAtPos(4, 97);
+         if ((active1 & 0x100000000L) != 0x0L)
+            return jjStopAtPos(4, 96);
+         else if ((active1 & 0x400000000L) != 0x0L)
+            return jjStopAtPos(4, 98);
          break;
       case 'r':
          return jjMoveStringLiteralDfa5_0(active0, 0x2010800000800L, active1, 0x0L, active2, 0x0L);
@@ -698,9 +700,9 @@ else if ((active0 & 0x40000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 30, 42);
          else if ((active0 & 0x4000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 50, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'u':
-         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x8000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x10000000L);
       case 'v':
          return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
@@ -709,7 +711,7 @@ else if ((active0 & 0x4000000000000L) != 0x0L)
             jjmatchedKind = 56;
             jjmatchedPos = 4;
          }
-         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0x5400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0xa800000000000L, active2, 0x0L);
       default :
          break;
    }
@@ -726,9 +728,9 @@ private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'a':
-         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0x544L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0xa88L);
       case 'c':
          if ((active0 & 0x1000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 48, 42);
@@ -752,9 +754,9 @@ else if ((active0 & 0x40000000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 53, 42);
          break;
       case 'i':
-         return jjMoveStringLiteralDfa6_0(active0, 0x2080000000000000L, active1, 0x5400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x2080000000000000L, active1, 0xa800000000000L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x8000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x10000000L);
       case 'm':
          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
@@ -766,11 +768,11 @@ else if ((active0 & 0x40000000000L) != 0x0L)
       case 's':
          if ((active0 & 0x200000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 57, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
       case 't':
          if ((active0 & 0x800000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 35, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L, active1, 0x1400000000000000L, active2, 0x14000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L, active1, 0x2800000000000000L, active2, 0x28000L);
       default :
          break;
    }
@@ -787,7 +789,7 @@ private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x1400000000000000L, active2, 0x14000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x2800000000000000L, active2, 0x28000L);
       case 'a':
          return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
@@ -811,14 +813,14 @@ else if ((active0 & 0x400000000000L) != 0x0L)
       case 's':
          if ((active0 & 0x4000000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 26, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x105400000000000L, active2, 0x1554L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x20a800000000000L, active2, 0x2aa8L);
       case 't':
          if ((active0 & 0x200000L) != 0x0L)
          {
             jjmatchedKind = 21;
             jjmatchedPos = 6;
          }
-         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x8000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x10000000L);
       case 'u':
          return jjMoveStringLiteralDfa7_0(active0, 0x100000L, active1, 0x0L, active2, 0x0L);
       case 'y':
@@ -841,8 +843,8 @@ private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case ':':
-         if ((active2 & 0x8000000L) != 0x0L)
-            return jjStopAtPos(7, 155);
+         if ((active2 & 0x10000000L) != 0x0L)
+            return jjStopAtPos(7, 156);
          break;
       case 'c':
          return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
@@ -851,11 +853,11 @@ private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long a
             return jjStartNfaWithStates_0(7, 20, 42);
          else if ((active0 & 0x2000000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(7, 61, 42);
-         return jjMoveStringLiteralDfa8_0(active0, 0x801000000000L, active1, 0x5400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x801000000000L, active1, 0xa800000000000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'i':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
       case 'n':
          return jjMoveStringLiteralDfa8_0(active0, 0xc0000400000000L, active1, 0x0L, active2, 0x0L);
       case 'p':
@@ -863,13 +865,13 @@ else if ((active0 & 0x2000000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(7, 52, 42);
          break;
       case 's':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4544L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8a88L);
       case 't':
          if ((active0 & 0x800L) != 0x0L)
             return jjStartNfaWithStates_0(7, 11, 42);
          break;
       case 'u':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
       default :
          break;
    }
@@ -886,7 +888,7 @@ private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x5400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0xa800000000000L, active2, 0x0L);
       case 'd':
          if ((active0 & 0x800000000000L) != 0x0L)
             return jjStartNfaWithStates_0(8, 47, 42);
@@ -896,13 +898,13 @@ private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long a
             return jjStartNfaWithStates_0(8, 40, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x10L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
       case 'h':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'i':
-         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0x100000000000000L, active2, 0x1544L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0x200000000000000L, active2, 0x2a88L);
       case 'n':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
       case 'o':
          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
@@ -925,27 +927,27 @@ private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x400000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
       case 'f':
          if ((active0 & 0x1000000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 36, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x100000000000000L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'g':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0x544L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0xa88L);
       case 'i':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x10L) != 0x0L)
-            return jjStopAtPos(9, 132);
+         if ((active2 & 0x20L) != 0x0L)
+            return jjStopAtPos(9, 133);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x1000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
       case 's':
          if ((active0 & 0x400000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 34, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
       case 'x':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x4000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x8000000000000L, active2, 0x0L);
       case 'z':
          return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       default :
@@ -966,32 +968,32 @@ private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long
       case 'e':
          return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'i':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
       case 'n':
-         if ((active2 & 0x4L) != 0x0L)
-            return jjStopAtPos(10, 130);
-         else if ((active2 & 0x40L) != 0x0L)
-            return jjStopAtPos(10, 134);
-         else if ((active2 & 0x100L) != 0x0L)
-            return jjStopAtPos(10, 136);
-         else if ((active2 & 0x400L) != 0x0L)
-            return jjStopAtPos(10, 138);
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x400000000000L, active2, 0x0L);
+         if ((active2 & 0x8L) != 0x0L)
+            return jjStopAtPos(10, 131);
+         else if ((active2 & 0x80L) != 0x0L)
+            return jjStopAtPos(10, 135);
+         else if ((active2 & 0x200L) != 0x0L)
+            return jjStopAtPos(10, 137);
+         else if ((active2 & 0x800L) != 0x0L)
+            return jjStopAtPos(10, 139);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
       case 'o':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x4000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x8000000000000L, active2, 0x0L);
       case 'r':
-         if ((active1 & 0x1000000000000L) != 0x0L)
-            return jjStopAtPos(10, 112);
+         if ((active1 & 0x2000000000000L) != 0x0L)
+            return jjStopAtPos(10, 113);
          break;
       case 't':
-         if ((active1 & 0x100000000000000L) != 0x0L)
+         if ((active1 & 0x200000000000000L) != 0x0L)
          {
-            jjmatchedKind = 120;
+            jjmatchedKind = 121;
             jjmatchedPos = 10;
          }
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
       default :
          break;
    }
@@ -1008,26 +1010,26 @@ private int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
       case 'd':
          if ((active0 & 0x40000000000000L) != 0x0L)
             return jjStartNfaWithStates_0(11, 54, 42);
-         else if ((active1 & 0x400000000000L) != 0x0L)
-            return jjStopAtPos(11, 110);
+         else if ((active1 & 0x800000000000L) != 0x0L)
+            return jjStopAtPos(11, 111);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
       case 'r':
-         if ((active1 & 0x4000000000000L) != 0x0L)
-            return jjStopAtPos(11, 114);
+         if ((active1 & 0x8000000000000L) != 0x0L)
+            return jjStopAtPos(11, 115);
          break;
       case 't':
-         if ((active1 & 0x400000000000000L) != 0x0L)
+         if ((active1 & 0x800000000000000L) != 0x0L)
          {
-            jjmatchedKind = 122;
+            jjmatchedKind = 123;
             jjmatchedPos = 11;
          }
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x8000L);
       default :
          break;
    }
@@ -1044,11 +1046,11 @@ private int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x8000L);
       case 'a':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x2000L);
       case 'n':
-         return jjMoveStringLiteralDfa13_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x2000000000000000L, active2, 0x20000L);
       default :
          break;
    }
@@ -1065,11 +1067,11 @@ private int jjMoveStringLiteralDfa13_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x8000L);
       case 'e':
-         return jjMoveStringLiteralDfa14_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x2000000000000000L, active2, 0x20000L);
       case 's':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x2000L);
       default :
          break;
    }
@@ -1086,9 +1088,9 @@ private int jjMoveStringLiteralDfa14_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'd':
-         return jjMoveStringLiteralDfa15_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x2000000000000000L, active2, 0x20000L);
       case 's':
-         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0x5000L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0xa000L);
       default :
          break;
    }
@@ -1105,11 +1107,11 @@ private int jjMoveStringLiteralDfa15_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa16_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x2000000000000000L, active2, 0x20000L);
       case 'i':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x2000L);
       case 's':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x8000L);
       default :
          break;
    }
@@ -1126,11 +1128,11 @@ private int jjMoveStringLiteralDfa16_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x2000L);
       case 'i':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x8000L);
       case 's':
-         return jjMoveStringLiteralDfa17_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x2000000000000000L, active2, 0x20000L);
       default :
          break;
    }
@@ -1147,12 +1149,12 @@ private int jjMoveStringLiteralDfa17_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x4000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x8000L);
       case 'h':
-         return jjMoveStringLiteralDfa18_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x2000000000000000L, active2, 0x20000L);
       case 'n':
-         if ((active2 & 0x1000L) != 0x0L)
-            return jjStopAtPos(17, 140);
+         if ((active2 & 0x2000L) != 0x0L)
+            return jjStopAtPos(17, 141);
          break;
       default :
          break;
@@ -1170,10 +1172,10 @@ private int jjMoveStringLiteralDfa18_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa19_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa19_0(active1, 0x2000000000000000L, active2, 0x20000L);
       case 'n':
-         if ((active2 & 0x4000L) != 0x0L)
-            return jjStopAtPos(18, 142);
+         if ((active2 & 0x8000L) != 0x0L)
+            return jjStopAtPos(18, 143);
          break;
       default :
          break;
@@ -1191,7 +1193,7 @@ private int jjMoveStringLiteralDfa19_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'f':
-         return jjMoveStringLiteralDfa20_0(active1, 0x1000000000000000L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa20_0(active1, 0x2000000000000000L, active2, 0x20000L);
       default :
          break;
    }
@@ -1208,12 +1210,12 @@ private int jjMoveStringLiteralDfa20_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 't':
-         if ((active1 & 0x1000000000000000L) != 0x0L)
+         if ((active1 & 0x2000000000000000L) != 0x0L)
          {
-            jjmatchedKind = 124;
+            jjmatchedKind = 125;
             jjmatchedPos = 20;
          }
-         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x10000L);
+         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x20000L);
       default :
          break;
    }
@@ -1230,7 +1232,7 @@ private int jjMoveStringLiteralDfa21_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa22_0(active2, 0x10000L);
+         return jjMoveStringLiteralDfa22_0(active2, 0x20000L);
       default :
          break;
    }
@@ -1247,7 +1249,7 @@ private int jjMoveStringLiteralDfa22_0(long old2, long active2){
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa23_0(active2, 0x10000L);
+         return jjMoveStringLiteralDfa23_0(active2, 0x20000L);
       default :
          break;
    }
@@ -1264,7 +1266,7 @@ private int jjMoveStringLiteralDfa23_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa24_0(active2, 0x10000L);
+         return jjMoveStringLiteralDfa24_0(active2, 0x20000L);
       default :
          break;
    }
@@ -1281,7 +1283,7 @@ private int jjMoveStringLiteralDfa24_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa25_0(active2, 0x10000L);
+         return jjMoveStringLiteralDfa25_0(active2, 0x20000L);
       default :
          break;
    }
@@ -1298,7 +1300,7 @@ private int jjMoveStringLiteralDfa25_0(long old2, long active2){
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa26_0(active2, 0x10000L);
+         return jjMoveStringLiteralDfa26_0(active2, 0x20000L);
       default :
          break;
    }
@@ -1315,7 +1317,7 @@ private int jjMoveStringLiteralDfa26_0(long old2, long active2){
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa27_0(active2, 0x10000L);
+         return jjMoveStringLiteralDfa27_0(active2, 0x20000L);
       default :
          break;
    }
@@ -1332,8 +1334,8 @@ private int jjMoveStringLiteralDfa27_0(long old2, long active2){
    switch(curChar)
    {
       case 'n':
-         if ((active2 & 0x10000L) != 0x0L)
-            return jjStopAtPos(27, 144);
+         if ((active2 & 0x20000L) != 0x0L)
+            return jjStopAtPos(27, 145);
          break;
       default :
          break;
@@ -1427,8 +1429,8 @@ else if (curChar == 47)
                      { jjAddStates(13, 14); }
                   else if (curChar == 36)
                   {
-                     if (kind > 74)
-                        kind = 74;
+                     if (kind > 75)
+                        kind = 75;
                      { jjCheckNAdd(42); }
                   }
                   else if (curChar == 34)
@@ -1443,14 +1445,14 @@ else if (curChar == 60)
                      { jjCheckNAddStates(0, 3); }
                   if ((0x3fe000000000000L & l) != 0x0L)
                   {
-                     if (kind > 63)
-                        kind = 63;
+                     if (kind > 64)
+                        kind = 64;
                      { jjCheckNAddTwoStates(15, 16); }
                   }
                   else if (curChar == 48)
                   {
-                     if (kind > 63)
-                        kind = 63;
+                     if (kind > 64)
+                        kind = 64;
                      { jjCheckNAddStates(18, 21); }
                   }
                   else if (curChar == 34)
@@ -1517,15 +1519,15 @@ else if (curChar == 34)
                case 14:
                   if ((0x3fe000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 15:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 17:
@@ -1535,8 +1537,8 @@ else if (curChar == 34)
                case 18:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 68)
-                     kind = 68;
+                  if (kind > 69)
+                     kind = 69;
                   { jjCheckNAddStates(28, 30); }
                   break;
                case 20:
@@ -1546,8 +1548,8 @@ else if (curChar == 34)
                case 21:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 68)
-                     kind = 68;
+                  if (kind > 69)
+                     kind = 69;
                   { jjCheckNAddTwoStates(21, 22); }
                   break;
                case 23:
@@ -1562,8 +1564,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(15, 17); }
                   break;
                case 27:
-                  if (curChar == 39 && kind > 71)
-                     kind = 71;
+                  if (curChar == 39 && kind > 72)
+                     kind = 72;
                   break;
                case 28:
                   if (curChar == 34)
@@ -1577,8 +1579,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(22, 24); }
                   break;
                case 32:
-                  if (curChar == 34 && kind > 72)
-                     kind = 72;
+                  if (curChar == 34 && kind > 73)
+                     kind = 73;
                   break;
                case 33:
                case 35:
@@ -1590,8 +1592,8 @@ else if (curChar == 34)
                      { jjCheckNAddStates(31, 33); }
                   break;
                case 36:
-                  if (curChar == 34 && kind > 73)
-                     kind = 73;
+                  if (curChar == 34 && kind > 74)
+                     kind = 74;
                   break;
                case 37:
                   if (curChar == 34)
@@ -1612,15 +1614,15 @@ else if (curChar == 34)
                case 41:
                   if (curChar != 36)
                      break;
-                  if (kind > 74)
-                     kind = 74;
+                  if (kind > 75)
+                     kind = 75;
                   { jjCheckNAdd(42); }
                   break;
                case 42:
                   if ((0x3ff001000000000L & l) == 0x0L)
                      break;
-                  if (kind > 74)
-                     kind = 74;
+                  if (kind > 75)
+                     kind = 75;
                   { jjCheckNAdd(42); }
                   break;
                case 43:
@@ -1634,15 +1636,15 @@ else if (curChar == 34)
                case 45:
                   if (curChar != 46)
                      break;
-                  if (kind > 68)
-                     kind = 68;
+                  if (kind > 69)
+                     kind = 69;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 46:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 68)
-                     kind = 68;
+                  if (kind > 69)
+                     kind = 69;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 48:
@@ -1652,8 +1654,8 @@ else if (curChar == 34)
                case 49:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 68)
-                     kind = 68;
+                  if (kind > 69)
+                     kind = 69;
                   { jjCheckNAddTwoStates(49, 22); }
                   break;
                case 50:
@@ -1667,8 +1669,8 @@ else if (curChar == 34)
                case 53:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 68)
-                     kind = 68;
+                  if (kind > 69)
+                     kind = 69;
                   { jjCheckNAddTwoStates(53, 22); }
                   break;
                case 54:
@@ -1678,36 +1680,36 @@ else if (curChar == 34)
                case 56:
                   if (curChar != 48)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddStates(18, 21); }
                   break;
                case 58:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 60:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 61:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAdd(16); }
                   break;
                case 62:
                   if ((0xff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddTwoStates(62, 16); }
                   break;
                case 63:
@@ -1777,8 +1779,8 @@ else if (curChar < 128)
                case 42:
                   if ((0x7fffffe87fffffeL & l) == 0x0L)
                      break;
-                  if (kind > 74)
-                     kind = 74;
+                  if (kind > 75)
+                     kind = 75;
                   { jjCheckNAdd(42); }
                   break;
                case 9:
@@ -1787,21 +1789,21 @@ else if (curChar < 128)
                case 15:
                   if (curChar != 95)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 16:
-                  if ((0x88920000889200L & l) != 0x0L && kind > 63)
-                     kind = 63;
+                  if ((0x88920000889200L & l) != 0x0L && kind > 64)
+                     kind = 64;
                   break;
                case 19:
                   if ((0x2000000020L & l) != 0x0L)
                      { jjAddStates(43, 44); }
                   break;
                case 22:
-                  if ((0x80005000800050L & l) != 0x0L && kind > 68)
-                     kind = 68;
+                  if ((0x80005000800050L & l) != 0x0L && kind > 69)
+                     kind = 69;
                   break;
                case 24:
                   if ((0xffffffffefffffffL & l) != 0x0L)
@@ -1837,8 +1839,8 @@ else if (curChar < 128)
                      { jjAddStates(47, 48); }
                   break;
                case 55:
-                  if ((0x5000000050L & l) != 0x0L && kind > 68)
-                     kind = 68;
+                  if ((0x5000000050L & l) != 0x0L && kind > 69)
+                     kind = 69;
                   break;
                case 57:
                   if ((0x100000001000000L & l) != 0x0L)
@@ -1847,22 +1849,22 @@ else if (curChar < 128)
                case 58:
                   if ((0x7e8000007eL & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 59:
                   if ((0x400000004L & l) == 0x0L)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 60:
                   if (curChar != 95)
                      break;
-                  if (kind > 63)
-                     kind = 63;
+                  if (kind > 64)
+                     kind = 64;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 65:
@@ -1906,8 +1908,8 @@ else if (curChar < 128)
                   }
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
                   {
-                     if (kind > 74)
-                        kind = 74;
+                     if (kind > 75)
+                        kind = 75;
                      { jjCheckNAdd(42); }
                   }
                   break;
@@ -1940,8 +1942,8 @@ else if (curChar < 128)
                case 42:
                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
                      break;
-                  if (kind > 74)
-                     kind = 74;
+                  if (kind > 75)
+                     kind = 75;
                   { jjCheckNAdd(42); }
                   break;
                case 65:
@@ -1997,10 +1999,10 @@ else if (curChar < 128)
 "\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\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", 
 "\164\162\141\156\163\151\145\156\164", "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\165\145", 
-"\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", 
-null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
-"\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", 
-"\100\147\164", "\74", "\100\154\164", "\41", "\176", "\75\75", "\74\75", 
+"\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\145\156", 
+"\167\150\151\154\145", null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", 
+"\76", "\100\147\164", "\74", "\100\154\164", "\41", "\176", "\75\75", "\74\75", 
 "\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75", "\174\174", "\100\157\162", 
 "\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", 
 "\100\142\151\164\167\151\163\145\137\141\156\144", "\174", "\100\142\151\164\167\151\163\145\137\157\162", "\136", 
@@ -2288,10 +2290,10 @@ public void SwitchTo(int lexState)
    -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, 0xffffffffffffe790L, 0xfffffffL, 
+   0xfffffffffffff801L, 0xffffffffffffcf21L, 0x1fffffffL, 
 };
 static final long[] jjtoSkip = {
    0x7feL, 0x0L, 0x0L, 
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTreeConstants.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTreeConstants.java
index 518f778..0e3680d 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTreeConstants.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTreeConstants.java
@@ -26,26 +26,28 @@ public interface ParserTreeConstants
   public int JJTPRIMARYEXPRESSION = 20;
   public int JJTMETHODINVOCATION = 21;
   public int JJTLAMBDAEXPRESSION = 22;
-  public int JJTPRIMARYSUFFIX = 23;
-  public int JJTLITERAL = 24;
-  public int JJTARGUMENTS = 25;
-  public int JJTALLOCATIONEXPRESSION = 26;
-  public int JJTARRAYDIMENSIONS = 27;
-  public int JJTLABELEDSTATEMENT = 28;
-  public int JJTSWITCHSTATEMENT = 29;
-  public int JJTSWITCHLABEL = 30;
-  public int JJTIFSTATEMENT = 31;
-  public int JJTWHILESTATEMENT = 32;
-  public int JJTFORSTATEMENT = 33;
-  public int JJTENHANCEDFORSTATEMENT = 34;
-  public int JJTTYPEDVARIABLEDECLARATION = 35;
-  public int JJTSTATEMENTEXPRESSIONLIST = 36;
-  public int JJTRETURNSTATEMENT = 37;
-  public int JJTTHROWSTATEMENT = 38;
-  public int JJTTRYSTATEMENT = 39;
-  public int JJTMULTICATCH = 40;
-  public int JJTTRYWITHRESOURCES = 41;
-  public int JJTAUTOCLOSEABLE = 42;
+  public int JJTWHENEXPRESSION = 23;
+  public int JJTWHENENTRY = 24;
+  public int JJTPRIMARYSUFFIX = 25;
+  public int JJTLITERAL = 26;
+  public int JJTARGUMENTS = 27;
+  public int JJTALLOCATIONEXPRESSION = 28;
+  public int JJTARRAYDIMENSIONS = 29;
+  public int JJTLABELEDSTATEMENT = 30;
+  public int JJTSWITCHSTATEMENT = 31;
+  public int JJTSWITCHLABEL = 32;
+  public int JJTIFSTATEMENT = 33;
+  public int JJTWHILESTATEMENT = 34;
+  public int JJTFORSTATEMENT = 35;
+  public int JJTENHANCEDFORSTATEMENT = 36;
+  public int JJTTYPEDVARIABLEDECLARATION = 37;
+  public int JJTSTATEMENTEXPRESSIONLIST = 38;
+  public int JJTRETURNSTATEMENT = 39;
+  public int JJTTHROWSTATEMENT = 40;
+  public int JJTTRYSTATEMENT = 41;
+  public int JJTMULTICATCH = 42;
+  public int JJTTRYWITHRESOURCES = 43;
+  public int JJTAUTOCLOSEABLE = 44;
 
 
   public String[] jjtNodeName = {
@@ -72,6 +74,8 @@ public interface ParserTreeConstants
     "PrimaryExpression",
     "MethodInvocation",
     "LambdaExpression",
+    "WhenExpression",
+    "WhenEntry",
     "PrimarySuffix",
     "Literal",
     "Arguments",
@@ -94,4 +98,4 @@ public interface ParserTreeConstants
     "AutoCloseable",
   };
 }
-/* ParserGeneratorCC - OriginalChecksum=8f20f6be71fceaf418d56fe7f536b30f (do not edit this line) */
+/* ParserGeneratorCC - OriginalChecksum=ffec6fb3060f8e5edbf35756f68095b0 (do not edit this line) */
diff --git a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
index 57960a9..9182739 100644
--- a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
+++ b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
@@ -469,6 +469,7 @@ TOKEN : /* RESERVED WORDS AND LITERALS */
 | < TRY: "try" >
 | < VOID: "void" >
 | < VOLATILE: "volatile" >
+| < WHEN: "when" >
 | < WHILE: "while" >
 }
 
@@ -1094,11 +1095,30 @@ void LambdaExpression() #LambdaExpression :
   { jjtThis.singleParamName = t != null ? t.image : null; }
 }
 
+void WhenExpression() #WhenExpression :
+{}
+{
+  "when" "(" Expression() ")" "{"
+    ( WhenEntry() )+
+  "}"
+}
+
+void WhenEntry() #WhenEntry :
+{ int count = 0; }
+{
+  "else" { jjtThis.isElse = true; } "->" Expression()
+|
+  Expression() { count = 1; } ( "," Expression() { count++; } )*
+  "->" Expression() { jjtThis.numConditions = count; }
+}
+
 void PrimaryPrefix() : { }
 {
   Literal()
 |
   "(" Expression() ")"
+|
+  WhenExpression()
 |
   AllocationExpression()
 |

From 8a13fcd1cc30e0fbd14387c85233ae5d251889b6 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Mon, 27 Apr 2026 10:10:59 +0800
Subject: [PATCH 08/27] fix: skip invalid generic signature

---
 .../src/main/java/bsh/ClassGeneratorUtil.java               | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ClassGeneratorUtil.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ClassGeneratorUtil.java
index ca4d887..a25e7f5 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ClassGeneratorUtil.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ClassGeneratorUtil.java
@@ -342,10 +342,8 @@ private static void generateField(String fieldName, String type, int modifiers,
      * @return parameter type signature
      */
     private static String getTypeParameterSignature(String[] paramTypes) {
-        StringBuilder sb = new StringBuilder("<");
-        for (final String pt : paramTypes)
-            sb.append(pt).append(":");
-        return sb.toString();
+        // TODO: Generate a real generic Signature when generic metadata is preserved.
+        return null;
     }
 
     /** Generate support code needed for Enum types.

From 2377ed4569e5a11638c9af8987c783c4b4b415fe Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Mon, 27 Apr 2026 11:07:41 +0800
Subject: [PATCH 09/27] fix: use Proxy for BshLambda conversion

---
 .../src/main/java/bsh/BshLambda.java          | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java
index 4bf02be..725fe2f 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshLambda.java
@@ -5,6 +5,7 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
+import java.lang.reflect.Proxy;
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Base64;
@@ -122,10 +123,24 @@ protected static boolean isAssignable(Class<?> from, Class<?> to, int round) {
     protected <T> T convertTo(Class<T> functionalInterface) throws UtilEvalError {
         if (!BshLambda.isAssignable(this.dummyType, functionalInterface, Types.BSH_ASSIGNABLE))
             throw new UtilEvalError("This BshLambda can't be converted to " + functionalInterface.getName());
-        Class<T> _class = getClassForFI(functionalInterface);
-
         try {
-            return (T) _class.getConstructors()[0].newInstance(this);
+            return (T) Proxy.newProxyInstance(
+                    functionalInterface.getClassLoader(),
+                    new Class<?>[] { functionalInterface },
+                    (proxy, method, args) -> {
+                        if (method.getDeclaringClass() == Object.class) {
+                            switch (method.getName()) {
+                                case "toString":
+                                    return "BshLambdaProxy[" + this + "]";
+                                case "equals":
+                                    return args != null && args.length == 1 && proxy == args[0];
+                                case "hashCode":
+                                    return System.identityHashCode(proxy);
+                            }
+                        }
+                        return this.invoke(args != null ? args : Reflect.ZERO_ARGS,
+                                method.getExceptionTypes(), method.getReturnType());
+                    });
         } catch (Throwable e) {
             throw new UtilEvalError("Can't create a instance for the generate class for the BshLambda: " + e.getMessage(), e);
         }

From 2c60c8f74452edc9d643468c9ba366d10e377d6b Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Wed, 29 Apr 2026 15:12:45 +0800
Subject: [PATCH 10/27] revert: remove kotlin-style is/as operators

---
 README.md                                     |   10 -
 .../main/java/bsh/BSHBinaryExpression.java    |   14 +-
 .../src/main/java/bsh/Parser.java             | 1644 ++++++++---------
 .../src/main/java/bsh/ParserConstants.java    |  238 ++-
 .../src/main/java/bsh/ParserTokenManager.java |  886 +++++----
 .../src/main/jjtree/bsh.jjt                   |   10 +-
 6 files changed, 1344 insertions(+), 1458 deletions(-)

diff --git a/README.md b/README.md
index 2a4f6cd..ecb32f9 100644
--- a/README.md
+++ b/README.md
@@ -118,16 +118,6 @@ void hi(String name, int age = 18) {
 hi("user") // name: user, age: 18
 hi("user", 1) // name: user, age: 1
 
-// 类型判断
-print(123 is Number) // true
-// 等价
-print(123 instanceof Number) // true
-
-// 类型转换
-print("1" as int) // 1
-// 等价
-print((int) "1") // 1
-
 // 条件分支
 var num = 2
 var out1 = when (num) {
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java
index 5298905..0b9ffcb 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHBinaryExpression.java
@@ -45,7 +45,7 @@ public Object eval( CallStack callstack, Interpreter interpreter)
         /*
             Doing instanceof?  Next node is a type.
         */
-        if ( (kind == INSTANCEOF || kind == IS) )
+        if (kind == INSTANCEOF)
         {
             // null object ref is not instance of any type
             if ( lhs == Primitive.NULL )
@@ -72,18 +72,6 @@ public Object eval( CallStack callstack, Interpreter interpreter)
                     ? Primitive.TRUE : Primitive.FALSE;
         }
 
-        if (kind == AS)
-        {
-            Class<?> rhs = ((BSHType)jjtGetChild(1)).getType(
-                callstack, interpreter );
-
-            try {
-                return Types.castObject( lhs, rhs, Types.CAST );
-            } catch ( UtilEvalError e ) {
-                throw e.toEvalError( this, callstack );
-            }
-        }
-
         /*
             Look ahead and short circuit evaluation of the rhs if:
             we're a boolean AND and the lhs is false.
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
index 9bcfba5..76fbd0d 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
@@ -2054,81 +2054,32 @@ final public void ConditionalExpression() throws ParseException {
   final public void InstanceOfExpression() throws ParseException {Token t = null;
     RelationalExpression();
     switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
-    case INSTANCEOF:
-    case IS:
-    case AS:{
-      switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
-      case INSTANCEOF:
-      case IS:{
-        switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
-        case INSTANCEOF:{
-          t = jj_consume_token(INSTANCEOF);
-          break;
-          }
-        case IS:{
-          t = jj_consume_token(IS);
-          break;
-          }
-        default:
-          jj_la1[51] = jj_gen;
-          jj_consume_token(-1);
-          throw new ParseException();
-        }
-        Type();
+    case INSTANCEOF:{
+      t = jj_consume_token(INSTANCEOF);
+      Type();
 BSHBinaryExpression jjtn001 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
-        boolean jjtc001 = true;
-        jjtree.openNodeScope(jjtn001);
-        jjtreeOpenNodeScope(jjtn001);
-        try {
+                             boolean jjtc001 = true;
+                             jjtree.openNodeScope(jjtn001);
+                             jjtreeOpenNodeScope(jjtn001);
+      try {
 jjtree.closeNodeScope(jjtn001,  2);
-        jjtc001 = false;
-        if (jjtree.nodeCreated()) {
-         jjtreeCloseNodeScope(jjtn001);
-        }
+                             jjtc001 = false;
+                             if (jjtree.nodeCreated()) {
+                              jjtreeCloseNodeScope(jjtn001);
+                             }
 jjtn001.kind = t.kind;
-        } finally {
+      } finally {
 if (jjtc001) {
-          jjtree.closeNodeScope(jjtn001,  2);
-          if (jjtree.nodeCreated()) {
-           jjtreeCloseNodeScope(jjtn001);
-          }
-        }
-        }
-        break;
-        }
-      case AS:{
-        t = jj_consume_token(AS);
-        Type();
-BSHBinaryExpression jjtn002 = new BSHBinaryExpression(JJTBINARYEXPRESSION);
-        boolean jjtc002 = true;
-        jjtree.openNodeScope(jjtn002);
-        jjtreeOpenNodeScope(jjtn002);
-        try {
-jjtree.closeNodeScope(jjtn002,  2);
-        jjtc002 = false;
-        if (jjtree.nodeCreated()) {
-         jjtreeCloseNodeScope(jjtn002);
-        }
-jjtn002.kind = t.kind;
-        } finally {
-if (jjtc002) {
-          jjtree.closeNodeScope(jjtn002,  2);
-          if (jjtree.nodeCreated()) {
-           jjtreeCloseNodeScope(jjtn002);
-          }
-        }
-        }
-        break;
-        }
-      default:
-        jj_la1[52] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
+                               jjtree.closeNodeScope(jjtn001,  2);
+                               if (jjtree.nodeCreated()) {
+                                jjtreeCloseNodeScope(jjtn001);
+                               }
+                             }
       }
       break;
       }
     default:
-      jj_la1[53] = jj_gen;
+      jj_la1[51] = jj_gen;
       ;
     }
 }
@@ -2149,7 +2100,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[54] = jj_gen;
+        jj_la1[52] = jj_gen;
         break label_18;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2186,7 +2137,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[55] = jj_gen;
+        jj_la1[53] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2227,7 +2178,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[56] = jj_gen;
+        jj_la1[54] = jj_gen;
         break label_19;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2256,7 +2207,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[57] = jj_gen;
+        jj_la1[55] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2293,7 +2244,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[58] = jj_gen;
+        jj_la1[56] = jj_gen;
         break label_20;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2306,7 +2257,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[59] = jj_gen;
+        jj_la1[57] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2345,7 +2296,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[60] = jj_gen;
+        jj_la1[58] = jj_gen;
         break label_21;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2366,7 +2317,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[61] = jj_gen;
+        jj_la1[59] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2403,7 +2354,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[62] = jj_gen;
+        jj_la1[60] = jj_gen;
         break label_22;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2416,7 +2367,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[63] = jj_gen;
+        jj_la1[61] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2467,7 +2418,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[64] = jj_gen;
+        jj_la1[62] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2505,7 +2456,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[65] = jj_gen;
+        jj_la1[63] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2532,7 +2483,7 @@ final public void ConditionalExpression() throws ParseException {
       break;
       }
     default:
-      jj_la1[68] = jj_gen;
+      jj_la1[66] = jj_gen;
       if (jj_2_10(2147483647)) {
         LambdaExpression();
       } else if (jj_2_11(2147483647)) {
@@ -2576,7 +2527,7 @@ final public void ConditionalExpression() throws ParseException {
               break;
               }
             default:
-              jj_la1[66] = jj_gen;
+              jj_la1[64] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -2602,13 +2553,13 @@ final public void ConditionalExpression() throws ParseException {
             break;
             }
           default:
-            jj_la1[67] = jj_gen;
+            jj_la1[65] = jj_gen;
             ;
           }
           break;
           }
         default:
-          jj_la1[69] = jj_gen;
+          jj_la1[67] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2737,7 +2688,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[70] = jj_gen;
+        jj_la1[68] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2780,7 +2731,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[71] = jj_gen;
+        jj_la1[69] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2862,7 +2813,7 @@ final public void WhenExpression() throws ParseException {/*@bgen(jjtree) WhenEx
           break;
           }
         default:
-          jj_la1[72] = jj_gen;
+          jj_la1[70] = jj_gen;
           break label_24;
         }
       }
@@ -2943,7 +2894,7 @@ final public void WhenEntry() throws ParseException {/*@bgen(jjtree) WhenEntry *
             break;
             }
           default:
-            jj_la1[73] = jj_gen;
+            jj_la1[71] = jj_gen;
             break label_25;
           }
           jj_consume_token(COMMA);
@@ -2961,7 +2912,7 @@ final public void WhenEntry() throws ParseException {/*@bgen(jjtree) WhenEntry *
         break;
         }
       default:
-        jj_la1[74] = jj_gen;
+        jj_la1[72] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3020,7 +2971,7 @@ final public void PrimaryPrefix() throws ParseException {
       break;
       }
     default:
-      jj_la1[75] = jj_gen;
+      jj_la1[73] = jj_gen;
       if (jj_2_13(2147483647)) {
         MethodInvocation();
       } else if (jj_2_14(2147483647)) {
@@ -3032,7 +2983,7 @@ final public void PrimaryPrefix() throws ParseException {
           break;
           }
         default:
-          jj_la1[76] = jj_gen;
+          jj_la1[74] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3094,7 +3045,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
             break;
             }
           default:
-            jj_la1[77] = jj_gen;
+            jj_la1[75] = jj_gen;
             ;
           }
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3137,7 +3088,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[78] = jj_gen;
+                jj_la1[76] = jj_gen;
                 ;
               }
 jjtn000.slice = true; jjtn000.step = true;
@@ -3181,7 +3132,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[79] = jj_gen;
+                jj_la1[77] = jj_gen;
                 ;
               }
               switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3222,26 +3173,26 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                   break;
                   }
                 default:
-                  jj_la1[80] = jj_gen;
+                  jj_la1[78] = jj_gen;
                   ;
                 }
                 break;
                 }
               default:
-                jj_la1[81] = jj_gen;
+                jj_la1[79] = jj_gen;
                 ;
               }
               break;
               }
             default:
-              jj_la1[82] = jj_gen;
+              jj_la1[80] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
             break;
             }
           default:
-            jj_la1[83] = jj_gen;
+            jj_la1[81] = jj_gen;
             ;
           }
           jj_consume_token(RBRACKET);
@@ -3254,7 +3205,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
           break;
           }
         default:
-          jj_la1[87] = jj_gen;
+          jj_la1[85] = jj_gen;
           if (getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET) {
             jj_consume_token(COLON_COLON);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3267,7 +3218,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[84] = jj_gen;
+              jj_la1[82] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -3279,7 +3230,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
 jjtn000.operation = BSHPrimarySuffix.METHODREF;
     jjtn000.field = t.image;
           } else if (jj_2_16(2)) {
-            jj_consume_token(155);
+            jj_consume_token(153);
             t = jj_consume_token(IDENTIFIER);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
             case LPAREN:{
@@ -3287,7 +3238,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[85] = jj_gen;
+              jj_la1[83] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3307,7 +3258,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[86] = jj_gen;
+              jj_la1[84] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3332,7 +3283,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[88] = jj_gen;
+              jj_la1[86] = jj_gen;
               if (jj_2_18(2)) {
                 jj_consume_token(DOT);
                 AllocationExpression();
@@ -3501,7 +3452,7 @@ final public void Literal() throws ParseException {/*@bgen(jjtree) Literal */
         break;
         }
       default:
-        jj_la1[89] = jj_gen;
+        jj_la1[87] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3542,7 +3493,7 @@ final public boolean BooleanLiteral() throws ParseException {
       break;
       }
     default:
-      jj_la1[90] = jj_gen;
+      jj_la1[88] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
@@ -3598,7 +3549,7 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
         break;
         }
       default:
-        jj_la1[91] = jj_gen;
+        jj_la1[89] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -3636,7 +3587,7 @@ final public void ArgumentList() throws ParseException {
         break;
         }
       default:
-        jj_la1[92] = jj_gen;
+        jj_la1[90] = jj_gen;
         break label_26;
       }
       jj_consume_token(COMMA);
@@ -3684,7 +3635,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[93] = jj_gen;
+            jj_la1[91] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3696,7 +3647,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[94] = jj_gen;
+          jj_la1[92] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3708,7 +3659,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[95] = jj_gen;
+        jj_la1[93] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3777,7 +3728,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
               break;
               }
             default:
-              jj_la1[96] = jj_gen;
+              jj_la1[94] = jj_gen;
               break label_29;
             }
           }
@@ -3795,7 +3746,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
           break;
           }
         default:
-          jj_la1[97] = jj_gen;
+          jj_la1[95] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3889,7 +3840,7 @@ void Statement() throws ParseException {
         break;
         }
       default:
-        jj_la1[98] = jj_gen;
+        jj_la1[96] = jj_gen;
         if (isRegularForStatement()) {
           ForStatement();
         } else {
@@ -3923,7 +3874,7 @@ void Statement() throws ParseException {
             break;
             }
           default:
-            jj_la1[99] = jj_gen;
+            jj_la1[97] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3983,7 +3934,7 @@ final public void Block() throws ParseException {/*@bgen(jjtree) Block */
         break;
         }
       default:
-        jj_la1[100] = jj_gen;
+        jj_la1[98] = jj_gen;
         ;
       }
       jj_consume_token(LBRACE);
@@ -4049,7 +4000,7 @@ final public void BlockStatement() throws ParseException {
         break;
         }
       default:
-        jj_la1[101] = jj_gen;
+        jj_la1[99] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4067,7 +4018,7 @@ final public void MethodDeclTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[102] = jj_gen;
+      jj_la1[100] = jj_gen;
       if (isImplicitMethodTerminator()) {
 
       } else {
@@ -4084,7 +4035,7 @@ final public void StatementTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[103] = jj_gen;
+      jj_la1[101] = jj_gen;
       ;
     }
 }
@@ -4108,11 +4059,11 @@ final public void SwitchStatement() throws ParseException {/*@bgen(jjtree) Switc
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CASE:
-        case 156:{
+        case 154:{
           break;
           }
         default:
-          jj_la1[104] = jj_gen;
+          jj_la1[102] = jj_gen;
           break label_31;
         }
         SwitchLabel();
@@ -4163,8 +4114,8 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         jj_consume_token(COLON);
         break;
         }
-      case 156:{
-        jj_consume_token(156);
+      case 154:{
+        jj_consume_token(154);
 jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                if (jjtree.nodeCreated()) {
@@ -4174,7 +4125,7 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         break;
         }
       default:
-        jj_la1[105] = jj_gen;
+        jj_la1[103] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4219,7 +4170,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[106] = jj_gen;
+        jj_la1[104] = jj_gen;
         if (jj_2_32(1)) {
           Statement();
         } else {
@@ -4234,7 +4185,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[107] = jj_gen;
+        jj_la1[105] = jj_gen;
         ;
       }
     } catch (Throwable jjte000) {
@@ -4398,7 +4349,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[108] = jj_gen;
+        jj_la1[106] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4437,7 +4388,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[109] = jj_gen;
+        jj_la1[107] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4476,7 +4427,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[110] = jj_gen;
+        jj_la1[108] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -4540,7 +4491,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[111] = jj_gen;
+            jj_la1[109] = jj_gen;
             ;
           }
           Type();
@@ -4558,7 +4509,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[112] = jj_gen;
+          jj_la1[110] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4625,7 +4576,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[113] = jj_gen;
+        jj_la1[111] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4654,7 +4605,7 @@ final public void TypedVariableDeclaration() throws ParseException {/*@bgen(jjtr
           break;
           }
         default:
-          jj_la1[114] = jj_gen;
+          jj_la1[112] = jj_gen;
           break label_33;
         }
         jj_consume_token(COMMA);
@@ -4704,7 +4655,7 @@ final public void StatementExpressionList() throws ParseException {/*@bgen(jjtre
           break;
           }
         default:
-          jj_la1[115] = jj_gen;
+          jj_la1[113] = jj_gen;
           break label_34;
         }
         jj_consume_token(COMMA);
@@ -4956,7 +4907,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[116] = jj_gen;
+        jj_la1[114] = jj_gen;
         ;
       }
       Block();
@@ -4967,7 +4918,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
           break;
           }
         default:
-          jj_la1[117] = jj_gen;
+          jj_la1[115] = jj_gen;
           break label_35;
         }
         jj_consume_token(CATCH);
@@ -4985,7 +4936,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[118] = jj_gen;
+        jj_la1[116] = jj_gen;
         ;
       }
 jjtree.closeNodeScope(jjtn000, true);
@@ -5032,7 +4983,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[119] = jj_gen;
+          jj_la1[117] = jj_gen;
           ;
         }
         Type();
@@ -5043,7 +4994,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
             break;
             }
           default:
-            jj_la1[120] = jj_gen;
+            jj_la1[118] = jj_gen;
             break label_36;
           }
           jj_consume_token(BIT_OR);
@@ -5069,7 +5020,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[121] = jj_gen;
+          jj_la1[119] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5113,7 +5064,7 @@ final public void TryWithResources() throws ParseException {/*@bgen(jjtree) TryW
           break;
           }
         default:
-          jj_la1[122] = jj_gen;
+          jj_la1[120] = jj_gen;
           break label_37;
         }
         jj_consume_token(SEMICOLON);
@@ -5160,7 +5111,7 @@ final public void AutoCloseable() throws ParseException {/*@bgen(jjtree) AutoClo
           break;
           }
         default:
-          jj_la1[123] = jj_gen;
+          jj_la1[121] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5569,67 +5520,15 @@ private boolean jj_2_38(int xla)
     finally { jj_save(37, xla); }
   }
 
-  private boolean jj_3R_256()
- {
-    if (jj_3R_53()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_257()
- {
-    if (jj_3R_263()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_170()
- {
-    if (jj_3R_172()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_173()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_255()
- {
-    if (jj_3R_262()) return true;
-    return false;
-  }
-
-  private boolean jj_3_33()
- {
-    if (jj_scan_token(FOR)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_115()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_33()) {
-    jj_scanpos = xsp;
-    if (jj_3R_142()) return true;
-    }
-    return false;
-  }
-
-  private boolean jj_3R_173()
+  private boolean jj_3R_171()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(106)) {
+    if (jj_scan_token(104)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(107)) return true;
+    if (jj_scan_token(105)) return true;
     }
-    if (jj_3R_172()) return true;
+    if (jj_3R_170()) return true;
     return false;
   }
 
@@ -5639,7 +5538,7 @@ private boolean jj_3R_142()
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_264()) jj_scanpos = xsp;
+    if (jj_3R_262()) jj_scanpos = xsp;
     if (jj_3R_46()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_scan_token(COLON)) return true;
@@ -5649,84 +5548,84 @@ private boolean jj_3R_142()
     return false;
   }
 
-  private boolean jj_3R_172()
+  private boolean jj_3R_170()
  {
-    if (jj_3R_174()) return true;
+    if (jj_3R_172()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_175()) { jj_scanpos = xsp; break; }
+      if (jj_3R_173()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_175()
+  private boolean jj_3R_173()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(108)) {
+    if (jj_scan_token(106)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(109)) {
+    if (jj_scan_token(107)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(116)) {
+    if (jj_scan_token(114)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(117)) return true;
+    if (jj_scan_token(115)) return true;
     }
     }
     }
-    if (jj_3R_174()) return true;
+    if (jj_3R_172()) return true;
     return false;
   }
 
-  private boolean jj_3R_262()
+  private boolean jj_3R_260()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_270()) {
+    if (jj_3R_268()) {
     jj_scanpos = xsp;
-    if (jj_3R_271()) return true;
+    if (jj_3R_269()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_270()
+  private boolean jj_3R_268()
  {
     if (jj_3R_99()) return true;
     return false;
   }
 
-  private boolean jj_3R_174()
+  private boolean jj_3R_172()
  {
-    if (jj_3R_176()) return true;
+    if (jj_3R_174()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_177()) { jj_scanpos = xsp; break; }
+      if (jj_3R_175()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_271()
+  private boolean jj_3R_269()
  {
-    if (jj_3R_272()) return true;
+    if (jj_3R_270()) return true;
     return false;
   }
 
-  private boolean jj_3R_264()
+  private boolean jj_3R_262()
  {
     if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_177()
+  private boolean jj_3R_175()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(118)) {
+    if (jj_scan_token(116)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(119)) return true;
+    if (jj_scan_token(117)) return true;
     }
-    if (jj_3R_176()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
@@ -5738,19 +5637,19 @@ private boolean jj_3_34()
     return false;
   }
 
-  private boolean jj_3R_176()
+  private boolean jj_3R_174()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_178()) {
+    if (jj_3R_176()) {
     jj_scanpos = xsp;
-    if (jj_3R_179()) {
+    if (jj_3R_177()) {
     jj_scanpos = xsp;
-    if (jj_3R_180()) {
+    if (jj_3R_178()) {
     jj_scanpos = xsp;
-    if (jj_3R_181()) {
+    if (jj_3R_179()) {
     jj_scanpos = xsp;
-    if (jj_3R_182()) return true;
+    if (jj_3R_180()) return true;
     }
     }
     }
@@ -5758,33 +5657,33 @@ private boolean jj_3R_176()
     return false;
   }
 
-  private boolean jj_3R_178()
+  private boolean jj_3R_176()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(106)) {
+    if (jj_scan_token(104)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(107)) {
+    if (jj_scan_token(105)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(93)) {
+    if (jj_scan_token(91)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(92)) return true;
+    if (jj_scan_token(90)) return true;
     }
     }
     }
-    if (jj_3R_176()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
-  private boolean jj_3R_179()
+  private boolean jj_3R_177()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(104)) {
+    if (jj_scan_token(102)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(105)) return true;
+    if (jj_scan_token(103)) return true;
     }
-    if (jj_3R_185()) return true;
+    if (jj_3R_183()) return true;
     return false;
   }
 
@@ -5796,20 +5695,20 @@ private boolean jj_3R_99()
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_239()) { jj_scanpos = xsp; break; }
+      if (jj_3R_237()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_180()
+  private boolean jj_3R_178()
  {
-    if (jj_3R_183()) return true;
+    if (jj_3R_181()) return true;
     return false;
   }
 
-  private boolean jj_3R_181()
+  private boolean jj_3R_179()
  {
-    if (jj_3R_184()) return true;
+    if (jj_3R_182()) return true;
     return false;
   }
 
@@ -5819,23 +5718,23 @@ private boolean jj_3_32()
     return false;
   }
 
-  private boolean jj_3R_272()
+  private boolean jj_3R_270()
  {
     if (jj_3R_109()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_276()) { jj_scanpos = xsp; break; }
+      if (jj_3R_274()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_182()
+  private boolean jj_3R_180()
  {
-    if (jj_3R_185()) return true;
+    if (jj_3R_183()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_186()) jj_scanpos = xsp;
+    if (jj_3R_184()) jj_scanpos = xsp;
     return false;
   }
 
@@ -5845,7 +5744,7 @@ private boolean jj_3_10()
     xsp = jj_scanpos;
     if (jj_3R_48()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(75)) return true;
+    if (jj_scan_token(73)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     return false;
@@ -5857,18 +5756,18 @@ private boolean jj_3R_48()
     return false;
   }
 
-  private boolean jj_3R_263()
+  private boolean jj_3R_261()
  {
-    if (jj_3R_272()) return true;
+    if (jj_3R_270()) return true;
     return false;
   }
 
-  private boolean jj_3R_184()
+  private boolean jj_3R_182()
  {
     if (jj_scan_token(LPAREN)) return true;
     if (jj_3R_46()) return true;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_176()) return true;
+    if (jj_3R_174()) return true;
     return false;
   }
 
@@ -5892,9 +5791,9 @@ private boolean jj_3R_116()
     return false;
   }
 
-  private boolean jj_3R_185()
+  private boolean jj_3R_183()
  {
-    if (jj_3R_188()) return true;
+    if (jj_3R_186()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
@@ -5903,7 +5802,7 @@ private boolean jj_3R_185()
     return false;
   }
 
-  private boolean jj_3R_254()
+  private boolean jj_3R_252()
  {
     if (jj_scan_token(ELSE)) return true;
     if (jj_3R_59()) return true;
@@ -5923,25 +5822,25 @@ private boolean jj_3R_154()
     return false;
   }
 
-  private boolean jj_3R_200()
+  private boolean jj_3R_198()
  {
     if (jj_3R_40()) return true;
-    if (jj_3R_210()) return true;
+    if (jj_3R_208()) return true;
     return false;
   }
 
-  private boolean jj_3R_186()
+  private boolean jj_3R_184()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(104)) {
+    if (jj_scan_token(102)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(105)) return true;
+    if (jj_scan_token(103)) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_239()
+  private boolean jj_3R_237()
  {
     if (jj_scan_token(COMMA)) return true;
     if (jj_3R_62()) return true;
@@ -5960,31 +5859,31 @@ private boolean jj_3R_117()
     return false;
   }
 
-  private boolean jj_3R_183()
+  private boolean jj_3R_181()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_187()) {
+    if (jj_3R_185()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(75)) return true;
+    if (jj_scan_token(73)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_189()) {
+    if (jj_3R_187()) {
     jj_scanpos = xsp;
-    if (jj_3R_190()) return true;
+    if (jj_3R_188()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_276()
+  private boolean jj_3R_274()
  {
     if (jj_scan_token(COMMA)) return true;
     if (jj_3R_109()) return true;
     return false;
   }
 
-  private boolean jj_3R_187()
+  private boolean jj_3R_185()
  {
     if (jj_3R_57()) return true;
     return false;
@@ -5997,7 +5896,7 @@ private boolean jj_3_36()
     return false;
   }
 
-  private boolean jj_3R_189()
+  private boolean jj_3R_187()
  {
     if (jj_3R_52()) return true;
     return false;
@@ -6015,7 +5914,7 @@ private boolean jj_3_12()
     return false;
   }
 
-  private boolean jj_3R_199()
+  private boolean jj_3R_197()
  {
     if (jj_scan_token(WHEN)) return true;
     if (jj_scan_token(LPAREN)) return true;
@@ -6023,10 +5922,10 @@ private boolean jj_3R_199()
     if (jj_scan_token(RPAREN)) return true;
     if (jj_scan_token(LBRACE)) return true;
     Token xsp;
-    if (jj_3R_209()) return true;
+    if (jj_3R_207()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_209()) { jj_scanpos = xsp; break; }
+      if (jj_3R_207()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RBRACE)) return true;
     return false;
@@ -6042,30 +5941,30 @@ private boolean jj_3R_118()
     return false;
   }
 
-  private boolean jj_3R_190()
+  private boolean jj_3R_188()
  {
     if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_209()
+  private boolean jj_3R_207()
  {
-    if (jj_3R_216()) return true;
+    if (jj_3R_214()) return true;
     return false;
   }
 
-  private boolean jj_3R_216()
+  private boolean jj_3R_214()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_225()) {
+    if (jj_3R_223()) {
     jj_scanpos = xsp;
-    if (jj_3R_226()) return true;
+    if (jj_3R_224()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_225()
+  private boolean jj_3R_223()
  {
     if (jj_scan_token(ELSE)) return true;
     if (jj_scan_token(ARROW)) return true;
@@ -6083,13 +5982,13 @@ private boolean jj_3R_119()
     return false;
   }
 
-  private boolean jj_3R_226()
+  private boolean jj_3R_224()
  {
     if (jj_3R_53()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_233()) { jj_scanpos = xsp; break; }
+      if (jj_3R_231()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(ARROW)) return true;
     if (jj_3R_53()) return true;
@@ -6102,10 +6001,14 @@ private boolean jj_3R_156()
     return false;
   }
 
-  private boolean jj_3R_188()
+  private boolean jj_3R_186()
  {
     Token xsp;
     xsp = jj_scanpos;
+    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()) {
@@ -6114,11 +6017,7 @@ private boolean jj_3R_188()
     jj_scanpos = xsp;
     if (jj_3R_194()) {
     jj_scanpos = xsp;
-    if (jj_3R_195()) {
-    jj_scanpos = xsp;
-    if (jj_3R_196()) {
-    jj_scanpos = xsp;
-    if (jj_3R_197()) return true;
+    if (jj_3R_195()) return true;
     }
     }
     }
@@ -6128,9 +6027,9 @@ private boolean jj_3R_188()
     return false;
   }
 
-  private boolean jj_3R_191()
+  private boolean jj_3R_189()
  {
-    if (jj_3R_198()) return true;
+    if (jj_3R_196()) return true;
     return false;
   }
 
@@ -6142,7 +6041,7 @@ private boolean jj_3R_120()
     return false;
   }
 
-  private boolean jj_3R_192()
+  private boolean jj_3R_190()
  {
     if (jj_scan_token(LPAREN)) return true;
     if (jj_3R_53()) return true;
@@ -6150,25 +6049,25 @@ private boolean jj_3R_192()
     return false;
   }
 
-  private boolean jj_3R_193()
+  private boolean jj_3R_191()
  {
-    if (jj_3R_199()) return true;
+    if (jj_3R_197()) return true;
     return false;
   }
 
-  private boolean jj_3R_194()
+  private boolean jj_3R_192()
  {
     if (jj_3R_51()) return true;
     return false;
   }
 
-  private boolean jj_3R_195()
+  private boolean jj_3R_193()
  {
-    if (jj_3R_200()) return true;
+    if (jj_3R_198()) return true;
     return false;
   }
 
-  private boolean jj_3R_196()
+  private boolean jj_3R_194()
  {
     if (jj_3R_46()) return true;
     return false;
@@ -6183,30 +6082,30 @@ private boolean jj_3R_121()
     if (jj_3R_52()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_258()) { jj_scanpos = xsp; break; }
+      if (jj_3R_256()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_259()) jj_scanpos = xsp;
+    if (jj_3R_257()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_197()
+  private boolean jj_3R_195()
  {
     if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_258()
+  private boolean jj_3R_256()
  {
     if (jj_scan_token(CATCH)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_265()) return true;
+    if (jj_3R_263()) return true;
     if (jj_scan_token(RPAREN)) return true;
     if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_259()
+  private boolean jj_3R_257()
  {
     if (jj_scan_token(FINALLY)) return true;
     if (jj_3R_52()) return true;
@@ -6221,7 +6120,7 @@ private boolean jj_3_13()
     xsp = jj_scanpos;
     if (jj_3R_50()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(79)) return true;
+    if (jj_scan_token(77)) return true;
     }
     return false;
   }
@@ -6254,18 +6153,18 @@ private boolean jj_3_37()
     return false;
   }
 
-  private boolean jj_3R_265()
+  private boolean jj_3R_263()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_37()) {
     jj_scanpos = xsp;
-    if (jj_3R_275()) return true;
+    if (jj_3R_273()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_233()
+  private boolean jj_3R_231()
  {
     if (jj_scan_token(COMMA)) return true;
     if (jj_3R_53()) return true;
@@ -6308,7 +6207,7 @@ private boolean jj_3R_49()
     return false;
   }
 
-  private boolean jj_3R_275()
+  private boolean jj_3R_273()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
@@ -6319,9 +6218,9 @@ private boolean jj_3R_73()
     if (jj_scan_token(LBRACKET)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_211()) jj_scanpos = xsp;
+    if (jj_3R_209()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_212()) jj_scanpos = xsp;
+    if (jj_3R_210()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
@@ -6336,17 +6235,17 @@ private boolean jj_3R_61()
   private boolean jj_3R_160()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_273()) return true;
+    if (jj_3R_271()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_274()) { jj_scanpos = xsp; break; }
+      if (jj_3R_272()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_211()
+  private boolean jj_3R_209()
  {
     if (jj_3R_53()) return true;
     return false;
@@ -6365,45 +6264,45 @@ private boolean jj_3_38()
     return false;
   }
 
-  private boolean jj_3R_212()
+  private boolean jj_3R_210()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_221()) {
+    if (jj_3R_219()) {
     jj_scanpos = xsp;
-    if (jj_3R_222()) return true;
+    if (jj_3R_220()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_221()
+  private boolean jj_3R_219()
  {
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_230()) jj_scanpos = xsp;
+    if (jj_3R_228()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_273()
+  private boolean jj_3R_271()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_38()) {
     jj_scanpos = xsp;
-    if (jj_3R_277()) return true;
+    if (jj_3R_275()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_222()
+  private boolean jj_3R_220()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_231()) jj_scanpos = xsp;
+    if (jj_3R_229()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_232()) jj_scanpos = xsp;
+    if (jj_3R_230()) jj_scanpos = xsp;
     return false;
   }
 
@@ -6418,35 +6317,29 @@ private boolean jj_3R_74()
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(75)) {
+    if (jj_scan_token(73)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(43)) return true;
+    if (jj_scan_token(41)) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_230()
+  private boolean jj_3R_228()
  {
     if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_232()
+  private boolean jj_3R_230()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_235()) jj_scanpos = xsp;
+    if (jj_3R_233()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3_1()
- {
-    if (jj_3R_38()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_277()
+  private boolean jj_3R_275()
  {
     if (jj_3R_62()) return true;
     return false;
@@ -6454,18 +6347,24 @@ private boolean jj_3R_277()
 
   private boolean jj_3_16()
  {
-    if (jj_scan_token(155)) return true;
+    if (jj_scan_token(153)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_213()) jj_scanpos = xsp;
+    if (jj_3R_211()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_274()
+  private boolean jj_3_1()
+ {
+    if (jj_3R_38()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_272()
  {
     if (jj_scan_token(SEMICOLON)) return true;
-    if (jj_3R_273()) return true;
+    if (jj_3R_271()) return true;
     return false;
   }
 
@@ -6475,7 +6374,7 @@ private boolean jj_3_17()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_214()) jj_scanpos = xsp;
+    if (jj_3R_212()) jj_scanpos = xsp;
     return false;
   }
 
@@ -6487,6 +6386,13 @@ private boolean jj_3R_75()
     return false;
   }
 
+  private boolean jj_3_18()
+ {
+    if (jj_scan_token(DOT)) return true;
+    if (jj_3R_51()) return true;
+    return false;
+  }
+
   private boolean jj_3R_55()
  {
     Token xsp;
@@ -6497,10 +6403,9 @@ private boolean jj_3R_55()
     return false;
   }
 
-  private boolean jj_3_18()
+  private boolean jj_3R_229()
  {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_3R_51()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
@@ -6508,27 +6413,27 @@ private boolean jj_3R_79()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(46)) {
+    if (jj_scan_token(44)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(47)) {
+    if (jj_scan_token(45)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(48)) {
+    if (jj_scan_token(46)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(54)) {
+    if (jj_scan_token(52)) {
     jj_scanpos = xsp;
     if (jj_scan_token(28)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(42)) {
+    if (jj_scan_token(40)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(55)) {
+    if (jj_scan_token(53)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(61)) {
+    if (jj_scan_token(59)) {
     jj_scanpos = xsp;
     if (jj_scan_token(11)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(51)) {
+    if (jj_scan_token(49)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(52)) {
+    if (jj_scan_token(50)) {
     jj_scanpos = xsp;
     if (jj_scan_token(21)) return true;
     }
@@ -6545,34 +6450,32 @@ private boolean jj_3R_79()
     return false;
   }
 
-  private boolean jj_3R_231()
- {
-    if (jj_3R_53()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_213()
+  private boolean jj_3R_211()
  {
-    if (jj_3R_210()) return true;
+    if (jj_3R_208()) return true;
     return false;
   }
 
-  private boolean jj_3R_235()
+  private boolean jj_3R_233()
  {
     if (jj_3R_53()) return true;
     return false;
   }
 
-  private boolean jj_3R_214()
+  private boolean jj_3R_212()
  {
-    if (jj_3R_210()) return true;
+    if (jj_3R_208()) return true;
     return false;
   }
 
-  private boolean jj_3R_198()
+  private boolean jj_3R_196()
  {
     Token xsp;
     xsp = jj_scanpos;
+    if (jj_3R_199()) {
+    jj_scanpos = xsp;
+    if (jj_3R_200()) {
+    jj_scanpos = xsp;
     if (jj_3R_201()) {
     jj_scanpos = xsp;
     if (jj_3R_202()) {
@@ -6583,11 +6486,7 @@ private boolean jj_3R_198()
     jj_scanpos = xsp;
     if (jj_3R_205()) {
     jj_scanpos = xsp;
-    if (jj_3R_206()) {
-    jj_scanpos = xsp;
-    if (jj_3R_207()) {
-    jj_scanpos = xsp;
-    if (jj_3R_208()) return true;
+    if (jj_3R_206()) return true;
     }
     }
     }
@@ -6598,12 +6497,18 @@ private boolean jj_3R_198()
     return false;
   }
 
-  private boolean jj_3R_201()
+  private boolean jj_3R_199()
  {
     if (jj_scan_token(INTEGER_LITERAL)) return true;
     return false;
   }
 
+  private boolean jj_3R_200()
+ {
+    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
+    return false;
+  }
+
   private boolean jj_3R_97()
  {
     if (jj_3R_55()) return true;
@@ -6628,32 +6533,26 @@ private boolean jj_3R_122()
     return false;
   }
 
-  private boolean jj_3R_202()
- {
-    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
-    return false;
-  }
-
   private boolean jj_3R_143()
  {
     if (jj_scan_token(CLASS)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_245()) jj_scanpos = xsp;
+    if (jj_3R_243()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_246()) jj_scanpos = xsp;
+    if (jj_3R_244()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_245()
+  private boolean jj_3R_243()
  {
     if (jj_scan_token(EXTENDS)) return true;
     if (jj_3R_40()) return true;
     return false;
   }
 
-  private boolean jj_3R_246()
+  private boolean jj_3R_244()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
     if (jj_3R_83()) return true;
@@ -6666,7 +6565,13 @@ private boolean jj_3R_144()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_247()) jj_scanpos = xsp;
+    if (jj_3R_245()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_201()
+ {
+    if (jj_scan_token(CHARACTER_LITERAL)) return true;
     return false;
   }
 
@@ -6676,97 +6581,91 @@ private boolean jj_3R_123()
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_240()) jj_scanpos = xsp;
-    if (jj_3R_241()) return true;
+    if (jj_3R_238()) jj_scanpos = xsp;
+    if (jj_3R_239()) return true;
     return false;
   }
 
-  private boolean jj_3R_247()
+  private boolean jj_3R_245()
  {
     if (jj_scan_token(EXTENDS)) return true;
     if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_240()
+  private boolean jj_3R_238()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
     if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_203()
- {
-    if (jj_scan_token(CHARACTER_LITERAL)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_204()
+  private boolean jj_3R_202()
  {
     if (jj_scan_token(STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_260()
+  private boolean jj_3R_258()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_266()) jj_scanpos = xsp;
+    if (jj_3R_264()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_267()) jj_scanpos = xsp;
+    if (jj_3R_265()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_205()
+  private boolean jj_3R_203()
  {
     if (jj_scan_token(LONG_STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_241()
+  private boolean jj_3R_204()
+ {
+    if (jj_3R_213()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_205()
+ {
+    if (jj_scan_token(42)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_239()
  {
     if (jj_scan_token(LBRACE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_248()) jj_scanpos = xsp;
+    if (jj_3R_246()) jj_scanpos = xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_249()) { jj_scanpos = xsp; break; }
+      if (jj_3R_247()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_250()) jj_scanpos = xsp;
+    if (jj_3R_248()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
   private boolean jj_3R_206()
  {
-    if (jj_3R_215()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_266()
- {
-    if (jj_3R_210()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_207()
- {
-    if (jj_scan_token(44)) return true;
+    if (jj_scan_token(58)) return true;
     return false;
   }
 
-  private boolean jj_3R_248()
+  private boolean jj_3R_264()
  {
-    if (jj_3R_260()) return true;
+    if (jj_3R_208()) return true;
     return false;
   }
 
-  private boolean jj_3R_208()
+  private boolean jj_3R_246()
  {
-    if (jj_scan_token(60)) return true;
+    if (jj_3R_258()) return true;
     return false;
   }
 
@@ -6781,65 +6680,65 @@ private boolean jj_3R_98()
     }
     if (jj_3R_57()) return true;
     xsp = jj_scanpos;
-    if (jj_3R_236()) jj_scanpos = xsp;
+    if (jj_3R_234()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_237()) {
+    if (jj_3R_235()) {
     jj_scanpos = xsp;
-    if (jj_3R_238()) return true;
+    if (jj_3R_236()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_124()
+  private boolean jj_3R_213()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_221()) {
+    jj_scanpos = xsp;
+    if (jj_3R_222()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_125()
+  private boolean jj_3R_221()
  {
-    if (jj_3R_56()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(TRUE)) return true;
     return false;
   }
 
-  private boolean jj_3R_215()
+  private boolean jj_3R_124()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_223()) {
-    jj_scanpos = xsp;
-    if (jj_3R_224()) return true;
-    }
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_223()
+  private boolean jj_3R_222()
  {
-    if (jj_scan_token(TRUE)) return true;
+    if (jj_scan_token(FALSE)) return true;
     return false;
   }
 
-  private boolean jj_3R_224()
+  private boolean jj_3R_125()
  {
-    if (jj_scan_token(FALSE)) return true;
+    if (jj_3R_56()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_267()
+  private boolean jj_3R_265()
  {
     if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_236()
+  private boolean jj_3R_234()
  {
     if (jj_scan_token(THROWS)) return true;
     if (jj_3R_83()) return true;
     return false;
   }
 
-  private boolean jj_3R_237()
+  private boolean jj_3R_235()
  {
     if (jj_3R_52()) return true;
     return false;
@@ -6859,10 +6758,10 @@ private boolean jj_3R_101()
     return false;
   }
 
-  private boolean jj_3R_249()
+  private boolean jj_3R_247()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_260()) return true;
+    if (jj_3R_258()) return true;
     return false;
   }
 
@@ -6890,9 +6789,19 @@ private boolean jj_3R_100()
     return false;
   }
 
-  private boolean jj_3R_238()
+  private boolean jj_3R_208()
  {
-    if (jj_3R_242()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_218()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_236()
+ {
+    if (jj_3R_240()) return true;
     return false;
   }
 
@@ -6904,13 +6813,27 @@ private boolean jj_3R_126()
     return false;
   }
 
-  private boolean jj_3R_210()
+  private boolean jj_3R_218()
  {
-    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_227()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_227()
+ {
+    if (jj_3R_53()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_220()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_232()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_232()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
@@ -6920,19 +6843,28 @@ private boolean jj_3R_39()
     return false;
   }
 
-  private boolean jj_3R_220()
+  private boolean jj_3R_51()
  {
-    if (jj_3R_229()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_76()) {
+    jj_scanpos = xsp;
+    if (jj_3R_77()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_229()
+  private boolean jj_3R_76()
  {
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(NEW)) return true;
     Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_234()) { jj_scanpos = xsp; break; }
+    xsp = jj_scanpos;
+    if (jj_3R_215()) {
+    jj_scanpos = xsp;
+    if (jj_3R_216()) {
+    jj_scanpos = xsp;
+    if (jj_3R_217()) return true;
+    }
     }
     return false;
   }
@@ -6943,28 +6875,28 @@ private boolean jj_3R_62()
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_243()) { jj_scanpos = xsp; break; }
+      if (jj_3R_241()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_244()) jj_scanpos = xsp;
+    if (jj_3R_242()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_234()
+  private boolean jj_3R_241()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_243()
+  private boolean jj_3R_215()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_3R_102()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_244()
+  private boolean jj_3R_242()
  {
     if (jj_scan_token(ASSIGN)) return true;
     if (jj_3R_44()) return true;
@@ -6978,39 +6910,25 @@ private boolean jj_3R_41()
     return false;
   }
 
-  private boolean jj_3R_51()
+  private boolean jj_3R_248()
  {
+    if (jj_scan_token(SEMICOLON)) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_76()) {
-    jj_scanpos = xsp;
-    if (jj_3R_77()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_2()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_76()
+  private boolean jj_3R_216()
  {
-    if (jj_scan_token(NEW)) return true;
+    if (jj_3R_40()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_217()) {
-    jj_scanpos = xsp;
-    if (jj_3R_218()) {
+    if (jj_3R_225()) {
     jj_scanpos = xsp;
-    if (jj_3R_219()) return true;
-    }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_250()
- {
-    if (jj_scan_token(SEMICOLON)) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_2()) { jj_scanpos = xsp; break; }
+    if (jj_3R_226()) return true;
     }
     return false;
   }
@@ -7032,16 +6950,15 @@ private boolean jj_3R_44()
     return false;
   }
 
-  private boolean jj_3R_70()
+  private boolean jj_3R_225()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_217()
+  private boolean jj_3R_70()
  {
-    if (jj_3R_102()) return true;
-    if (jj_3R_104()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
@@ -7051,39 +6968,9 @@ private boolean jj_3_2()
     return false;
   }
 
-  private boolean jj_3R_218()
- {
-    if (jj_3R_40()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_227()) {
-    jj_scanpos = xsp;
-    if (jj_3R_228()) return true;
-    }
-    return false;
-  }
-
-  private boolean jj_3R_227()
- {
-    if (jj_3R_104()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_43()
- {
-    if (jj_scan_token(LBRACE)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_69()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(85)) jj_scanpos = xsp;
-    if (jj_scan_token(RBRACE)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_228()
+  private boolean jj_3R_226()
  {
-    if (jj_3R_210()) return true;
+    if (jj_3R_208()) return true;
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_19()) jj_scanpos = xsp;
@@ -7096,30 +6983,21 @@ private boolean jj_3R_77()
     return false;
   }
 
-  private boolean jj_3R_219()
+  private boolean jj_3R_217()
  {
     if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3R_69()
- {
-    if (jj_3R_44()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_6()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_57()
+  private boolean jj_3R_43()
  {
-    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(LBRACE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_82()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_69()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(83)) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
@@ -7152,13 +7030,6 @@ private boolean jj_3_22()
     return false;
   }
 
-  private boolean jj_3_6()
- {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_44()) return true;
-    return false;
-  }
-
   private boolean jj_3_20()
  {
     if (jj_scan_token(LBRACKET)) return true;
@@ -7174,29 +7045,24 @@ private boolean jj_3_21()
     return false;
   }
 
-  private boolean jj_3R_82()
+  private boolean jj_3R_69()
  {
-    if (jj_3R_106()) return true;
+    if (jj_3R_44()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_107()) { jj_scanpos = xsp; break; }
+      if (jj_3_6()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_106()
+  private boolean jj_3R_57()
  {
+    if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_7()) {
-    jj_scanpos = xsp;
-    if (jj_3R_140()) return true;
-    }
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_141()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_82()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
@@ -7212,15 +7078,10 @@ private boolean jj_3R_137()
     return false;
   }
 
-  private boolean jj_3_7()
+  private boolean jj_3_6()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_45()) jj_scanpos = xsp;
-    if (jj_3R_46()) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_47()) jj_scanpos = xsp;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_44()) return true;
     return false;
   }
 
@@ -7243,22 +7104,47 @@ private boolean jj_3R_138()
     return false;
   }
 
-  private boolean jj_3R_140()
+  private boolean jj_3R_82()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_106()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_107()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_141()
+  private boolean jj_3R_106()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_7()) {
+    jj_scanpos = xsp;
+    if (jj_3R_140()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_141()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_47()
+  private boolean jj_3_7()
  {
-    if (jj_scan_token(ELLIPSIS)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_45()) jj_scanpos = xsp;
+    if (jj_3R_46()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_47()) jj_scanpos = xsp;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_140()
+ {
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
@@ -7276,7 +7162,7 @@ private boolean jj_3R_59()
     jj_scanpos = xsp;
     if (jj_3_24()) {
     jj_scanpos = xsp;
-    if (jj_scan_token(84)) {
+    if (jj_scan_token(82)) {
     jj_scanpos = xsp;
     if (jj_3R_84()) {
     jj_scanpos = xsp;
@@ -7330,12 +7216,38 @@ private boolean jj_3_24()
     return false;
   }
 
+  private boolean jj_3R_141()
+ {
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_47()
+ {
+    if (jj_scan_token(ELLIPSIS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_84()
+ {
+    if (jj_3R_109()) return true;
+    if (jj_3R_42()) return true;
+    return false;
+  }
+
   private boolean jj_3R_45()
  {
     if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
+  private boolean jj_3R_85()
+ {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
   private boolean jj_3R_46()
  {
     Token xsp;
@@ -7351,23 +7263,28 @@ private boolean jj_3R_46()
     return false;
   }
 
-  private boolean jj_3R_107()
+  private boolean jj_3R_86()
+ {
+    if (jj_3R_111()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_107()
  {
     if (jj_scan_token(COMMA)) return true;
     if (jj_3R_106()) return true;
     return false;
   }
 
-  private boolean jj_3R_84()
+  private boolean jj_3R_87()
  {
-    if (jj_3R_109()) return true;
-    if (jj_3R_42()) return true;
+    if (jj_3R_112()) return true;
     return false;
   }
 
-  private boolean jj_3R_85()
+  private boolean jj_3R_88()
  {
-    if (jj_3R_110()) return true;
+    if (jj_3R_113()) return true;
     return false;
   }
 
@@ -7377,34 +7294,34 @@ private boolean jj_3R_71()
     return false;
   }
 
-  private boolean jj_3R_86()
+  private boolean jj_3R_89()
  {
-    if (jj_3R_111()) return true;
+    if (jj_3R_114()) return true;
     return false;
   }
 
-  private boolean jj_3R_87()
+  private boolean jj_3_8()
  {
-    if (jj_3R_112()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3_8()
+  private boolean jj_3R_90()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_3R_115()) return true;
     return false;
   }
 
-  private boolean jj_3R_88()
+  private boolean jj_3R_91()
  {
-    if (jj_3R_113()) return true;
+    if (jj_3R_116()) return true;
     return false;
   }
 
-  private boolean jj_3R_89()
+  private boolean jj_3R_92()
  {
-    if (jj_3R_114()) return true;
+    if (jj_3R_117()) return true;
     return false;
   }
 
@@ -7425,9 +7342,9 @@ private boolean jj_3R_80()
     return false;
   }
 
-  private boolean jj_3R_90()
+  private boolean jj_3R_93()
  {
-    if (jj_3R_115()) return true;
+    if (jj_3R_118()) return true;
     return false;
   }
 
@@ -7437,21 +7354,21 @@ private boolean jj_3R_81()
     return false;
   }
 
-  private boolean jj_3R_91()
+  private boolean jj_3R_94()
  {
-    if (jj_3R_116()) return true;
+    if (jj_3R_119()) return true;
     return false;
   }
 
-  private boolean jj_3R_92()
+  private boolean jj_3R_95()
  {
-    if (jj_3R_117()) return true;
+    if (jj_3R_120()) return true;
     return false;
   }
 
-  private boolean jj_3R_93()
+  private boolean jj_3R_96()
  {
-    if (jj_3R_118()) return true;
+    if (jj_3R_121()) return true;
     return false;
   }
 
@@ -7496,12 +7413,6 @@ private boolean jj_3R_128()
     return false;
   }
 
-  private boolean jj_3R_94()
- {
-    if (jj_3R_119()) return true;
-    return false;
-  }
-
   private boolean jj_3R_129()
  {
     if (jj_scan_token(BYTE)) return true;
@@ -7520,12 +7431,6 @@ private boolean jj_3R_130()
     return false;
   }
 
-  private boolean jj_3R_95()
- {
-    if (jj_3R_120()) return true;
-    return false;
-  }
-
   private boolean jj_3R_131()
  {
     if (jj_scan_token(INT)) return true;
@@ -7538,9 +7443,11 @@ private boolean jj_3R_132()
     return false;
   }
 
-  private boolean jj_3R_96()
+  private boolean jj_3R_54()
  {
-    if (jj_3R_121()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
@@ -7556,36 +7463,28 @@ private boolean jj_3R_134()
     return false;
   }
 
-  private boolean jj_3R_54()
- {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_40()
+  private boolean jj_3R_52()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(49)) jj_scanpos = xsp;
+    if (jj_scan_token(LBRACE)) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_9()) { jj_scanpos = xsp; break; }
+      if (jj_3_25()) { jj_scanpos = xsp; break; }
     }
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_52()
+  private boolean jj_3R_40()
  {
+    if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(51)) jj_scanpos = xsp;
-    if (jj_scan_token(LBRACE)) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_25()) { jj_scanpos = xsp; break; }
+      if (jj_3_9()) { jj_scanpos = xsp; break; }
     }
-    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
@@ -7596,17 +7495,6 @@ private boolean jj_3_9()
     return false;
   }
 
-  private boolean jj_3R_83()
- {
-    if (jj_3R_40()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_108()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
   private boolean jj_3R_38()
  {
     Token xsp;
@@ -7639,31 +7527,26 @@ private boolean jj_3R_63()
     return false;
   }
 
-  private boolean jj_3R_64()
- {
-    if (jj_3R_98()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_53()
+  private boolean jj_3R_83()
  {
-    if (jj_3R_78()) return true;
+    if (jj_3R_40()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_103()) jj_scanpos = xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_108()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_65()
+  private boolean jj_3R_64()
  {
     if (jj_3R_98()) return true;
     return false;
   }
 
-  private boolean jj_3R_103()
+  private boolean jj_3R_65()
  {
-    if (jj_3R_136()) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_98()) return true;
     return false;
   }
 
@@ -7674,7 +7557,7 @@ private boolean jj_3_26()
     xsp = jj_scanpos;
     if (jj_scan_token(14)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(40)) {
+    if (jj_scan_token(38)) {
     jj_scanpos = xsp;
     if (jj_scan_token(25)) return true;
     }
@@ -7682,10 +7565,12 @@ private boolean jj_3_26()
     return false;
   }
 
-  private boolean jj_3R_108()
+  private boolean jj_3R_53()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_78()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_103()) jj_scanpos = xsp;
     return false;
   }
 
@@ -7711,53 +7596,91 @@ private boolean jj_3_27()
     return false;
   }
 
+  private boolean jj_3R_103()
+ {
+    if (jj_3R_136()) return true;
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3_30()
+ {
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_108()
+ {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_40()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_67()
+ {
+    if (jj_3R_100()) return true;
+    return false;
+  }
+
+  private boolean jj_3_28()
+ {
+    if (jj_3R_55()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_57()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_58()) jj_scanpos = xsp;
+    if (jj_scan_token(LBRACE)) return true;
+    return false;
+  }
+
   private boolean jj_3R_136()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(87)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(128)) {
+    if (jj_scan_token(85)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(138)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(139)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(129)) {
+    if (jj_scan_token(126)) {
     jj_scanpos = xsp;
     if (jj_scan_token(136)) {
     jj_scanpos = xsp;
     if (jj_scan_token(137)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(126)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(127)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(130)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(131)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(134)) {
     jj_scanpos = xsp;
     if (jj_scan_token(135)) {
     jj_scanpos = xsp;
+    if (jj_scan_token(124)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(125)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(128)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(129)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(132)) {
     jj_scanpos = xsp;
     if (jj_scan_token(133)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(140)) {
+    if (jj_scan_token(130)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(141)) {
+    if (jj_scan_token(131)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(142)) {
+    if (jj_scan_token(138)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(148)) {
+    if (jj_scan_token(139)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(140)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(143)) {
+    if (jj_scan_token(146)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(144)) {
+    if (jj_scan_token(141)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(145)) return true;
+    if (jj_scan_token(142)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(143)) return true;
     }
     }
     }
@@ -7782,30 +7705,6 @@ private boolean jj_3R_136()
     return false;
   }
 
-  private boolean jj_3_30()
- {
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_67()
- {
-    if (jj_3R_100()) return true;
-    return false;
-  }
-
-  private boolean jj_3_28()
- {
-    if (jj_3R_55()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_3R_57()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_58()) jj_scanpos = xsp;
-    if (jj_scan_token(LBRACE)) return true;
-    return false;
-  }
-
   private boolean jj_3R_68()
  {
     if (jj_3R_101()) return true;
@@ -7829,6 +7728,25 @@ private boolean jj_3R_78()
     return false;
   }
 
+  private boolean jj_3R_240()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(82)) {
+    jj_scanpos = xsp;
+    jj_lookingAhead = true;
+    jj_semLA = isImplicitMethodTerminator();
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_249()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_249()
+ {
+    return false;
+  }
+
   private boolean jj_3R_105()
  {
     if (jj_3R_139()) return true;
@@ -7840,17 +7758,11 @@ private boolean jj_3R_105()
     return false;
   }
 
-  private boolean jj_3R_242()
+  private boolean jj_3R_42()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(84)) {
-    jj_scanpos = xsp;
-    jj_lookingAhead = true;
-    jj_semLA = isImplicitMethodTerminator();
-    jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_251()) return true;
-    }
+    if (jj_scan_token(82)) jj_scanpos = xsp;
     return false;
   }
 
@@ -7858,30 +7770,17 @@ private boolean jj_3R_145()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(149)) {
+    if (jj_scan_token(147)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(150)) {
+    if (jj_scan_token(148)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(147)) return true;
+    if (jj_scan_token(145)) return true;
     }
     }
     if (jj_3R_139()) return true;
     return false;
   }
 
-  private boolean jj_3R_251()
- {
-    return false;
-  }
-
-  private boolean jj_3R_42()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(84)) jj_scanpos = xsp;
-    return false;
-  }
-
   private boolean jj_3R_139()
  {
     if (jj_3R_147()) return true;
@@ -7893,22 +7792,28 @@ private boolean jj_3R_139()
     return false;
   }
 
+  private boolean jj_3R_58()
+ {
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_83()) return true;
+    return false;
+  }
+
   private boolean jj_3R_148()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(100)) {
+    if (jj_scan_token(98)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(101)) return true;
+    if (jj_scan_token(99)) return true;
     }
     if (jj_3R_147()) return true;
     return false;
   }
 
-  private boolean jj_3R_58()
+  private boolean jj_3R_109()
  {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_83()) return true;
+    if (jj_3R_53()) return true;
     return false;
   }
 
@@ -7923,19 +7828,13 @@ private boolean jj_3R_147()
     return false;
   }
 
-  private boolean jj_3R_109()
- {
-    if (jj_3R_53()) return true;
-    return false;
-  }
-
   private boolean jj_3R_150()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(102)) {
+    if (jj_scan_token(100)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(103)) return true;
+    if (jj_scan_token(101)) return true;
     }
     if (jj_3R_149()) return true;
     return false;
@@ -7956,9 +7855,9 @@ private boolean jj_3R_152()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(112)) {
+    if (jj_scan_token(110)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(113)) return true;
+    if (jj_scan_token(111)) return true;
     }
     if (jj_3R_151()) return true;
     return false;
@@ -7973,17 +7872,6 @@ private boolean jj_3R_135()
     return false;
   }
 
-  private boolean jj_3R_151()
- {
-    if (jj_3R_153()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_158()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
   private boolean jj_3R_110()
  {
     if (jj_scan_token(SWITCH)) return true;
@@ -7994,70 +7882,58 @@ private boolean jj_3R_110()
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_252()) { jj_scanpos = xsp; break; }
+      if (jj_3R_250()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_158()
+  private boolean jj_3R_151()
  {
+    if (jj_3R_153()) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(114)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(115)) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_158()) { jj_scanpos = xsp; break; }
     }
-    if (jj_3R_153()) return true;
     return false;
   }
 
-  private boolean jj_3R_153()
+  private boolean jj_3R_250()
  {
-    if (jj_3R_159()) return true;
+    if (jj_3R_259()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_161()) { jj_scanpos = xsp; break; }
+      if (jj_3_31()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_161()
+  private boolean jj_3R_158()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(110)) {
+    if (jj_scan_token(112)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(111)) return true;
-    }
-    if (jj_3R_159()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_252()
- {
-    if (jj_3R_261()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_31()) { jj_scanpos = xsp; break; }
+    if (jj_scan_token(113)) return true;
     }
+    if (jj_3R_153()) return true;
     return false;
   }
 
-  private boolean jj_3R_261()
+  private boolean jj_3R_259()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_268()) {
+    if (jj_3R_266()) {
     jj_scanpos = xsp;
-    if (jj_3R_269()) return true;
+    if (jj_3R_267()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_268()
+  private boolean jj_3R_266()
  {
     if (jj_scan_token(CASE)) return true;
     if (jj_3R_53()) return true;
@@ -8065,32 +7941,43 @@ private boolean jj_3R_268()
     return false;
   }
 
-  private boolean jj_3R_269()
- {
-    if (jj_scan_token(156)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_159()
+  private boolean jj_3R_153()
  {
-    if (jj_3R_162()) return true;
+    if (jj_3R_159()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_163()) { jj_scanpos = xsp; break; }
+      if (jj_3R_161()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_163()
+  private boolean jj_3R_267()
+ {
+    if (jj_scan_token(154)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_161()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(94)) {
+    if (jj_scan_token(108)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(99)) return true;
+    if (jj_scan_token(109)) return true;
     }
+    if (jj_3R_159()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_159()
+ {
     if (jj_3R_162()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_163()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
@@ -8108,44 +7995,24 @@ private boolean jj_3R_111()
     if (jj_scan_token(RPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_253()) {
+    if (jj_3R_251()) {
     jj_scanpos = xsp;
     if (jj_3_32()) return true;
     }
     xsp = jj_scanpos;
-    if (jj_3R_254()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_162()
- {
-    if (jj_3R_164()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_165()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_165()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_168()) {
-    jj_scanpos = xsp;
-    if (jj_3R_169()) return true;
-    }
+    if (jj_3R_252()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_168()
+  private boolean jj_3R_163()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(36)) {
+    if (jj_scan_token(92)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(37)) return true;
+    if (jj_scan_token(97)) return true;
     }
-    if (jj_3R_46()) return true;
+    if (jj_3R_162()) return true;
     return false;
   }
 
@@ -8159,9 +8026,18 @@ private boolean jj_3R_112()
     return false;
   }
 
-  private boolean jj_3R_169()
+  private boolean jj_3R_162()
+ {
+    if (jj_3R_164()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_165()) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_165()
  {
-    if (jj_scan_token(AS)) return true;
+    if (jj_scan_token(INSTANCEOF)) return true;
     if (jj_3R_46()) return true;
     return false;
   }
@@ -8193,21 +8069,21 @@ private boolean jj_3R_167()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(90)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(91)) {
-    jj_scanpos = xsp;
     if (jj_scan_token(88)) {
     jj_scanpos = xsp;
     if (jj_scan_token(89)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(95)) {
+    if (jj_scan_token(86)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(96)) {
+    if (jj_scan_token(87)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(93)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(97)) {
+    if (jj_scan_token(94)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(98)) return true;
+    if (jj_scan_token(95)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(96)) return true;
     }
     }
     }
@@ -8225,13 +8101,13 @@ private boolean jj_3R_114()
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_255()) jj_scanpos = xsp;
+    if (jj_3R_253()) jj_scanpos = xsp;
     if (jj_scan_token(SEMICOLON)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_256()) jj_scanpos = xsp;
+    if (jj_3R_254()) jj_scanpos = xsp;
     if (jj_scan_token(SEMICOLON)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_257()) jj_scanpos = xsp;
+    if (jj_3R_255()) jj_scanpos = xsp;
     if (jj_scan_token(RPAREN)) return true;
     if (jj_3R_59()) return true;
     return false;
@@ -8239,42 +8115,94 @@ private boolean jj_3R_114()
 
   private boolean jj_3R_166()
  {
-    if (jj_3R_170()) return true;
+    if (jj_3R_168()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_171()) { jj_scanpos = xsp; break; }
+      if (jj_3R_169()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_171()
+  private boolean jj_3R_169()
  {
     Token xsp;
     xsp = jj_scanpos;
+    if (jj_scan_token(118)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(119)) {
+    jj_scanpos = xsp;
     if (jj_scan_token(120)) {
     jj_scanpos = xsp;
     if (jj_scan_token(121)) {
     jj_scanpos = xsp;
     if (jj_scan_token(122)) {
     jj_scanpos = xsp;
-    if (jj_scan_token(123)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(124)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(125)) return true;
+    if (jj_scan_token(123)) return true;
     }
     }
     }
     }
     }
+    if (jj_3R_168()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_251()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_254()
+ {
+    if (jj_3R_53()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_255()
+ {
+    if (jj_3R_261()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_168()
+ {
     if (jj_3R_170()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_171()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
   private boolean jj_3R_253()
  {
-    if (jj_scan_token(SEMICOLON)) return true;
+    if (jj_3R_260()) return true;
+    return false;
+  }
+
+  private boolean jj_3_33()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_115()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_33()) {
+    jj_scanpos = xsp;
+    if (jj_3R_142()) return true;
+    }
     return false;
   }
 
@@ -8292,7 +8220,7 @@ private boolean jj_3R_253()
   private boolean jj_lookingAhead = false;
   private boolean jj_semLA;
   private int jj_gen;
-  final private int[] jj_la1 = new int[124];
+  final private int[] jj_la1 = new int[122];
   static private int[] jj_la1_0;
   static private int[] jj_la1_1;
   static private int[] jj_la1_2;
@@ -8306,19 +8234,19 @@ private boolean jj_3R_253()
 	   jj_la1_init_4();
 	}
 	private static void jj_la1_init_0() {
-	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x49849000,0x0,0x49849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
+	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x49849000,0x0,0x49849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_1() {
-	   jj_la1_1 = new int[] {0x0,0x20d9c400,0x20d9c400,0x0,0x4,0x0,0x100,0x4,0x100,0x0,0x80000,0x0,0x0,0x0,0x10040280,0x2000000,0x80000,0x80000,0x0,0x8,0x0,0x0,0x54041a80,0x54041a80,0x0,0x0,0x40280,0x0,0x0,0x0,0x40280,0x10040280,0x40280,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x70,0x70,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x54041a80,0x0,0x540c1a80,0x54041a80,0x0,0x54041a80,0x54001800,0x0,0x54041a80,0x54041a80,0x54041a80,0x54041a80,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x14001000,0x4000000,0x54041a80,0x0,0x0,0x40280,0x800,0x0,0x0,0xd4241a82,0x9420000,0x80000,0x2008,0x0,0x0,0x0,0x0,0x0,0x0,0x74ddde80,0x54041a80,0x54041a80,0x0,0x0,0x54041a80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_1 = new int[] {0x0,0x8367100,0x8367100,0x0,0x4,0x0,0x40,0x4,0x40,0x0,0x20000,0x0,0x0,0x0,0x40100a0,0x800000,0x20000,0x20000,0x0,0x8,0x0,0x0,0x550106a0,0x550106a0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x100a0,0x40100a0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x550106a0,0x0,0x550306a0,0x550106a0,0x0,0x550106a0,0x55000600,0x0,0x550106a0,0x550106a0,0x550106a0,0x550106a0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x45000400,0x1000000,0x550106a0,0x0,0x0,0x100a0,0x200,0x0,0x0,0x750906a2,0x2508000,0x20000,0x808,0x0,0x0,0x0,0x0,0x0,0x0,0x5d3777a0,0x550106a0,0x550106a0,0x0,0x0,0x550106a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_2() {
-	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x10000,0x800,0x200000,0x100000,0x800,0x0,0x10000,0x0,0x400000,0x0,0x40000,0x800000,0x30054f21,0x30054f21,0x200000,0x200000,0x800,0x0,0x0,0x800,0x800,0x800,0x0,0x200000,0x800000,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x0,0x0,0x8f000000,0x8f000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x0,0x30000000,0x54f21,0x4800,0x30054f21,0x30054f21,0x200000,0x30054f21,0x54721,0x800,0x30054f21,0x30054f21,0x30054f21,0x30054f21,0x0,0x0,0x0,0x800,0x4000,0x4000,0x40000,0x10000,0x721,0x0,0x30054f21,0x200000,0x54000,0x50800,0x50000,0x40000,0x50000,0x30154f21,0x0,0x0,0x0,0x100000,0x100000,0x0,0x0,0x100000,0x0,0x30054f21,0x30054f21,0x30054f21,0x0,0x0,0x30054f21,0x200000,0x200000,0x4000,0x0,0x0,0x0,0x0,0x800,0x100000,0x800,};
+	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x4000,0x200,0x80000,0x40000,0x200,0x0,0x4000,0x0,0x100000,0x0,0x10000,0x200000,0xc0153c8,0xc0153c8,0x80000,0x80000,0x200,0x0,0x0,0x200,0x200,0x200,0x0,0x80000,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0xe3c00000,0xe3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0x0,0x0,0x0,0xc000000,0x153c8,0x1200,0xc0153c8,0xc0153c8,0x80000,0xc0153c8,0x151c8,0x200,0xc0153c8,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0x0,0x200,0x1000,0x1000,0x10000,0x4000,0x1c8,0x0,0xc0153c8,0x80000,0x15000,0x14200,0x14000,0x10000,0x14000,0xc0553c8,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x40000,0x0,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0xc0153c8,0x80000,0x80000,0x1000,0x0,0x0,0x0,0x0,0x200,0x40000,0x200,};
 	}
 	private static void jj_la1_init_3() {
-	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0xc0000000,0x0,0x0,0x0,0x30,0x30,0xc0,0xc0,0x30000,0x30000,0xc0000,0xc0000,0xc000,0xc000,0x8,0x8,0x0,0x0,0x0,0x7,0x7,0x3f000000,0x3f000000,0xc00,0xc00,0x303000,0x303000,0xc00000,0xc00000,0xc00,0x300,0x300,0x300,0xf00,0x0,0x0,0xf00,0xf00,0x0,0xf00,0x0,0x0,0xf00,0xf00,0xf00,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf00,0xf00,0xf00,0x0,0x0,0xf00,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x0,};
+	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0xf0000000,0x0,0x0,0x0,0xc,0xc,0x30,0x30,0xc000,0xc000,0x30000,0x30000,0x3000,0x3000,0x2,0x2,0x0,0x1,0x1,0xfc00000,0xfc00000,0x300,0x300,0xc0c00,0xc0c00,0x300000,0x300000,0x300,0xc0,0xc0,0xc0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_4() {
-	   jj_la1_4 = new int[] {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,0x4000000,0x0,0x0,0x0,0x0,0x0,0x13ffff,0x13ffff,0x800000,0x680000,0x680000,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,0x1000000,0x3000000,0x3000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_4 = new int[] {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,0x1000000,0x0,0x0,0x0,0x0,0x0,0x4ffff,0x4ffff,0x200000,0x1a0000,0x1a0000,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,0x400000,0xc00000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
   private final JJCalls[] jj_2_rtns = new JJCalls[38];
   private boolean jj_rescan = false;
@@ -8335,7 +8263,7 @@ public Parser(final java.io.InputStream stream, final java.nio.charset.Charset e
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8350,7 +8278,7 @@ public void ReInit(final java.io.InputStream stream, final java.nio.charset.Char
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8364,7 +8292,7 @@ public Parser(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 124; i++)
+   for (int i = 0; i < 122; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8388,7 +8316,7 @@ public void ReInit(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 124; i++)
+   for (int i = 0; i < 122; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8403,7 +8331,7 @@ public Parser(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8416,7 +8344,7 @@ public void ReInit(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 124; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8561,12 +8489,12 @@ private void jj_add_error_token(int kind, int pos) {
    */
   public ParseException generateParseException() {
     jj_expentries.clear();
-    boolean[] la1tokens = new boolean[157];
+    boolean[] la1tokens = new boolean[155];
     if (jj_kind >= 0) {
       la1tokens[jj_kind] = true;
       jj_kind = -1;
     }
-    for (int i = 0; i < 124; i++) {
+    for (int i = 0; i < 122; i++) {
       if (jj_la1[i] == jj_gen) {
         for (int j = 0; j < 32; j++) {
           if ((jj_la1_0[i] & (1<<j)) != 0) {
@@ -8587,7 +8515,7 @@ public ParseException generateParseException() {
         }
       }
     }
-    for (int i = 0; i < 157; i++) {
+    for (int i = 0; i < 155; i++) {
       if (la1tokens[i]) {
         jj_expentry = new int[1];
         jj_expentry[0] = i;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
index 708bb29..67da8c9 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserConstants.java
@@ -98,241 +98,237 @@ public interface ParserConstants {
   /** RegularExpression Id. */
   int INSTANCEOF = 36;
   /** RegularExpression Id. */
-  int IS = 37;
+  int INT = 37;
   /** RegularExpression Id. */
-  int AS = 38;
+  int INTERFACE = 38;
   /** RegularExpression Id. */
-  int INT = 39;
+  int LONG = 39;
   /** RegularExpression Id. */
-  int INTERFACE = 40;
+  int NATIVE = 40;
   /** RegularExpression Id. */
-  int LONG = 41;
+  int NEW = 41;
   /** RegularExpression Id. */
-  int NATIVE = 42;
+  int NULL = 42;
   /** RegularExpression Id. */
-  int NEW = 43;
+  int PACKAGE = 43;
   /** RegularExpression Id. */
-  int NULL = 44;
+  int PRIVATE = 44;
   /** RegularExpression Id. */
-  int PACKAGE = 45;
+  int PROTECTED = 45;
   /** RegularExpression Id. */
-  int PRIVATE = 46;
+  int PUBLIC = 46;
   /** RegularExpression Id. */
-  int PROTECTED = 47;
+  int RETURN = 47;
   /** RegularExpression Id. */
-  int PUBLIC = 48;
+  int SHORT = 48;
   /** RegularExpression Id. */
-  int RETURN = 49;
+  int STATIC = 49;
   /** RegularExpression Id. */
-  int SHORT = 50;
+  int STRICTFP = 50;
   /** RegularExpression Id. */
-  int STATIC = 51;
+  int SWITCH = 51;
   /** RegularExpression Id. */
-  int STRICTFP = 52;
+  int SYNCHRONIZED = 52;
   /** RegularExpression Id. */
-  int SWITCH = 53;
+  int TRANSIENT = 53;
   /** RegularExpression Id. */
-  int SYNCHRONIZED = 54;
+  int THROW = 54;
   /** RegularExpression Id. */
-  int TRANSIENT = 55;
+  int THROWS = 55;
   /** RegularExpression Id. */
-  int THROW = 56;
+  int TRUE = 56;
   /** RegularExpression Id. */
-  int THROWS = 57;
+  int TRY = 57;
   /** RegularExpression Id. */
-  int TRUE = 58;
+  int VOID = 58;
   /** RegularExpression Id. */
-  int TRY = 59;
+  int VOLATILE = 59;
   /** RegularExpression Id. */
-  int VOID = 60;
+  int WHEN = 60;
   /** RegularExpression Id. */
-  int VOLATILE = 61;
+  int WHILE = 61;
   /** RegularExpression Id. */
-  int WHEN = 62;
+  int INTEGER_LITERAL = 62;
   /** RegularExpression Id. */
-  int WHILE = 63;
+  int DECIMAL_LITERAL = 63;
   /** RegularExpression Id. */
-  int INTEGER_LITERAL = 64;
+  int HEX_LITERAL = 64;
   /** RegularExpression Id. */
-  int DECIMAL_LITERAL = 65;
+  int BINARY_LITERAL = 65;
   /** RegularExpression Id. */
-  int HEX_LITERAL = 66;
+  int OCTAL_LITERAL = 66;
   /** RegularExpression Id. */
-  int BINARY_LITERAL = 67;
+  int FLOATING_POINT_LITERAL = 67;
   /** RegularExpression Id. */
-  int OCTAL_LITERAL = 68;
+  int EXPONENT = 68;
   /** RegularExpression Id. */
-  int FLOATING_POINT_LITERAL = 69;
+  int ESCAPE = 69;
   /** RegularExpression Id. */
-  int EXPONENT = 70;
+  int CHARACTER_LITERAL = 70;
   /** RegularExpression Id. */
-  int ESCAPE = 71;
+  int STRING_LITERAL = 71;
   /** RegularExpression Id. */
-  int CHARACTER_LITERAL = 72;
+  int LONG_STRING_LITERAL = 72;
   /** RegularExpression Id. */
-  int STRING_LITERAL = 73;
+  int IDENTIFIER = 73;
   /** RegularExpression Id. */
-  int LONG_STRING_LITERAL = 74;
+  int LETTER = 74;
   /** RegularExpression Id. */
-  int IDENTIFIER = 75;
+  int DIGIT = 75;
   /** RegularExpression Id. */
-  int LETTER = 76;
+  int LPAREN = 76;
   /** RegularExpression Id. */
-  int DIGIT = 77;
+  int RPAREN = 77;
   /** RegularExpression Id. */
-  int LPAREN = 78;
+  int LBRACE = 78;
   /** RegularExpression Id. */
-  int RPAREN = 79;
+  int RBRACE = 79;
   /** RegularExpression Id. */
-  int LBRACE = 80;
+  int LBRACKET = 80;
   /** RegularExpression Id. */
-  int RBRACE = 81;
+  int RBRACKET = 81;
   /** RegularExpression Id. */
-  int LBRACKET = 82;
+  int SEMICOLON = 82;
   /** RegularExpression Id. */
-  int RBRACKET = 83;
+  int COMMA = 83;
   /** RegularExpression Id. */
-  int SEMICOLON = 84;
+  int DOT = 84;
   /** RegularExpression Id. */
-  int COMMA = 85;
+  int ASSIGN = 85;
   /** RegularExpression Id. */
-  int DOT = 86;
+  int GT = 86;
   /** RegularExpression Id. */
-  int ASSIGN = 87;
+  int GTX = 87;
   /** RegularExpression Id. */
-  int GT = 88;
+  int LT = 88;
   /** RegularExpression Id. */
-  int GTX = 89;
+  int LTX = 89;
   /** RegularExpression Id. */
-  int LT = 90;
+  int BANG = 90;
   /** RegularExpression Id. */
-  int LTX = 91;
+  int TILDE = 91;
   /** RegularExpression Id. */
-  int BANG = 92;
+  int EQ = 92;
   /** RegularExpression Id. */
-  int TILDE = 93;
+  int LE = 93;
   /** RegularExpression Id. */
-  int EQ = 94;
+  int LEX = 94;
   /** RegularExpression Id. */
-  int LE = 95;
+  int GE = 95;
   /** RegularExpression Id. */
-  int LEX = 96;
+  int GEX = 96;
   /** RegularExpression Id. */
-  int GE = 97;
+  int NE = 97;
   /** RegularExpression Id. */
-  int GEX = 98;
+  int BOOL_OR = 98;
   /** RegularExpression Id. */
-  int NE = 99;
+  int BOOL_ORX = 99;
   /** RegularExpression Id. */
-  int BOOL_OR = 100;
+  int BOOL_AND = 100;
   /** RegularExpression Id. */
-  int BOOL_ORX = 101;
+  int BOOL_ANDX = 101;
   /** RegularExpression Id. */
-  int BOOL_AND = 102;
+  int INCR = 102;
   /** RegularExpression Id. */
-  int BOOL_ANDX = 103;
+  int DECR = 103;
   /** RegularExpression Id. */
-  int INCR = 104;
+  int PLUS = 104;
   /** RegularExpression Id. */
-  int DECR = 105;
+  int MINUS = 105;
   /** RegularExpression Id. */
-  int PLUS = 106;
+  int STAR = 106;
   /** RegularExpression Id. */
-  int MINUS = 107;
+  int SLASH = 107;
   /** RegularExpression Id. */
-  int STAR = 108;
+  int BIT_AND = 108;
   /** RegularExpression Id. */
-  int SLASH = 109;
+  int BIT_ANDX = 109;
   /** RegularExpression Id. */
-  int BIT_AND = 110;
+  int BIT_OR = 110;
   /** RegularExpression Id. */
-  int BIT_ANDX = 111;
+  int BIT_ORX = 111;
   /** RegularExpression Id. */
-  int BIT_OR = 112;
+  int XOR = 112;
   /** RegularExpression Id. */
-  int BIT_ORX = 113;
+  int XORX = 113;
   /** RegularExpression Id. */
-  int XOR = 114;
+  int MOD = 114;
   /** RegularExpression Id. */
-  int XORX = 115;
+  int MODX = 115;
   /** RegularExpression Id. */
-  int MOD = 116;
+  int POWER = 116;
   /** RegularExpression Id. */
-  int MODX = 117;
+  int POWERX = 117;
   /** RegularExpression Id. */
-  int POWER = 118;
+  int LSHIFT = 118;
   /** RegularExpression Id. */
-  int POWERX = 119;
+  int LSHIFTX = 119;
   /** RegularExpression Id. */
-  int LSHIFT = 120;
+  int RSIGNEDSHIFT = 120;
   /** RegularExpression Id. */
-  int LSHIFTX = 121;
+  int RSIGNEDSHIFTX = 121;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFT = 122;
+  int RUNSIGNEDSHIFT = 122;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTX = 123;
+  int RUNSIGNEDSHIFTX = 123;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFT = 124;
+  int PLUSASSIGN = 124;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTX = 125;
+  int MINUSASSIGN = 125;
   /** RegularExpression Id. */
-  int PLUSASSIGN = 126;
+  int STARASSIGN = 126;
   /** RegularExpression Id. */
-  int MINUSASSIGN = 127;
+  int SLASHASSIGN = 127;
   /** RegularExpression Id. */
-  int STARASSIGN = 128;
+  int ANDASSIGN = 128;
   /** RegularExpression Id. */
-  int SLASHASSIGN = 129;
+  int ANDASSIGNX = 129;
   /** RegularExpression Id. */
-  int ANDASSIGN = 130;
+  int ORASSIGN = 130;
   /** RegularExpression Id. */
-  int ANDASSIGNX = 131;
+  int ORASSIGNX = 131;
   /** RegularExpression Id. */
-  int ORASSIGN = 132;
+  int XORASSIGN = 132;
   /** RegularExpression Id. */
-  int ORASSIGNX = 133;
+  int XORASSIGNX = 133;
   /** RegularExpression Id. */
-  int XORASSIGN = 134;
+  int MODASSIGN = 134;
   /** RegularExpression Id. */
-  int XORASSIGNX = 135;
+  int MODASSIGNX = 135;
   /** RegularExpression Id. */
-  int MODASSIGN = 136;
+  int POWERASSIGN = 136;
   /** RegularExpression Id. */
-  int MODASSIGNX = 137;
+  int POWERASSIGNX = 137;
   /** RegularExpression Id. */
-  int POWERASSIGN = 138;
+  int LSHIFTASSIGN = 138;
   /** RegularExpression Id. */
-  int POWERASSIGNX = 139;
+  int LSHIFTASSIGNX = 139;
   /** RegularExpression Id. */
-  int LSHIFTASSIGN = 140;
+  int RSIGNEDSHIFTASSIGN = 140;
   /** RegularExpression Id. */
-  int LSHIFTASSIGNX = 141;
+  int RSIGNEDSHIFTASSIGNX = 141;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGN = 142;
+  int RUNSIGNEDSHIFTASSIGN = 142;
   /** RegularExpression Id. */
-  int RSIGNEDSHIFTASSIGNX = 143;
+  int RUNSIGNEDSHIFTASSIGNX = 143;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGN = 144;
+  int ARROW = 144;
   /** RegularExpression Id. */
-  int RUNSIGNEDSHIFTASSIGNX = 145;
+  int SPACESHIP = 145;
   /** RegularExpression Id. */
-  int ARROW = 146;
+  int NULLCOALESCEASSIGN = 146;
   /** RegularExpression Id. */
-  int SPACESHIP = 147;
+  int NULLCOALESCE = 147;
   /** RegularExpression Id. */
-  int NULLCOALESCEASSIGN = 148;
+  int ELVIS = 148;
   /** RegularExpression Id. */
-  int NULLCOALESCE = 149;
+  int HOOK = 149;
   /** RegularExpression Id. */
-  int ELVIS = 150;
+  int COLON = 150;
   /** RegularExpression Id. */
-  int HOOK = 151;
+  int COLON_COLON = 151;
   /** RegularExpression Id. */
-  int COLON = 152;
-  /** RegularExpression Id. */
-  int COLON_COLON = 153;
-  /** RegularExpression Id. */
-  int ELLIPSIS = 154;
+  int ELLIPSIS = 152;
 
   /** Lexical state. */
   int DEFAULT = 0;
@@ -376,8 +372,6 @@ public interface ParserConstants {
     "\"implements\"",
     "\"import\"",
     "\"instanceof\"",
-    "\"is\"",
-    "\"as\"",
     "\"int\"",
     "\"interface\"",
     "\"long\"",
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
index 3925eb9..74ef619 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
@@ -38,113 +38,113 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
    switch (pos)
    {
       case 0:
-         if ((active1 & 0x100000084000000L) != 0x0L || (active2 & 0x81000L) != 0x0L)
+         if ((active1 & 0x40000021000000L) != 0x0L || (active2 & 0x20400L) != 0x0L)
             return 75;
-         if ((active1 & 0x400000L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+         if ((active1 & 0x100000L) != 0x0L || (active2 & 0x1000000L) != 0x0L)
             return 18;
-         if ((active1 & 0x200000000000L) != 0x0L || (active2 & 0x2L) != 0x0L)
+         if ((active1 & 0x8000080000000000L) != 0x0L)
             return 64;
-         if ((active0 & 0xfffffffffffff800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
+         if ((active0 & 0x3ffffffffffff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
-            jjmatchedKind = 75;
+            jjmatchedKind = 73;
             return 42;
          }
          if ((active0 & 0x3eL) != 0x0L)
             return 0;
          return -1;
       case 1:
-         if ((active1 & 0x100000000000000L) != 0x0L || (active2 & 0x1000L) != 0x0L)
+         if ((active1 & 0x40000000000000L) != 0x0L || (active2 & 0x400L) != 0x0L)
             return 75;
-         if ((active0 & 0x6200c00000L) != 0x0L)
+         if ((active0 & 0x200c00000L) != 0x0L)
             return 42;
-         if ((active0 & 0xffffff9dff3ff800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
+         if ((active0 & 0x3ffffffdff3ff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 1)
             {
-               jjmatchedKind = 75;
+               jjmatchedKind = 73;
                jjmatchedPos = 1;
             }
             return 42;
          }
          return -1;
       case 2:
-         if ((active0 & 0xf7fff61d7fbff800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
+         if ((active0 & 0x200026080000000L) != 0x0L)
+            return 42;
+         if ((active0 & 0x3dfffd9d7fbff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 2)
             {
-               jjmatchedKind = 75;
+               jjmatchedKind = 73;
                jjmatchedPos = 2;
             }
             return 42;
          }
-         if ((active0 & 0x800098080000000L) != 0x0L)
-            return 42;
          return -1;
       case 3:
-         if ((active0 & 0x5400120103058000L) != 0x0L)
+         if ((active0 & 0x1500048103058000L) != 0x0L)
             return 42;
-         if ((active0 & 0xa3ffe51c7cba7800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
+         if ((active0 & 0x28fff95c7cba7800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 3)
             {
-               jjmatchedKind = 75;
+               jjmatchedKind = 73;
                jjmatchedPos = 3;
             }
             return 42;
          }
          return -1;
       case 4:
-         if ((active0 & 0x83040000780a6000L) != 0x0L)
+         if ((active0 & 0x20c10000780a6000L) != 0x0L)
             return 42;
-         if ((active0 & 0x20fbe51c04b01800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
+         if ((active0 & 0x83ef95c04b01800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             if (jjmatchedPos != 4)
             {
-               jjmatchedKind = 75;
+               jjmatchedKind = 73;
                jjmatchedPos = 4;
             }
             return 42;
          }
          return -1;
       case 5:
-         if ((active0 & 0x22b040800800000L) != 0x0L)
-            return 42;
-         if ((active0 & 0x20d0e11424301800L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
+         if ((active0 & 0x834385424301800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
-            jjmatchedKind = 75;
+            jjmatchedKind = 73;
             jjmatchedPos = 5;
             return 42;
          }
+         if ((active0 & 0x8ac10800800000L) != 0x0L)
+            return 42;
          return -1;
       case 6:
-         if ((active0 & 0x20d0811400100800L) != 0x0L)
+         if ((active0 & 0x180024201000L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
+            return 42;
+         if ((active0 & 0x834205400100800L) != 0x0L)
          {
             if (jjmatchedPos != 6)
             {
-               jjmatchedKind = 75;
+               jjmatchedKind = 73;
                jjmatchedPos = 6;
             }
             return 42;
          }
-         if ((active0 & 0x600024201000L) != 0x0L || (active2 & 0x10000000L) != 0x0L)
-            return 42;
          return -1;
       case 7:
-         if ((active0 & 0x2010000000100800L) != 0x0L)
+         if ((active0 & 0x804000000100800L) != 0x0L)
             return 42;
-         if ((active0 & 0xc0811400000000L) != 0x0L)
+         if ((active0 & 0x30205400000000L) != 0x0L)
          {
-            jjmatchedKind = 75;
+            jjmatchedKind = 73;
             jjmatchedPos = 7;
             return 42;
          }
          return -1;
       case 8:
-         if ((active0 & 0x80810000000000L) != 0x0L)
+         if ((active0 & 0x20204000000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x40001400000000L) != 0x0L)
+         if ((active0 & 0x10001400000000L) != 0x0L)
          {
-            jjmatchedKind = 75;
+            jjmatchedKind = 73;
             jjmatchedPos = 8;
             return 42;
          }
@@ -152,26 +152,26 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
       case 9:
          if ((active0 & 0x1400000000L) != 0x0L)
             return 42;
-         if ((active0 & 0x40000000000000L) != 0x0L)
+         if ((active0 & 0x10000000000000L) != 0x0L)
          {
-            jjmatchedKind = 75;
+            jjmatchedKind = 73;
             jjmatchedPos = 9;
             return 42;
          }
          return -1;
       case 10:
-         if ((active0 & 0x40000000000000L) != 0x0L)
+         if ((active0 & 0x10000000000000L) != 0x0L)
          {
             if (jjmatchedPos != 10)
             {
-               jjmatchedKind = 75;
+               jjmatchedKind = 73;
                jjmatchedPos = 10;
             }
             return 42;
          }
          return -1;
       case 11:
-         if ((active0 & 0x40000000000000L) != 0x0L)
+         if ((active0 & 0x10000000000000L) != 0x0L)
             return 42;
          return -1;
       default :
@@ -201,69 +201,69 @@ private int jjMoveStringLiteralDfa0_0(){
       case ' ':
          return jjStartNfaWithStates_0(0, 1, 0);
       case '!':
-         jjmatchedKind = 92;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000L, 0x0L);
+         jjmatchedKind = 90;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L, 0x0L);
       case '%':
-         jjmatchedKind = 116;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x100L);
+         jjmatchedKind = 114;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x40L);
       case '&':
-         jjmatchedKind = 110;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000L, 0x4L);
+         jjmatchedKind = 108;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000L, 0x1L);
       case '(':
-         return jjStopAtPos(0, 78);
+         return jjStopAtPos(0, 76);
       case ')':
-         return jjStopAtPos(0, 79);
+         return jjStopAtPos(0, 77);
       case '*':
-         jjmatchedKind = 108;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L, 0x401L);
-      case '+':
          jjmatchedKind = 106;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000010000000000L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x4010000000000000L, 0x100L);
+      case '+':
+         jjmatchedKind = 104;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000004000000000L, 0x0L);
       case ',':
-         return jjStopAtPos(0, 85);
+         return jjStopAtPos(0, 83);
       case '-':
-         jjmatchedKind = 107;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000020000000000L, 0x40000L);
+         jjmatchedKind = 105;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000008000000000L, 0x10000L);
       case '.':
-         jjmatchedKind = 86;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x4000000L);
+         jjmatchedKind = 84;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x1000000L);
       case '/':
-         jjmatchedKind = 109;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2L);
+         jjmatchedKind = 107;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000000L, 0x0L);
       case ':':
-         jjmatchedKind = 152;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x2000000L);
+         jjmatchedKind = 150;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x800000L);
       case ';':
-         return jjStopAtPos(0, 84);
+         return jjStopAtPos(0, 82);
       case '<':
-         jjmatchedKind = 90;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000080000000L, 0x81000L);
+         jjmatchedKind = 88;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000020000000L, 0x20400L);
       case '=':
-         jjmatchedKind = 87;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L, 0x0L);
+         jjmatchedKind = 85;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L, 0x0L);
       case '>':
-         jjmatchedKind = 88;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x1400000200000000L, 0x14000L);
+         jjmatchedKind = 86;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x500000080000000L, 0x5000L);
       case '?':
-         jjmatchedKind = 151;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x8700000L);
+         jjmatchedKind = 149;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x21c0000L);
       case '@':
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x2aaa80a50a000000L, 0x2aaa8L);
+         return jjMoveStringLiteralDfa1_0(0x0L, 0xaaaa02942800000L, 0xaaaaL);
       case '[':
-         return jjStopAtPos(0, 82);
+         return jjStopAtPos(0, 80);
       case ']':
-         return jjStopAtPos(0, 83);
+         return jjStopAtPos(0, 81);
       case '^':
-         jjmatchedKind = 114;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x40L);
+         jjmatchedKind = 112;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x0L, 0x10L);
       case 'a':
-         return jjMoveStringLiteralDfa1_0(0x4000000800L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x800L, 0x0L, 0x0L);
       case 'b':
          return jjMoveStringLiteralDfa1_0(0xb000L, 0x0L, 0x0L);
       case 'c':
          return jjMoveStringLiteralDfa1_0(0x1f4000L, 0x0L, 0x0L);
       case 'd':
-         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x10000000L);
+         return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L, 0x4000000L);
       case 'e':
          return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L, 0x0L);
       case 'f':
@@ -271,32 +271,32 @@ private int jjMoveStringLiteralDfa0_0(){
       case 'g':
          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L, 0x0L);
       case 'i':
-         return jjMoveStringLiteralDfa1_0(0x1be00000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L, 0x0L);
       case 'p':
-         return jjMoveStringLiteralDfa1_0(0x1e00000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L, 0x0L);
       case 'r':
-         return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L, 0x0L);
       case 's':
-         return jjMoveStringLiteralDfa1_0(0x7c000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x1f000000000000L, 0x0L, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa1_0(0xf80000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x3e0000000000000L, 0x0L, 0x0L);
       case 'v':
-         return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0xc00000000000000L, 0x0L, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x0L, 0x0L);
+         return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L, 0x0L);
       case '{':
-         return jjStopAtPos(0, 80);
+         return jjStopAtPos(0, 78);
       case '|':
-         jjmatchedKind = 112;
-         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000L, 0x10L);
+         jjmatchedKind = 110;
+         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L, 0x4L);
       case '}':
-         return jjStopAtPos(0, 81);
+         return jjStopAtPos(0, 79);
       case '~':
-         return jjStopAtPos(0, 93);
+         return jjStopAtPos(0, 91);
       default :
          return jjMoveNfa_0(1, 0);
    }
@@ -310,138 +310,132 @@ private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2){
    switch(curChar)
    {
       case '&':
-         if ((active1 & 0x4000000000L) != 0x0L)
-            return jjStopAtPos(1, 102);
+         if ((active1 & 0x1000000000L) != 0x0L)
+            return jjStopAtPos(1, 100);
          break;
       case '*':
-         if ((active1 & 0x40000000000000L) != 0x0L)
+         if ((active1 & 0x10000000000000L) != 0x0L)
          {
-            jjmatchedKind = 118;
+            jjmatchedKind = 116;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x100L);
       case '+':
-         if ((active1 & 0x10000000000L) != 0x0L)
-            return jjStopAtPos(1, 104);
+         if ((active1 & 0x4000000000L) != 0x0L)
+            return jjStopAtPos(1, 102);
          break;
       case '-':
-         if ((active1 & 0x20000000000L) != 0x0L)
-            return jjStopAtPos(1, 105);
+         if ((active1 & 0x8000000000L) != 0x0L)
+            return jjStopAtPos(1, 103);
          break;
       case '.':
-         if ((active2 & 0x8000000L) != 0x0L)
-            return jjStopAtPos(1, 155);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x4000000L);
-      case ':':
-         if ((active2 & 0x400000L) != 0x0L)
-            return jjStopAtPos(1, 150);
-         else if ((active2 & 0x2000000L) != 0x0L)
+         if ((active2 & 0x2000000L) != 0x0L)
             return jjStopAtPos(1, 153);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x1000000L);
+      case ':':
+         if ((active2 & 0x100000L) != 0x0L)
+            return jjStopAtPos(1, 148);
+         else if ((active2 & 0x800000L) != 0x0L)
+            return jjStopAtPos(1, 151);
          break;
       case '<':
-         if ((active1 & 0x100000000000000L) != 0x0L)
+         if ((active1 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 120;
+            jjmatchedKind = 118;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x1000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x400L);
       case '=':
-         if ((active1 & 0x40000000L) != 0x0L)
-            return jjStopAtPos(1, 94);
-         else if ((active1 & 0x80000000L) != 0x0L)
+         if ((active1 & 0x10000000L) != 0x0L)
+            return jjStopAtPos(1, 92);
+         else if ((active1 & 0x20000000L) != 0x0L)
          {
-            jjmatchedKind = 95;
+            jjmatchedKind = 93;
             jjmatchedPos = 1;
          }
+         else if ((active1 & 0x80000000L) != 0x0L)
+            return jjStopAtPos(1, 95);
          else if ((active1 & 0x200000000L) != 0x0L)
             return jjStopAtPos(1, 97);
-         else if ((active1 & 0x800000000L) != 0x0L)
-            return jjStopAtPos(1, 99);
+         else if ((active1 & 0x1000000000000000L) != 0x0L)
+            return jjStopAtPos(1, 124);
+         else if ((active1 & 0x2000000000000000L) != 0x0L)
+            return jjStopAtPos(1, 125);
          else if ((active1 & 0x4000000000000000L) != 0x0L)
             return jjStopAtPos(1, 126);
          else if ((active1 & 0x8000000000000000L) != 0x0L)
             return jjStopAtPos(1, 127);
          else if ((active2 & 0x1L) != 0x0L)
             return jjStopAtPos(1, 128);
-         else if ((active2 & 0x2L) != 0x0L)
-            return jjStopAtPos(1, 129);
          else if ((active2 & 0x4L) != 0x0L)
             return jjStopAtPos(1, 130);
          else if ((active2 & 0x10L) != 0x0L)
             return jjStopAtPos(1, 132);
          else if ((active2 & 0x40L) != 0x0L)
             return jjStopAtPos(1, 134);
-         else if ((active2 & 0x100L) != 0x0L)
-            return jjStopAtPos(1, 136);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x80000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x20000L);
       case '>':
-         if ((active1 & 0x400000000000000L) != 0x0L)
+         if ((active1 & 0x100000000000000L) != 0x0L)
          {
-            jjmatchedKind = 122;
+            jjmatchedKind = 120;
             jjmatchedPos = 1;
          }
-         else if ((active2 & 0x40000L) != 0x0L)
-            return jjStopAtPos(1, 146);
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x1000000000000000L, active2, 0x14000L);
+         else if ((active2 & 0x10000L) != 0x0L)
+            return jjStopAtPos(1, 144);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x400000000000000L, active2, 0x5000L);
       case '?':
-         if ((active2 & 0x200000L) != 0x0L)
+         if ((active2 & 0x80000L) != 0x0L)
          {
-            jjmatchedKind = 149;
+            jjmatchedKind = 147;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x100000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x0L, active2, 0x40000L);
       case 'a':
-         return jjMoveStringLiteralDfa2_0(active0, 0x240008030000L, active1, 0x8000000000L, active2, 0x8L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0x2000000000L, active2, 0x2L);
       case 'b':
-         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0xa800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x800L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa2_0(active0, 0x2080000200000L, active1, 0x0L, active2, 0x10000000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x820000200000L, active1, 0x0L, active2, 0x4000000L);
       case 'f':
          if ((active0 & 0x200000000L) != 0x0L)
             return jjStartNfaWithStates_0(1, 33, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x402000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x100800000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc304000000040000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x30c1000000040000L, active1, 0x0L, active2, 0x0L);
       case 'i':
          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x200000108000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x41004000L, active1, 0x80000042000000L, active2, 0x800L);
       case 'm':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x20000000000000L, active2, 0x200L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0x8000000000000L, active2, 0x80L);
       case 'n':
-         return jjMoveStringLiteralDfa2_0(active0, 0x19002000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x7002000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x400000L) != 0x0L)
          {
             jjmatchedKind = 22;
             jjmatchedPos = 1;
          }
-         return jjMoveStringLiteralDfa2_0(active0, 0x3000020180981000L, active1, 0x2000000000L, active2, 0x20L);
+         return jjMoveStringLiteralDfa2_0(active0, 0xc00008180981000L, active1, 0x800000000L, active2, 0x8L);
       case 'p':
-         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x0L, active1, 0x20000000000000L, active2, 0x200L);
       case 'r':
-         return jjMoveStringLiteralDfa2_0(active0, 0xc80c00000002000L, active1, 0x2800000000000000L, active2, 0x28000L);
-      case 's':
-         if ((active0 & 0x2000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(1, 37, 42);
-         else if ((active0 & 0x4000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(1, 38, 42);
-         break;
+         return jjMoveStringLiteralDfa2_0(active0, 0x320300000002000L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 't':
-         return jjMoveStringLiteralDfa2_0(active0, 0x18000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x6000000000000L, active1, 0x0L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa2_0(active0, 0x1100000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x440000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         return jjMoveStringLiteralDfa2_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0x0L, active2, 0x0L);
       case 'x':
-         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x80L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0x0L, active2, 0x20L);
       case 'y':
-         return jjMoveStringLiteralDfa2_0(active0, 0x40000000008000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0x0L, active2, 0x0L);
       case '|':
-         if ((active1 & 0x1000000000L) != 0x0L)
-            return jjStopAtPos(1, 100);
+         if ((active1 & 0x400000000L) != 0x0L)
+            return jjStopAtPos(1, 98);
          break;
       default :
          break;
@@ -459,85 +453,85 @@ private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '.':
-         if ((active2 & 0x4000000L) != 0x0L)
-            return jjStopAtPos(2, 154);
+         if ((active2 & 0x1000000L) != 0x0L)
+            return jjStopAtPos(2, 152);
          break;
       case '=':
-         if ((active2 & 0x400L) != 0x0L)
+         if ((active2 & 0x100L) != 0x0L)
+            return jjStopAtPos(2, 136);
+         else if ((active2 & 0x400L) != 0x0L)
             return jjStopAtPos(2, 138);
          else if ((active2 & 0x1000L) != 0x0L)
             return jjStopAtPos(2, 140);
-         else if ((active2 & 0x4000L) != 0x0L)
-            return jjStopAtPos(2, 142);
-         else if ((active2 & 0x100000L) != 0x0L)
-            return jjStopAtPos(2, 148);
+         else if ((active2 & 0x40000L) != 0x0L)
+            return jjStopAtPos(2, 146);
          break;
       case '>':
-         if ((active1 & 0x1000000000000000L) != 0x0L)
+         if ((active1 & 0x400000000000000L) != 0x0L)
          {
-            jjmatchedKind = 124;
+            jjmatchedKind = 122;
             jjmatchedPos = 2;
          }
-         else if ((active2 & 0x80000L) != 0x0L)
-            return jjStopAtPos(2, 147);
-         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x10000L);
+         else if ((active2 & 0x20000L) != 0x0L)
+            return jjStopAtPos(2, 145);
+         return jjMoveStringLiteralDfa3_0(active0, 0x0L, active1, 0x0L, active2, 0x4000L);
       case 'a':
-         return jjMoveStringLiteralDfa3_0(active0, 0x88000000044000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x22000000044000L, active1, 0x0L, active2, 0x0L);
       case 'b':
-         return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
-         return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         return jjMoveStringLiteralDfa3_0(active0, 0x4000000000002000L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x1000000000002000L, active1, 0x80000000000000L, active2, 0x800L);
       case 'f':
-         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x10000000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0x0L, active2, 0x4000000L);
       case 'i':
-         return jjMoveStringLiteralDfa3_0(active0, 0x9020400000000000L, active1, 0x280a800000000000L, active2, 0x28000L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x2408100000000000L, active1, 0xa02a00000000000L, active2, 0xa000L);
       case 'l':
-         return jjMoveStringLiteralDfa3_0(active0, 0x2000100008000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x800040008000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         return jjMoveStringLiteralDfa3_0(active0, 0x40020030180000L, active1, 0x8000000000L, active2, 0x8L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x10008030180000L, active1, 0x2000000000L, active2, 0x2L);
       case 'o':
-         return jjMoveStringLiteralDfa3_0(active0, 0x4800040001000L, active1, 0xa0000000000000L, active2, 0xa80L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x1200040001000L, active1, 0x28000000000000L, active2, 0x2a0L);
       case 'p':
          return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x80000000L) != 0x0L)
             return jjStartNfaWithStates_0(2, 31, 42);
-         else if ((active1 & 0x2000000000L) != 0x0L)
+         else if ((active1 & 0x800000000L) != 0x0L)
          {
-            jjmatchedKind = 101;
+            jjmatchedKind = 99;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x310000000000000L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa3_0(active0, 0xc4000000000000L, active1, 0x0L, active2, 0x8L);
       case 's':
          return jjMoveStringLiteralDfa3_0(active0, 0x1001010800L, active1, 0x0L, active2, 0x0L);
       case 't':
-         if ((active0 & 0x8000000000L) != 0x0L)
+         if ((active0 & 0x2000000000L) != 0x0L)
          {
-            jjmatchedKind = 39;
+            jjmatchedKind = 37;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x2000000L) != 0x0L)
+         else if ((active1 & 0x800000L) != 0x0L)
          {
-            jjmatchedKind = 89;
+            jjmatchedKind = 87;
             jjmatchedPos = 2;
          }
-         else if ((active1 & 0x8000000L) != 0x0L)
+         else if ((active1 & 0x2000000L) != 0x0L)
          {
-            jjmatchedKind = 91;
+            jjmatchedKind = 89;
             jjmatchedPos = 2;
          }
-         return jjMoveStringLiteralDfa3_0(active0, 0x2050104028000L, active1, 0x500000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0x140000000L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa3_0(active0, 0x400000002800000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa3_0(active0, 0x100000002800000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active0 & 0x80000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(2, 43, 42);
+         if ((active0 & 0x20000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(2, 41, 42);
          break;
       case 'y':
-         if ((active0 & 0x800000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(2, 59, 42);
+         if ((active0 & 0x200000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(2, 57, 42);
          break;
       default :
          break;
@@ -555,31 +549,31 @@ private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '=':
-         if ((active2 & 0x10000L) != 0x0L)
-            return jjStopAtPos(3, 144);
+         if ((active2 & 0x4000L) != 0x0L)
+            return jjStopAtPos(3, 142);
          break;
       case '_':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 'a':
-         return jjMoveStringLiteralDfa4_0(active0, 0x2000000070202000L, active1, 0x0L, active2, 0x10000000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x800000070202000L, active1, 0x0L, active2, 0x4000000L);
       case 'b':
          return jjMoveStringLiteralDfa4_0(active0, 0x800000L, active1, 0x0L, active2, 0x0L);
       case 'c':
-         return jjMoveStringLiteralDfa4_0(active0, 0x40000000020000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0x0L, active2, 0x0L);
       case 'd':
-         if ((active0 & 0x1000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 60, 42);
-         else if ((active1 & 0x8000000000L) != 0x0L)
+         if ((active0 & 0x400000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 58, 42);
+         else if ((active1 & 0x2000000000L) != 0x0L)
          {
-            jjmatchedKind = 103;
+            jjmatchedKind = 101;
             jjmatchedPos = 3;
          }
-         else if ((active1 & 0x20000000000000L) != 0x0L)
+         else if ((active1 & 0x8000000000000L) != 0x0L)
          {
-            jjmatchedKind = 117;
+            jjmatchedKind = 115;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x208L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x82L);
       case 'e':
          if ((active0 & 0x8000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 15, 42);
@@ -587,54 +581,54 @@ else if ((active0 & 0x10000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 16, 42);
          else if ((active0 & 0x1000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 24, 42);
-         else if ((active0 & 0x400000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 58, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x10004000000L, active1, 0x500000000L, active2, 0x0L);
+         else if ((active0 & 0x100000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 56, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x4004000000L, active1, 0x140000000L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'g':
-         if ((active0 & 0x20000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 41, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x2800000000000000L, active2, 0x28000L);
+         if ((active0 & 0x8000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 39, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 'i':
-         return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x4010000000000L, active1, 0x0L, active2, 0x0L);
       case 'k':
-         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         if ((active0 & 0x100000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 44, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x8001000400001000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x40000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 42, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x2000400400001000L, active1, 0x0L, active2, 0x0L);
       case 'm':
          if ((active0 & 0x2000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 25, 42);
          break;
       case 'n':
-         if ((active0 & 0x4000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(3, 62, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x1000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(3, 60, 42);
+         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 'o':
          if ((active0 & 0x100000000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 32, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x300000800000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0x0L, active2, 0x0L);
       case 'r':
          if ((active0 & 0x40000L) != 0x0L)
             return jjStartNfaWithStates_0(3, 18, 42);
-         return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0x0L, active2, 0x80L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0x0L, active2, 0x20L);
       case 's':
          return jjMoveStringLiteralDfa4_0(active0, 0x8084000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         return jjMoveStringLiteralDfa4_0(active0, 0x28801000100800L, active1, 0xa800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0xa201000100800L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'u':
-         return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
       case 'v':
-         return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active1 & 0x80000000000000L) != 0x0L)
+         if ((active1 & 0x20000000000000L) != 0x0L)
          {
-            jjmatchedKind = 119;
+            jjmatchedKind = 117;
             jjmatchedPos = 3;
          }
-         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
+         return jjMoveStringLiteralDfa4_0(active0, 0x0L, active1, 0x0L, active2, 0x200L);
       default :
          break;
    }
@@ -651,23 +645,23 @@ private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0xa88L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x0L, active1, 0x0L, active2, 0x2a2L);
       case 'a':
-         return jjMoveStringLiteralDfa5_0(active0, 0x601000000000L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L, active1, 0x0L, active2, 0x8L);
       case 'c':
-         return jjMoveStringLiteralDfa5_0(active0, 0x30000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0xc000000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x8000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 27, 42);
-         else if ((active0 & 0x8000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 63, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x800400001000L, active1, 0x0L, active2, 0x0L);
+         else if ((active0 & 0x2000000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 61, 42);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200400001000L, active1, 0x0L, active2, 0x0L);
       case 'h':
          if ((active0 & 0x20000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 17, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L, active1, 0x2800000000000000L, active2, 0x28000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 'i':
-         return jjMoveStringLiteralDfa5_0(active0, 0x9000000100000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x2400000100000L, active1, 0x0L, active2, 0x0L);
       case 'k':
          if ((active0 & 0x2000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 13, 42);
@@ -682,36 +676,36 @@ else if ((active0 & 0x8000000000000000L) != 0x0L)
       case 'n':
          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'q':
-         if ((active1 & 0x100000000L) != 0x0L)
+         if ((active1 & 0x40000000L) != 0x0L)
+            return jjStopAtPos(4, 94);
+         else if ((active1 & 0x100000000L) != 0x0L)
             return jjStopAtPos(4, 96);
-         else if ((active1 & 0x400000000L) != 0x0L)
-            return jjStopAtPos(4, 98);
          break;
       case 'r':
-         return jjMoveStringLiteralDfa5_0(active0, 0x2010800000800L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x804800000800L, active1, 0x0L, active2, 0x0L);
       case 's':
          if ((active0 & 0x4000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 14, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
          if ((active0 & 0x80000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 19, 42);
          else if ((active0 & 0x40000000L) != 0x0L)
             return jjStartNfaWithStates_0(4, 30, 42);
-         else if ((active0 & 0x4000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(4, 50, 42);
-         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0x200000000000000L, active2, 0x2000L);
+         else if ((active0 & 0x1000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(4, 48, 42);
+         return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0x80000000000000L, active2, 0x800L);
       case 'u':
-         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x10000000L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x200000L, active1, 0x0L, active2, 0x4000000L);
       case 'v':
-         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
       case 'w':
-         if ((active0 & 0x100000000000000L) != 0x0L)
+         if ((active0 & 0x40000000000000L) != 0x0L)
          {
-            jjmatchedKind = 56;
+            jjmatchedKind = 54;
             jjmatchedPos = 4;
          }
-         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0xa800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0x2a00000000000L, active2, 0x0L);
       default :
          break;
    }
@@ -728,51 +722,51 @@ private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'a':
-         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0xa88L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x1800L, active1, 0x0L, active2, 0x2a2L);
       case 'c':
-         if ((active0 & 0x1000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 48, 42);
-         else if ((active0 & 0x8000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 51, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x400000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 46, 42);
+         else if ((active0 & 0x2000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 49, 42);
+         return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
       case 'd':
          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x800000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 23, 42);
-         else if ((active0 & 0x40000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 42, 42);
+         else if ((active0 & 0x10000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 40, 42);
          break;
       case 'f':
-         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L, active1, 0x0L, active2, 0x0L);
       case 'g':
-         return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L, active1, 0x0L, active2, 0x0L);
       case 'h':
-         if ((active0 & 0x20000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 53, 42);
+         if ((active0 & 0x8000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 51, 42);
          break;
       case 'i':
-         return jjMoveStringLiteralDfa6_0(active0, 0x2080000000000000L, active1, 0xa800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x820000000000000L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x10000000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x20200000L, active1, 0x0L, active2, 0x4000000L);
       case 'm':
          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
-         if ((active0 & 0x2000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 49, 42);
+         if ((active0 & 0x800000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 47, 42);
          return jjMoveStringLiteralDfa6_0(active0, 0x1000100000L, active1, 0x0L, active2, 0x0L);
       case 'r':
-         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
       case 's':
-         if ((active0 & 0x200000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(5, 57, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
+         if ((active0 & 0x80000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(5, 55, 42);
+         return jjMoveStringLiteralDfa6_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 't':
          if ((active0 & 0x800000000L) != 0x0L)
             return jjStartNfaWithStates_0(5, 35, 42);
-         return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L, active1, 0x2800000000000000L, active2, 0x28000L);
+         return jjMoveStringLiteralDfa6_0(active0, 0x4100000000000L, active1, 0xa00000000000000L, active2, 0xa000L);
       default :
          break;
    }
@@ -789,38 +783,38 @@ private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x2800000000000000L, active2, 0x28000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0xa00000000000000L, active2, 0xa000L);
       case 'a':
-         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L, active1, 0x0L, active2, 0x0L);
       case 'c':
          return jjMoveStringLiteralDfa7_0(active0, 0x1000000800L, active1, 0x0L, active2, 0x0L);
       case 'e':
-         if ((active0 & 0x200000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(6, 45, 42);
-         else if ((active0 & 0x400000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(6, 46, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x80000400000000L, active1, 0x0L, active2, 0x0L);
+         if ((active0 & 0x80000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(6, 43, 42);
+         else if ((active0 & 0x100000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(6, 44, 42);
+         return jjMoveStringLiteralDfa7_0(active0, 0x20000400000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L, active1, 0x0L, active2, 0x0L);
       case 'l':
-         return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000000L, active1, 0x0L, active2, 0x0L);
       case 'n':
          if ((active0 & 0x1000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 12, 42);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
       case 's':
          if ((active0 & 0x4000000L) != 0x0L)
             return jjStartNfaWithStates_0(6, 26, 42);
-         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x20a800000000000L, active2, 0x2aa8L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x0L, active1, 0x82a00000000000L, active2, 0xaaaL);
       case 't':
          if ((active0 & 0x200000L) != 0x0L)
          {
             jjmatchedKind = 21;
             jjmatchedPos = 6;
          }
-         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L, active1, 0x0L, active2, 0x10000000L);
+         return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L, active1, 0x0L, active2, 0x4000000L);
       case 'u':
          return jjMoveStringLiteralDfa7_0(active0, 0x100000L, active1, 0x0L, active2, 0x0L);
       case 'y':
@@ -843,35 +837,35 @@ private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case ':':
-         if ((active2 & 0x10000000L) != 0x0L)
-            return jjStopAtPos(7, 156);
+         if ((active2 & 0x4000000L) != 0x0L)
+            return jjStopAtPos(7, 154);
          break;
       case 'c':
-         return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L, active1, 0x0L, active2, 0x0L);
       case 'e':
          if ((active0 & 0x100000L) != 0x0L)
             return jjStartNfaWithStates_0(7, 20, 42);
-         else if ((active0 & 0x2000000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(7, 61, 42);
-         return jjMoveStringLiteralDfa8_0(active0, 0x801000000000L, active1, 0xa800000000000L, active2, 0x0L);
+         else if ((active0 & 0x800000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(7, 59, 42);
+         return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'h':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'i':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 'n':
-         return jjMoveStringLiteralDfa8_0(active0, 0xc0000400000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x30000400000000L, active1, 0x0L, active2, 0x0L);
       case 'p':
-         if ((active0 & 0x10000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(7, 52, 42);
+         if ((active0 & 0x4000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(7, 50, 42);
          break;
       case 's':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8a88L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x22a2L);
       case 't':
          if ((active0 & 0x800L) != 0x0L)
             return jjStartNfaWithStates_0(7, 11, 42);
          break;
       case 'u':
-         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa8_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -888,28 +882,28 @@ private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0xa800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x2a00000000000L, active2, 0x0L);
       case 'd':
-         if ((active0 & 0x800000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 47, 42);
+         if ((active0 & 0x200000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 45, 42);
          break;
       case 'e':
-         if ((active0 & 0x10000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 40, 42);
+         if ((active0 & 0x4000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 38, 42);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x20L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x0L, active2, 0x8L);
       case 'h':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'i':
-         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000000L, active1, 0x200000000000000L, active2, 0x2a88L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L, active1, 0x80000000000000L, active2, 0xaa2L);
       case 'n':
-         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa9_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'o':
          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L, active1, 0x0L, active2, 0x0L);
       case 't':
-         if ((active0 & 0x80000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(8, 55, 42);
+         if ((active0 & 0x20000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(8, 53, 42);
          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L, active1, 0x0L, active2, 0x0L);
       default :
          break;
@@ -927,29 +921,29 @@ private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long a
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000L, active2, 0x0L);
       case 'f':
          if ((active0 & 0x1000000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 36, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x80000000000000L, active2, 0x800L);
       case 'g':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0xa88L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x0L, active2, 0x2a2L);
       case 'i':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'n':
-         if ((active2 & 0x20L) != 0x0L)
-            return jjStopAtPos(9, 133);
+         if ((active2 & 0x8L) != 0x0L)
+            return jjStopAtPos(9, 131);
          break;
       case 'o':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
       case 's':
          if ((active0 & 0x400000000L) != 0x0L)
             return jjStartNfaWithStates_0(9, 34, 42);
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'x':
-         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x8000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
       case 'z':
-         return jjMoveStringLiteralDfa10_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
       default :
          break;
    }
@@ -966,34 +960,34 @@ private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case 'e':
-         return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L, active1, 0x0L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L, active1, 0x0L, active2, 0x0L);
       case 'f':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x200000000000000L, active2, 0x2000L);
       case 'i':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x8L) != 0x0L)
-            return jjStopAtPos(10, 131);
+         if ((active2 & 0x2L) != 0x0L)
+            return jjStopAtPos(10, 129);
+         else if ((active2 & 0x20L) != 0x0L)
+            return jjStopAtPos(10, 133);
          else if ((active2 & 0x80L) != 0x0L)
             return jjStopAtPos(10, 135);
          else if ((active2 & 0x200L) != 0x0L)
             return jjStopAtPos(10, 137);
-         else if ((active2 & 0x800L) != 0x0L)
-            return jjStopAtPos(10, 139);
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x800000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x200000000000L, active2, 0x0L);
       case 'o':
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x8000000000000L, active2, 0x0L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x2000000000000L, active2, 0x0L);
       case 'r':
-         if ((active1 & 0x2000000000000L) != 0x0L)
-            return jjStopAtPos(10, 113);
+         if ((active1 & 0x800000000000L) != 0x0L)
+            return jjStopAtPos(10, 111);
          break;
       case 't':
-         if ((active1 & 0x200000000000000L) != 0x0L)
+         if ((active1 & 0x80000000000000L) != 0x0L)
          {
-            jjmatchedKind = 121;
+            jjmatchedKind = 119;
             jjmatchedPos = 10;
          }
-         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa11_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
       default :
          break;
    }
@@ -1010,26 +1004,26 @@ private int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x800L);
       case 'd':
-         if ((active0 & 0x40000000000000L) != 0x0L)
-            return jjStartNfaWithStates_0(11, 54, 42);
-         else if ((active1 & 0x800000000000L) != 0x0L)
-            return jjStopAtPos(11, 111);
+         if ((active0 & 0x10000000000000L) != 0x0L)
+            return jjStartNfaWithStates_0(11, 52, 42);
+         else if ((active1 & 0x200000000000L) != 0x0L)
+            return jjStopAtPos(11, 109);
          break;
       case 'g':
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x800000000000000L, active2, 0x8000L);
       case 'r':
-         if ((active1 & 0x8000000000000L) != 0x0L)
-            return jjStopAtPos(11, 115);
+         if ((active1 & 0x2000000000000L) != 0x0L)
+            return jjStopAtPos(11, 113);
          break;
       case 't':
-         if ((active1 & 0x800000000000000L) != 0x0L)
+         if ((active1 & 0x200000000000000L) != 0x0L)
          {
-            jjmatchedKind = 123;
+            jjmatchedKind = 121;
             jjmatchedPos = 11;
          }
-         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa12_0(active0, 0x0L, active1, 0x0L, active2, 0x2000L);
       default :
          break;
    }
@@ -1046,11 +1040,11 @@ private int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x8000L);
-      case 'a':
          return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x2000L);
+      case 'a':
+         return jjMoveStringLiteralDfa13_0(active1, 0x0L, active2, 0x800L);
       case 'n':
-         return jjMoveStringLiteralDfa13_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa13_0(active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -1067,11 +1061,11 @@ private int jjMoveStringLiteralDfa13_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x2000L);
       case 'e':
-         return jjMoveStringLiteralDfa14_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 's':
-         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa14_0(active1, 0x0L, active2, 0x800L);
       default :
          break;
    }
@@ -1088,9 +1082,9 @@ private int jjMoveStringLiteralDfa14_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'd':
-         return jjMoveStringLiteralDfa15_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 's':
-         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0xa000L);
+         return jjMoveStringLiteralDfa15_0(active1, 0x0L, active2, 0x2800L);
       default :
          break;
    }
@@ -1107,11 +1101,11 @@ private int jjMoveStringLiteralDfa15_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa16_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 'i':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x800L);
       case 's':
-         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa16_0(active1, 0x0L, active2, 0x2000L);
       default :
          break;
    }
@@ -1128,11 +1122,11 @@ private int jjMoveStringLiteralDfa16_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x2000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x800L);
       case 'i':
-         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x0L, active2, 0x2000L);
       case 's':
-         return jjMoveStringLiteralDfa17_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa17_0(active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -1149,12 +1143,12 @@ private int jjMoveStringLiteralDfa17_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x8000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x0L, active2, 0x2000L);
       case 'h':
-         return jjMoveStringLiteralDfa18_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa18_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x2000L) != 0x0L)
-            return jjStopAtPos(17, 141);
+         if ((active2 & 0x800L) != 0x0L)
+            return jjStopAtPos(17, 139);
          break;
       default :
          break;
@@ -1172,10 +1166,10 @@ private int jjMoveStringLiteralDfa18_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa19_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa19_0(active1, 0x800000000000000L, active2, 0x8000L);
       case 'n':
-         if ((active2 & 0x8000L) != 0x0L)
-            return jjStopAtPos(18, 143);
+         if ((active2 & 0x2000L) != 0x0L)
+            return jjStopAtPos(18, 141);
          break;
       default :
          break;
@@ -1193,7 +1187,7 @@ private int jjMoveStringLiteralDfa19_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 'f':
-         return jjMoveStringLiteralDfa20_0(active1, 0x2000000000000000L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa20_0(active1, 0x800000000000000L, active2, 0x8000L);
       default :
          break;
    }
@@ -1210,12 +1204,12 @@ private int jjMoveStringLiteralDfa20_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case 't':
-         if ((active1 & 0x2000000000000000L) != 0x0L)
+         if ((active1 & 0x800000000000000L) != 0x0L)
          {
-            jjmatchedKind = 125;
+            jjmatchedKind = 123;
             jjmatchedPos = 20;
          }
-         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x20000L);
+         return jjMoveStringLiteralDfa21_0(active1, 0x0L, active2, 0x8000L);
       default :
          break;
    }
@@ -1232,7 +1226,7 @@ private int jjMoveStringLiteralDfa21_0(long old1, long active1, long old2, long
    switch(curChar)
    {
       case '_':
-         return jjMoveStringLiteralDfa22_0(active2, 0x20000L);
+         return jjMoveStringLiteralDfa22_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1249,7 +1243,7 @@ private int jjMoveStringLiteralDfa22_0(long old2, long active2){
    switch(curChar)
    {
       case 'a':
-         return jjMoveStringLiteralDfa23_0(active2, 0x20000L);
+         return jjMoveStringLiteralDfa23_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1266,7 +1260,7 @@ private int jjMoveStringLiteralDfa23_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa24_0(active2, 0x20000L);
+         return jjMoveStringLiteralDfa24_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1283,7 +1277,7 @@ private int jjMoveStringLiteralDfa24_0(long old2, long active2){
    switch(curChar)
    {
       case 's':
-         return jjMoveStringLiteralDfa25_0(active2, 0x20000L);
+         return jjMoveStringLiteralDfa25_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1300,7 +1294,7 @@ private int jjMoveStringLiteralDfa25_0(long old2, long active2){
    switch(curChar)
    {
       case 'i':
-         return jjMoveStringLiteralDfa26_0(active2, 0x20000L);
+         return jjMoveStringLiteralDfa26_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1317,7 +1311,7 @@ private int jjMoveStringLiteralDfa26_0(long old2, long active2){
    switch(curChar)
    {
       case 'g':
-         return jjMoveStringLiteralDfa27_0(active2, 0x20000L);
+         return jjMoveStringLiteralDfa27_0(active2, 0x8000L);
       default :
          break;
    }
@@ -1334,8 +1328,8 @@ private int jjMoveStringLiteralDfa27_0(long old2, long active2){
    switch(curChar)
    {
       case 'n':
-         if ((active2 & 0x20000L) != 0x0L)
-            return jjStopAtPos(27, 145);
+         if ((active2 & 0x8000L) != 0x0L)
+            return jjStopAtPos(27, 143);
          break;
       default :
          break;
@@ -1429,8 +1423,8 @@ else if (curChar == 47)
                      { jjAddStates(13, 14); }
                   else if (curChar == 36)
                   {
-                     if (kind > 75)
-                        kind = 75;
+                     if (kind > 73)
+                        kind = 73;
                      { jjCheckNAdd(42); }
                   }
                   else if (curChar == 34)
@@ -1445,14 +1439,14 @@ else if (curChar == 60)
                      { jjCheckNAddStates(0, 3); }
                   if ((0x3fe000000000000L & l) != 0x0L)
                   {
-                     if (kind > 64)
-                        kind = 64;
+                     if (kind > 62)
+                        kind = 62;
                      { jjCheckNAddTwoStates(15, 16); }
                   }
                   else if (curChar == 48)
                   {
-                     if (kind > 64)
-                        kind = 64;
+                     if (kind > 62)
+                        kind = 62;
                      { jjCheckNAddStates(18, 21); }
                   }
                   else if (curChar == 34)
@@ -1519,15 +1513,15 @@ else if (curChar == 34)
                case 14:
                   if ((0x3fe000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 15:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 17:
@@ -1537,8 +1531,8 @@ else if (curChar == 34)
                case 18:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 69)
-                     kind = 69;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddStates(28, 30); }
                   break;
                case 20:
@@ -1548,8 +1542,8 @@ else if (curChar == 34)
                case 21:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 69)
-                     kind = 69;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddTwoStates(21, 22); }
                   break;
                case 23:
@@ -1564,8 +1558,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(15, 17); }
                   break;
                case 27:
-                  if (curChar == 39 && kind > 72)
-                     kind = 72;
+                  if (curChar == 39 && kind > 70)
+                     kind = 70;
                   break;
                case 28:
                   if (curChar == 34)
@@ -1579,8 +1573,8 @@ else if (curChar == 34)
                   { jjCheckNAddStates(22, 24); }
                   break;
                case 32:
-                  if (curChar == 34 && kind > 73)
-                     kind = 73;
+                  if (curChar == 34 && kind > 71)
+                     kind = 71;
                   break;
                case 33:
                case 35:
@@ -1592,8 +1586,8 @@ else if (curChar == 34)
                      { jjCheckNAddStates(31, 33); }
                   break;
                case 36:
-                  if (curChar == 34 && kind > 74)
-                     kind = 74;
+                  if (curChar == 34 && kind > 72)
+                     kind = 72;
                   break;
                case 37:
                   if (curChar == 34)
@@ -1614,15 +1608,15 @@ else if (curChar == 34)
                case 41:
                   if (curChar != 36)
                      break;
-                  if (kind > 75)
-                     kind = 75;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 42:
                   if ((0x3ff001000000000L & l) == 0x0L)
                      break;
-                  if (kind > 75)
-                     kind = 75;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 43:
@@ -1636,15 +1630,15 @@ else if (curChar == 34)
                case 45:
                   if (curChar != 46)
                      break;
-                  if (kind > 69)
-                     kind = 69;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 46:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 69)
-                     kind = 69;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddStates(34, 36); }
                   break;
                case 48:
@@ -1654,8 +1648,8 @@ else if (curChar == 34)
                case 49:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 69)
-                     kind = 69;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddTwoStates(49, 22); }
                   break;
                case 50:
@@ -1669,8 +1663,8 @@ else if (curChar == 34)
                case 53:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 69)
-                     kind = 69;
+                  if (kind > 67)
+                     kind = 67;
                   { jjCheckNAddTwoStates(53, 22); }
                   break;
                case 54:
@@ -1680,36 +1674,36 @@ else if (curChar == 34)
                case 56:
                   if (curChar != 48)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(18, 21); }
                   break;
                case 58:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 60:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 61:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAdd(16); }
                   break;
                case 62:
                   if ((0xff000000000000L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(62, 16); }
                   break;
                case 63:
@@ -1779,8 +1773,8 @@ else if (curChar < 128)
                case 42:
                   if ((0x7fffffe87fffffeL & l) == 0x0L)
                      break;
-                  if (kind > 75)
-                     kind = 75;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 9:
@@ -1789,21 +1783,21 @@ else if (curChar < 128)
                case 15:
                   if (curChar != 95)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(15, 16); }
                   break;
                case 16:
-                  if ((0x88920000889200L & l) != 0x0L && kind > 64)
-                     kind = 64;
+                  if ((0x88920000889200L & l) != 0x0L && kind > 62)
+                     kind = 62;
                   break;
                case 19:
                   if ((0x2000000020L & l) != 0x0L)
                      { jjAddStates(43, 44); }
                   break;
                case 22:
-                  if ((0x80005000800050L & l) != 0x0L && kind > 69)
-                     kind = 69;
+                  if ((0x80005000800050L & l) != 0x0L && kind > 67)
+                     kind = 67;
                   break;
                case 24:
                   if ((0xffffffffefffffffL & l) != 0x0L)
@@ -1839,8 +1833,8 @@ else if (curChar < 128)
                      { jjAddStates(47, 48); }
                   break;
                case 55:
-                  if ((0x5000000050L & l) != 0x0L && kind > 69)
-                     kind = 69;
+                  if ((0x5000000050L & l) != 0x0L && kind > 67)
+                     kind = 67;
                   break;
                case 57:
                   if ((0x100000001000000L & l) != 0x0L)
@@ -1849,22 +1843,22 @@ else if (curChar < 128)
                case 58:
                   if ((0x7e8000007eL & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddTwoStates(58, 16); }
                   break;
                case 59:
                   if ((0x400000004L & l) == 0x0L)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 60:
                   if (curChar != 95)
                      break;
-                  if (kind > 64)
-                     kind = 64;
+                  if (kind > 62)
+                     kind = 62;
                   { jjCheckNAddStates(37, 39); }
                   break;
                case 65:
@@ -1908,8 +1902,8 @@ else if (curChar < 128)
                   }
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
                   {
-                     if (kind > 75)
-                        kind = 75;
+                     if (kind > 73)
+                        kind = 73;
                      { jjCheckNAdd(42); }
                   }
                   break;
@@ -1942,8 +1936,8 @@ else if (curChar < 128)
                case 42:
                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
                      break;
-                  if (kind > 75)
-                     kind = 75;
+                  if (kind > 73)
+                     kind = 73;
                   { jjCheckNAdd(42); }
                   break;
                case 65:
@@ -1992,19 +1986,19 @@ else if (curChar < 128)
 "\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\163", "\141\163", 
-"\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\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", 
-"\164\162\141\156\163\151\145\156\164", "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\165\145", 
-"\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\145\156", 
-"\167\150\151\154\145", null, null, null, null, null, null, null, null, null, null, null, null, null, 
-null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", 
-"\76", "\100\147\164", "\74", "\100\154\164", "\41", "\176", "\75\75", "\74\75", 
-"\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75", "\174\174", "\100\157\162", 
-"\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", 
+"\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\167\151\164\143\150", 
+"\163\171\156\143\150\162\157\156\151\172\145\144", "\164\162\141\156\163\151\145\156\164", "\164\150\162\157\167", 
+"\164\150\162\157\167\163", "\164\162\165\145", "\164\162\171", "\166\157\151\144", 
+"\166\157\154\141\164\151\154\145", "\167\150\145\156", "\167\150\151\154\145", null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", 
+"\135", "\73", "\54", "\56", "\75", "\76", "\100\147\164", "\74", "\100\154\164", 
+"\41", "\176", "\75\75", "\74\75", "\100\154\164\145\161", "\76\75", 
+"\100\147\164\145\161", "\41\75", "\174\174", "\100\157\162", "\46\46", "\100\141\156\144", "\53\53", 
+"\55\55", "\53", "\55", "\52", "\57", "\46", 
 "\100\142\151\164\167\151\163\145\137\141\156\144", "\174", "\100\142\151\164\167\151\163\145\137\157\162", "\136", 
 "\100\142\151\164\167\151\163\145\137\170\157\162", "\45", "\100\155\157\144", "\52\52", "\100\160\157\167", "\74\74", 
 "\100\154\145\146\164\137\163\150\151\146\164", "\76\76", "\100\162\151\147\150\164\137\163\150\151\146\164", "\76\76\76", 
@@ -2290,10 +2284,10 @@ public void SwitchTo(int lexState)
    -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, 0xffffffffffffcf21L, 0x1fffffffL, 
+   0x7ffffffffffff801L, 0xfffffffffffff3c8L, 0x7ffffffL, 
 };
 static final long[] jjtoSkip = {
    0x7feL, 0x0L, 0x0L, 
diff --git a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
index 9182739..dfcb3bd 100644
--- a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
+++ b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
@@ -444,8 +444,6 @@ TOKEN : /* RESERVED WORDS AND LITERALS */
 | < IMPLEMENTS: "implements" >
 | < IMPORT: "import" >
 | < INSTANCEOF: "instanceof" >
-| < IS: "is" >
-| < AS: "as" >
 | < INT: "int" >
 | < INTERFACE: "interface" >
 | < LONG: "long" >
@@ -990,13 +988,7 @@ void InstanceOfExpression() :
 { Token t = null; }
 {
   RelationalExpression()
-  [
-    (t = <INSTANCEOF> | t = <IS>) Type()
-      { jjtThis.kind = t.kind; } #BinaryExpression(2)
-  |
-    t = <AS> Type()
-      { jjtThis.kind = t.kind; } #BinaryExpression(2)
-  ]
+  [t = <INSTANCEOF> Type() { jjtThis.kind = t.kind; } #BinaryExpression(2) ]
 }
 
 void RelationalExpression() :

From c109b7f8a5fb8b5a2a48c81ee8e7190df271d2b2 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Wed, 29 Apr 2026 15:36:49 +0800
Subject: [PATCH 11/27] perf: optimize default import order

---
 .../src/main/java/bsh/NameSpace.java             | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java
index ed22915..67ac3d8 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java
@@ -1386,14 +1386,6 @@ public void loadDefaultImports() {
          * precedence rules... so for max efficiency put the most common ones
          * later. */
         this.importPackage("org.json");
-        this.importPackage("java.util.stream");
-        this.importPackage("java.util.regex");
-        this.importPackage("java.util.function");
-        this.importPackage("java.util");
-        this.importPackage("java.net");
-        this.importPackage("java.math");
-        this.importPackage("java.lang");
-        this.importPackage("java.io");
         this.importPackage("android.widget");
         this.importPackage("android.view");
         this.importPackage("android.text");
@@ -1401,6 +1393,14 @@ public void loadDefaultImports() {
         this.importPackage("android.graphics");
         this.importPackage("android.content");
         this.importPackage("android.app");
+        this.importPackage("java.util.stream");
+        this.importPackage("java.util.regex");
+        this.importPackage("java.util.function");
+        this.importPackage("java.util");
+        this.importPackage("java.net");
+        this.importPackage("java.math");
+        this.importPackage("java.io");
+        this.importPackage("java.lang");
         this.importCommands("/bsh/commands");
     }
 

From 47adb241859aa78bc0149327aaa3eb09bf405de8 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Wed, 29 Apr 2026 16:48:17 +0800
Subject: [PATCH 12/27] refactor: move version constant into Version class

---
 bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java | 2 +-
 bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java     | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
index df627ed..c3074be 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
@@ -116,7 +116,7 @@ necessarily have an interpreter reference (e.g. tracing in utils).
     private boolean EOF;
     public static boolean TRACE;
     public static boolean COMPATIBIILTY;
-    public static final String VERSION = "3.0.0.beta10";
+    public static final String VERSION = Version.VERSION;
 
     static {
         // ResourceBundle b = ResourceBundle.getBundle("version");
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java
new file mode 100644
index 0000000..be14c25
--- /dev/null
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java
@@ -0,0 +1,5 @@
+package bsh;
+
+public final class Version {
+    public static final String VERSION = "3.0.0.beta10";
+}

From e140c580cf020fac3fd30149d71b940782e60a49 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Wed, 29 Apr 2026 16:48:44 +0800
Subject: [PATCH 13/27] chore: bump 3.0.0.beta11

---
 bsh-lambda-300-eee36c8/build.gradle.kts               | 2 +-
 bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/build.gradle.kts b/bsh-lambda-300-eee36c8/build.gradle.kts
index 4c49a68..23d51b5 100644
--- a/bsh-lambda-300-eee36c8/build.gradle.kts
+++ b/bsh-lambda-300-eee36c8/build.gradle.kts
@@ -11,7 +11,7 @@ plugins {
 
 val publishGroupId = "io.github.copylibs"
 val publishArtifactId = "beanshell-android-lambda"
-val publishVersion = "3.0.0.beta10"
+val publishVersion = "3.0.0.beta11"
 
 android {
     namespace = "bsh.lambda_300_eee36c8"
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java
index be14c25..4ff58d7 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Version.java
@@ -1,5 +1,5 @@
 package bsh;
 
 public final class Version {
-    public static final String VERSION = "3.0.0.beta10";
+    public static final String VERSION = "3.0.0.beta11";
 }

From df639cbf75fb676cd58f28ab46dd7938eca9ff99 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 30 Apr 2026 01:45:46 +0800
Subject: [PATCH 14/27] refactor: normalize EvalError trace and SimpleNode
 token spacing

---
 .../src/main/java/bsh/EvalError.java                 | 12 +++++-------
 .../src/main/java/bsh/SimpleNode.java                | 10 +++++++---
 .../src/main/java/bsh/TargetError.java               |  5 ++---
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/EvalError.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/EvalError.java
index c2e2ec2..430d8cc 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/EvalError.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/EvalError.java
@@ -66,15 +66,14 @@ public String getMessage()
     {
         String trace;
         if ( node != null )
-            trace = " : at Line: "+ node.getLineNumber()
-                + " : in file: "+ node.getSourceFile()
-                + " : "+node.getText();
+            trace = "\n\t" + "at " + node.getText() + " "
+                + "(" + node.getSourceFile() + ":" + node.getLineNumber() + ")";
         else
             // Users should not normally see this.
             trace = ": <at unknown location>";
 
         if ( callstack != null )
-            trace = trace +"\n" + getScriptStackTrace();
+            trace = trace + getScriptStackTrace();
 
         return getRawMessage() + trace;
     }
@@ -136,9 +135,8 @@ public String getScriptStackTrace()
             {
                 trace = trace + "\nCalled from method: " + ns.getName();
                 if ( node != null )
-                    trace += " : at Line: "+ node.getLineNumber()
-                        + " : in file: "+ node.getSourceFile()
-                        + " : "+node.getText();
+                    trace += "\n\t" + "at " + node.getText() + " "
+                        + "(" + node.getSourceFile() + ":" + node.getLineNumber() + ")";
             }
         }
 
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/SimpleNode.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/SimpleNode.java
index 85c3f52..24611be 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/SimpleNode.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/SimpleNode.java
@@ -229,12 +229,16 @@ public String getText()
         Token t = firstToken;
         while ( t!=null ) {
             text.append(t.image);
-            if ( !t.image.equals(".") )
-                text.append(" ");
             if ( t==lastToken ||
                 t.image.equals("{") || t.image.equals(";") )
                 break;
-            t=t.next;
+            Token next=t.next;
+            if ( next==null )
+                break;
+            if ( next.beginLine > t.endLine ||
+                next.beginColumn > t.endColumn + 1 )
+                text.append(" ");
+            t=next;
         }
 
         return text.toString();
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/TargetError.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/TargetError.java
index 0a25fae..9e70a36 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/TargetError.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/TargetError.java
@@ -70,9 +70,8 @@ public synchronized Throwable getTarget()
 
     public synchronized String getMessage()
     {
-        return super.getMessage()
-            + "Caused by: " +
-            printTargetError( getCause() );
+        return super.getMessage() + "\n"
+            + "Caused by: " + printTargetError( getCause() );
     }
 
     public void printStackTrace( boolean debug, PrintStream out ) {

From c526776c987f5ed10543d8ab9790fc6744de4695 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 30 Apr 2026 01:46:02 +0800
Subject: [PATCH 15/27] refactor: wrap log text view with scroll containers

---
 app/src/main/res/layout/fragment_about.xml |  2 +-
 app/src/main/res/layout/fragment_log.xml   | 44 ++++++++++++++--------
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/app/src/main/res/layout/fragment_about.xml b/app/src/main/res/layout/fragment_about.xml
index ea60b7a..d14f899 100644
--- a/app/src/main/res/layout/fragment_about.xml
+++ b/app/src/main/res/layout/fragment_about.xml
@@ -26,7 +26,7 @@
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         android:orientation="vertical"
-        android:padding="16dp"
+        android:paddingHorizontal="12dp"
         app:layout_behavior="@string/appbar_scrolling_view_behavior">
 
         <com.google.android.material.textview.MaterialTextView
diff --git a/app/src/main/res/layout/fragment_log.xml b/app/src/main/res/layout/fragment_log.xml
index aecde3b..49d2697 100644
--- a/app/src/main/res/layout/fragment_log.xml
+++ b/app/src/main/res/layout/fragment_log.xml
@@ -22,26 +22,38 @@
 
     </com.google.android.material.appbar.AppBarLayout>
 
-    <LinearLayout
+    <HorizontalScrollView
         android:layout_width="match_parent"
         android:layout_height="match_parent"
-        android:orientation="vertical"
-        android:padding="16dp"
+        android:clipToPadding="false"
+        android:fillViewport="true"
+        android:paddingHorizontal="12dp"
+        android:scrollbars="horizontal"
         app:layout_behavior="@string/appbar_scrolling_view_behavior">
 
-        <com.google.android.material.textview.MaterialTextView
-            android:id="@+id/logTvContent"
-            style="@style/TextAppearance.AppCompat.Small"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
+        <ScrollView
+            android:layout_width="wrap_content"
+            android:layout_height="match_parent"
             android:clipToPadding="false"
-            android:fontFamily="monospace"
-            android:hyphenationFrequency="fullFast"
-            android:textColor="?attr/colorOnSurface"
-            android:textIsSelectable="true"
-            android:textSize="12sp"
-            tools:text="Log" />
-
-    </LinearLayout>
+            android:fillViewport="true"
+            android:scrollbars="vertical">
+
+            <com.google.android.material.textview.MaterialTextView
+                android:id="@+id/logTvContent"
+                style="@style/TextAppearance.AppCompat.Small"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:clipToPadding="false"
+                android:fontFamily="monospace"
+                android:hyphenationFrequency="none"
+                android:scrollHorizontally="true"
+                android:textColor="?attr/colorOnSurface"
+                android:textIsSelectable="true"
+                android:textSize="12sp"
+                tools:text="Log" />
+
+        </ScrollView>
+
+    </HorizontalScrollView>
 
 </androidx.coordinatorlayout.widget.CoordinatorLayout>
\ No newline at end of file

From 6e868df41f083051753bc97cff2ca6d1f0ec1ea2 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 30 Apr 2026 03:14:40 +0800
Subject: [PATCH 16/27] fix: pack Java varargs into arrays before MethodHandle
 invoke

Arrays.asList(null)
Arrays.asList("A", "B", "C")
String.format("%s", "hi")
String.format("hi")
---
 .../src/main/java/bsh/Invocable.java          | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
index f96e83c..717d041 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
@@ -17,6 +17,7 @@
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
@@ -332,19 +333,22 @@ public ParameterType collectParamaters(Object base, Object[] params)
         boolean isFixedArity = false;
         if (isVarArgs()) {
             if (getLastParameterIndex() < params.length) {
-                Object[] varargs;
+                Object lastParam = params[getLastParameterIndex()];
                 if (getParameterCount() == params.length
-                    && params[getLastParameterIndex()].getClass().isArray()
-                    && getVarArgsComponentType().isAssignableFrom(params[getLastParameterIndex()].getClass().getComponentType())) {
+                    && lastParam != null
+                    && lastParam.getClass().isArray()
+                    && getVarArgsComponentType().isAssignableFrom(lastParam.getClass().getComponentType())) {
                     isFixedArity = true;
-                    parameters.add(params[getLastParameterIndex()]);
+                    parameters.add(lastParam);
                 } else {
-                    varargs = Arrays.copyOfRange(
-                            params, getLastParameterIndex(), params.length);
-                    for (int i = 0; i < varargs.length; i++)
-                        parameters.add(super.coerceToType(
-                            varargs[i], getVarArgsComponentType()));
+                    int length = params.length - getLastParameterIndex();
+                    Object varargs = Array.newInstance(getVarArgsComponentType(), length);
+                    for (int i = 0; i < length; i++)
+                        Array.set(varargs, i, super.coerceToType(params[getLastParameterIndex() + i], getVarArgsComponentType()));
+                    parameters.add(varargs);
                 }
+            } else {
+                parameters.add(Array.newInstance(getVarArgsComponentType(), 0));
             }
         } else if (null != params && getLastParameterIndex() < params.length)
             parameters.add(super.coerceToType(params[getLastParameterIndex()],

From 01b43a2106af702da332964305e2860feb7a4a25 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 30 Apr 2026 10:28:24 +0800
Subject: [PATCH 17/27] perf: Interpreter eval sourceName

---
 bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
index c3074be..c4b6521 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
@@ -621,7 +621,7 @@ public Object source(File file, NameSpace namespace)
         Interpreter.debug("Sourcing file: ", file);
         Reader sourceIn = new BufferedReader( new FileReader(file) );
         try {
-           return eval( sourceIn, namespace, file.getPath() );
+           return eval( sourceIn, namespace, file.getName() );
         } finally {
             sourceIn.close();
         }
@@ -807,7 +807,7 @@ public Object eval( Reader in ) throws EvalError
     */
     public Object eval( String statements ) throws EvalError {
         Interpreter.debug("eval(String): ", statements);
-        return eval(statements, globalNameSpace, "Memory");
+        return eval(statements, globalNameSpace, "eval string");
     }
 
     /**

From 0161d116218f6d50658a4743a23a2df7e5e9e902 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Thu, 30 Apr 2026 10:29:37 +0800
Subject: [PATCH 18/27] feat: add loadJava to bsh demo app

---
 .../main/java/io/github/copylibs/bsh/plugin/PluginManager.kt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt b/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt
index fb1a986..e5c506c 100644
--- a/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt
+++ b/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt
@@ -31,6 +31,11 @@ object PluginManager {
                 testClass2.print(args[0])
             }
         )
+        plugin.setMethod(
+            BshMethod("loadJava", arrayOf(String::class.java)) { args ->
+                plugin.source(args[0].toString())
+            }
+        )
         plugin.setMethod(
             BshMethod("loadDex", arrayOf(String::class.java)) { args ->
                 plugin.loadDex(args[0].toString())

From aceeb01204c81020a20bf809ead1126060613af0 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Sat, 2 May 2026 02:00:25 +0800
Subject: [PATCH 19/27] fix: restore Object[] array-style calls for Java
 varargs

ArrayList.class.getDeclaredMethod("add", (Object[]){int.class, Object.class})
---
 .../src/main/java/bsh/Invocable.java                | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
index 717d041..c1c2a33 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
@@ -340,11 +340,22 @@ public ParameterType collectParamaters(Object base, Object[] params)
                     && getVarArgsComponentType().isAssignableFrom(lastParam.getClass().getComponentType())) {
                     isFixedArity = true;
                     parameters.add(lastParam);
+                } else if (getParameterCount() == params.length
+                    && lastParam != null
+                    && lastParam.getClass().isArray()
+                    && Object[].class.isAssignableFrom(lastParam.getClass())) {
+                    Object[] source = (Object[]) lastParam;
+                    Object varargs = Array.newInstance(getVarArgsComponentType(), source.length);
+                    for (int i = 0; i < source.length; i++)
+                        Array.set(varargs, i, super.coerceToType(
+                            source[i], getVarArgsComponentType()));
+                    parameters.add(varargs);
                 } else {
                     int length = params.length - getLastParameterIndex();
                     Object varargs = Array.newInstance(getVarArgsComponentType(), length);
                     for (int i = 0; i < length; i++)
-                        Array.set(varargs, i, super.coerceToType(params[getLastParameterIndex() + i], getVarArgsComponentType()));
+                        Array.set(varargs, i, super.coerceToType(
+                            params[getLastParameterIndex() + i], getVarArgsComponentType()));
                     parameters.add(varargs);
                 }
             } else {

From 9120def56d4c9ded93eac25eb83f1c3706c00b32 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Sat, 2 May 2026 10:38:59 +0800
Subject: [PATCH 20/27] chore: add checkstyle verification for bsh lambda
 module

---
 bsh-lambda-300-eee36c8/build.gradle.kts       |  1 +
 .../src/conf/checkstyle-supressions.xml       | 50 ++++++++++++++++++
 .../src/main/java/bsh/Interpreter.java        |  1 -
 .../build-logic.bsh.checkstyle.gradle.kts     | 52 +++++++++++++++++++
 4 files changed, 103 insertions(+), 1 deletion(-)
 create mode 100644 bsh-lambda-300-eee36c8/src/conf/checkstyle-supressions.xml
 create mode 100644 build-logic/src/main/kotlin/build-logic.bsh.checkstyle.gradle.kts

diff --git a/bsh-lambda-300-eee36c8/build.gradle.kts b/bsh-lambda-300-eee36c8/build.gradle.kts
index 23d51b5..1434272 100644
--- a/bsh-lambda-300-eee36c8/build.gradle.kts
+++ b/bsh-lambda-300-eee36c8/build.gradle.kts
@@ -5,6 +5,7 @@ import com.vanniktech.maven.publish.SourcesJar
 plugins {
     id("build-logic.android.library")
     id("build-logic.bsh.codegen")
+    id("build-logic.bsh.checkstyle")
     id("com.vanniktech.maven.publish") version "0.36.0"
     id("signing")
 }
diff --git a/bsh-lambda-300-eee36c8/src/conf/checkstyle-supressions.xml b/bsh-lambda-300-eee36c8/src/conf/checkstyle-supressions.xml
new file mode 100644
index 0000000..cd4db55
--- /dev/null
+++ b/bsh-lambda-300-eee36c8/src/conf/checkstyle-supressions.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0"?>
+
+<!DOCTYPE suppressions PUBLIC
+    "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
+    "https://checkstyle.org/dtds/suppressions_1_2.dtd">
+
+<suppressions>
+
+<!-- suppressions for limited code style, only temporary -->
+    <suppress files=".*" checks="ParenPad" />
+    <suppress files=".*" checks="javadoc" />
+    <suppress files=".*" checks="OperatorWrap" />
+    <suppress files=".*" checks="LeftCurly" />
+    <suppress files=".*" checks="RightCurly" />
+    <suppress files=".*" checks="WhitespaceAfter" />
+    <suppress files=".*" checks="NoWhitespaceAfter" />
+    <suppress files=".*" checks="NoWhitespaceBefore" />
+    <suppress files=".*" checks="MethodParamPad" />
+    <suppress files=".*" checks="EmptyForIteratorPad" />
+    <suppress files=".*" checks="ModifierOrder" />
+
+
+<!-- TODO comments are handy -->
+    <suppress files=".*" checks="TodoComment" />
+
+<!-- lets not be anal: allow inline conditions and 1 line statements -->
+    <suppress files=".*" checks="ArrayTypeStyle" />
+    <suppress files=".*" checks="AvoidInlineConditionals" />
+    <suppress files=".*" checks="NeedBraces" />
+    <suppress files=".*" checks="WhitespaceAround" />
+
+<!-- Not specifying interface members as public is debateable -->
+    <suppress files=".*" checks="RedundantModifier" />
+<!-- explicitly marking parameters final is just daft -->
+    <suppress files=".*" checks="FinalParameters" />
+<!-- 80 character line is ideal but a few places over is not a crisis -->
+    <suppress files=".*" checks="LineLength" />
+
+
+<!-- These fall outside the scope of code clean-up and requires refactoring -->
+    <suppress files=".*" checks="naming" />
+    <suppress files=".*" checks="design" />
+    <suppress files=".*" checks="coding" />
+    <suppress files=".*" checks="MethodLength" />
+    <suppress files=".*" checks="FileLength" />
+    <suppress files=".*" checks="ParameterNumber" />
+    <suppress files=".*" checks="AvoidNestedBlocks" />
+    <suppress files=".*" checks="EmptyBlock" />
+
+</suppressions>
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
index c4b6521..43b84a3 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Interpreter.java
@@ -39,7 +39,6 @@
 import java.io.StringReader;
 import java.lang.reflect.InvocationTargetException;
 import java.net.URL;
-import java.util.ResourceBundle;
 
 import bsh.preprocess.AnnotationIgnorePreprocess;
 import bsh.preprocess.DefaultArgsDesugar;
diff --git a/build-logic/src/main/kotlin/build-logic.bsh.checkstyle.gradle.kts b/build-logic/src/main/kotlin/build-logic.bsh.checkstyle.gradle.kts
new file mode 100644
index 0000000..3e4c8a9
--- /dev/null
+++ b/build-logic/src/main/kotlin/build-logic.bsh.checkstyle.gradle.kts
@@ -0,0 +1,52 @@
+plugins {
+    checkstyle
+}
+
+val checkstyleToolVersion = "9.2.1"
+val embeddedCheckstyleConfig = configurations.detachedConfiguration(
+    dependencies.create("com.puppycrawl.tools:checkstyle:$checkstyleToolVersion")
+).apply {
+    isTransitive = false
+}
+
+extensions.configure<CheckstyleExtension> {
+    toolVersion = checkstyleToolVersion
+    config = resources.text.fromArchiveEntry(embeddedCheckstyleConfig, "sun_checks.xml")
+    configProperties["org.checkstyle.sun.suppressionfilter.config"] = project.file("src/conf/checkstyle-supressions.xml").absolutePath
+    isShowViolations = true
+}
+
+val checkstyleMain by tasks.registering(Checkstyle::class) {
+    group = LifecycleBasePlugin.VERIFICATION_GROUP
+    description = "Code 格式检查"
+
+    source("src/main/java")
+    include("**/*.java")
+    exclude("**/build/**")
+    exclude(
+        listOf(
+            "bsh/AbstractCharStream.java",
+            "bsh/BSHAutoCloseable.java",
+            "bsh/BSHEnumConstant.java",
+            "bsh/BSHLabeledStatement.java",
+            "bsh/BSHMultiCatch.java",
+            "bsh/BSHTryWithResources.java",
+            "bsh/CharStream.java",
+            "bsh/JavaCharStream.java",
+            "bsh/JJTParserState.java",
+            "bsh/Node.java",
+            "bsh/ParseException.java",
+            "bsh/Parser.java",
+            "bsh/ParserConstants.java",
+            "bsh/ParserTokenManager.java",
+            "bsh/ParserTreeConstants.java",
+            "bsh/Token.java",
+            "bsh/TokenMgrException.java",
+        )
+    )
+    classpath = files()
+}
+
+tasks.matching { it.name == LifecycleBasePlugin.CHECK_TASK_NAME }.configureEach {
+    dependsOn(checkstyleMain)
+}

From 0e8a6a8ff444c1409f6f46ac828578779d5e46b1 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Sat, 2 May 2026 11:19:07 +0800
Subject: [PATCH 21/27] fix: allow return when expression in parser

String get(b) {
  return when(b) {
    1 -> "01"
    else -> "00"
  }
}
print(get(1))
---
 .../src/main/java/bsh/Parser.java             | 47 ++++++++++---------
 .../src/main/jjtree/bsh.jjt                   |  1 +
 2 files changed, 25 insertions(+), 23 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
index 76fbd0d..f299abc 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
@@ -215,6 +215,7 @@ boolean isSameLineReturnExpression()
             case STRING_LITERAL:
             case LONG_STRING_LITERAL:
             case IDENTIFIER:
+            case WHEN:
             case LPAREN:
             case LBRACE:
             case LBRACKET:
@@ -5520,6 +5521,29 @@ private boolean jj_2_38(int xla)
     finally { jj_save(37, xla); }
   }
 
+  private boolean jj_3_33()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_53()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_115()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_33()) {
+    jj_scanpos = xsp;
+    if (jj_3R_142()) return true;
+    }
+    return false;
+  }
+
   private boolean jj_3R_171()
  {
     Token xsp;
@@ -8183,29 +8207,6 @@ private boolean jj_3R_253()
     return false;
   }
 
-  private boolean jj_3_33()
- {
-    if (jj_scan_token(FOR)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_115()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_33()) {
-    jj_scanpos = xsp;
-    if (jj_3R_142()) return true;
-    }
-    return false;
-  }
-
   /** Generated Token Manager. */
   public ParserTokenManager token_source;
   JavaCharStream jj_input_stream;
diff --git a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
index dfcb3bd..c02f905 100644
--- a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
+++ b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
@@ -293,6 +293,7 @@ public class Parser
             case STRING_LITERAL:
             case LONG_STRING_LITERAL:
             case IDENTIFIER:
+            case WHEN:
             case LPAREN:
             case LBRACE:
             case LBRACKET:

From 48a6807e5c032d5a9c943a76481e95539b44add3 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Sat, 2 May 2026 11:23:36 +0800
Subject: [PATCH 22/27] fix: preserve string template precedence in chained
 calls

var i = 1
print("dev-$i".length())
---
 .../src/main/java/bsh/preprocess/KtStringTemplate.java          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/KtStringTemplate.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/KtStringTemplate.java
index eed4570..fa78de5 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/KtStringTemplate.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/preprocess/KtStringTemplate.java
@@ -175,7 +175,7 @@ private static String rewriteStringLiteral(String content, boolean fromLongStrin
         if (pieces.isEmpty()) {
             return "\"\"";
         }
-        return joinWithPlus(pieces);
+        return "(" + joinWithPlus(pieces) + ")";
     }
 
     private static String joinWithPlus(List<String> pieces) {

From c66d0742d634b24776cb4d1f68409bef2aa284d0 Mon Sep 17 00:00:00 2001
From: oneQAQone <3900183615@qq.com>
Date: Sat, 2 May 2026 20:11:42 +0800
Subject: [PATCH 23/27] feat: add extension method support

---
 README.md                                     |    6 +
 .../main/java/bsh/BSHMethodDeclaration.java   |   92 +-
 .../src/main/java/bsh/BshMethod.java          |   42 +-
 .../src/main/java/bsh/Name.java               |   12 +
 .../src/main/java/bsh/NameSpace.java          |   28 +
 .../src/main/java/bsh/Parser.java             | 2603 +++++++++--------
 .../src/main/java/bsh/ParserTokenManager.java |  256 +-
 .../src/main/java/bsh/Reflect.java            |    9 +
 .../src/main/java/bsh/This.java               |    4 +-
 .../src/main/jjtree/bsh.jjt                   |   40 +-
 10 files changed, 1747 insertions(+), 1345 deletions(-)

diff --git a/README.md b/README.md
index ecb32f9..b84f83e 100644
--- a/README.md
+++ b/README.md
@@ -135,6 +135,12 @@ switch (num) {
     default: out2 = "other";
 }
 print(out2) // "small"
+
+// 扩展方法
+void String.log() {
+    print(this)
+}
+"BeanShell".log() // BeanShell
 ```
 
 ## 致谢
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHMethodDeclaration.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHMethodDeclaration.java
index bf725c8..4d3bc9c 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHMethodDeclaration.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BSHMethodDeclaration.java
@@ -27,6 +27,8 @@
 
 package bsh;
 
+import java.lang.reflect.Array;
+
 class BSHMethodDeclaration extends SimpleNode
 {
     public String name;
@@ -49,6 +51,10 @@ class BSHMethodDeclaration extends SimpleNode
     boolean isVarArgs;
     private boolean isScriptedObject;
 
+    boolean isExtension;
+    String receiverText;
+    Class<?> receiverType;
+
     BSHMethodDeclaration(int id) { super(id); }
 
     /**
@@ -60,20 +66,40 @@ synchronized void insureNodesParsed()
         if ( paramsNode != null ) // there is always a paramsNode
             return;
 
-        Object firstNode = jjtGetChild(0);
-        firstThrowsClause = 1;
+        int childIndex = 0;
+        Node firstNode = jjtGetChild(childIndex);
+
         if ( firstNode instanceof BSHReturnType )
         {
             returnTypeNode = (BSHReturnType)firstNode;
-            paramsNode = (BSHFormalParameters)jjtGetChild(1);
-            if ( jjtGetNumChildren() > 2+numThrows )
-                blockNode = (BSHBlock)jjtGetChild(2+numThrows); // skip throws
-            ++firstThrowsClause;
+            childIndex++;
+            firstNode = jjtGetChild(childIndex);
         }
-        else
+
+        if ( firstNode instanceof BSHAmbiguousName )
         {
-            paramsNode = (BSHFormalParameters)jjtGetChild(0);
-            blockNode = (BSHBlock)jjtGetChild(1+numThrows); // skip throws
+            String fullName = ((BSHAmbiguousName)firstNode).text;
+            int dot = fullName.lastIndexOf('.');
+            if ( dot >= 0 ) {
+                this.isExtension = true;
+                this.receiverText = fullName.substring(0, dot);
+                this.name = fullName.substring(dot + 1);
+            }
+            else
+            {
+                this.isExtension = false;
+                this.receiverText = null;
+                this.name = fullName;
+            }
+            childIndex++;
+        }
+
+        paramsNode = (BSHFormalParameters)jjtGetChild(childIndex);
+
+        childIndex++;
+        firstThrowsClause = childIndex;
+        if ( jjtGetNumChildren() > childIndex + numThrows ) {
+            blockNode = (BSHBlock)jjtGetChild(childIndex + numThrows);
         }
 
         if (null != blockNode && blockNode.jjtGetNumChildren() > 0) {
@@ -102,6 +128,53 @@ Class<?> evalReturnType( CallStack callstack, Interpreter interpreter )
             return null;
     }
 
+    /**
+        Evaluate the receiver type for an extension method declaration.
+        @return the receiver class, or null if this is not an extension method
+     */
+    Class<?> evalReceiverType( CallStack callstack, Interpreter interpreter )
+        throws EvalError
+    {
+        insureNodesParsed();
+        if ( isExtension && receiverText != null ) {
+            try {
+                String baseText = receiverText;
+
+                int dimensions = 0;
+                while ( baseText.endsWith("[]") ) {
+                    dimensions++;
+                    baseText = baseText.substring(0, baseText.length() - 2);
+                }
+
+                Class<?> clas;
+                switch (baseText) {
+                    case "boolean": clas = boolean.class; break;
+                    case "char":    clas = char.class; break;
+                    case "byte":    clas = byte.class; break;
+                    case "short":   clas = short.class; break;
+                    case "int":     clas = int.class; break;
+                    case "long":    clas = long.class; break;
+                    case "float":   clas = float.class; break;
+                    case "double":  clas = double.class; break;
+                    default:
+                        clas = callstack.top().getClass( baseText );
+                        if ( clas == null ) {
+                            throw new UtilEvalError("Extension receiver type not found: " + baseText);
+                        }
+                        break;
+                }
+
+                if ( dimensions == 0 )
+                    return clas;
+                else
+                    return Array.newInstance(clas, new int[dimensions]).getClass();
+            } catch ( UtilEvalError e ) {
+                throw e.toEvalError( this, callstack );
+            }
+        }
+        return null;
+    }
+
     String getReturnTypeDescriptor(
         CallStack callstack, Interpreter interpreter, String defaultPackage )
     {
@@ -126,6 +199,7 @@ public Object eval( CallStack callstack, Interpreter interpreter )
         throws EvalError
     {
         returnType = evalReturnType( callstack, interpreter );
+        receiverType = evalReceiverType( callstack, interpreter );
         evalNodes( callstack, interpreter );
 
         // Install an *instance* of this method in the namespace.
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshMethod.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshMethod.java
index 9f2ddd2..1f46a40 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshMethod.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshMethod.java
@@ -26,6 +26,8 @@
 
 package bsh;
 
+import static bsh.This.Keys.BSHEXTENSIONMETHODRECEIVER;
+
 import java.io.Serializable;
 import java.lang.reflect.Array;
 import java.lang.reflect.InvocationTargetException;
@@ -85,7 +87,10 @@ public interface MethodCallback {
     // Callback Method, for a BshObject that delegates to a host callback
     private transient MethodCallback methodCallback;
     protected boolean isVarArgs;
-    boolean isScriptedObject = false;
+    protected boolean isScriptedObject = false;
+    // Extension Method
+    protected boolean isExtension = false;
+    protected Class<?> receiverType = null;
 
     // End method components
 
@@ -97,6 +102,8 @@ public interface MethodCallback {
             method.paramsNode.paramTypes, method.paramsNode.getParamModifiers(),
             method.blockNode, declaringNameSpace, modifiers, method.isVarArgs );
         this.isScriptedObject = isScriptedObject;
+        this.isExtension = method.isExtension;
+        this.receiverType = method.receiverType;
     }
 
     BshMethod(
@@ -293,7 +300,7 @@ of the stack (i.e. it will look for purposes of the method
     */
     Object invoke(
         Object[] argValues, Interpreter interpreter, CallStack callstack,
-            Node callerInfo, boolean overrideNameSpace )
+            Node callerInfo, boolean overrideNameSpace, Object extensionReceiver )
         throws EvalError
     {
         Interpreter.debug("Bsh method invoke: ", this.name, " overrideNameSpace: ", overrideNameSpace);
@@ -349,11 +356,19 @@ Object invoke(
             {
                 return invokeImpl(
                     argValues, interpreter, callstack,
-                    callerInfo, overrideNameSpace );
+                    callerInfo, overrideNameSpace, extensionReceiver );
             }
         } else
             return invokeImpl( argValues, interpreter, callstack, callerInfo,
-                overrideNameSpace );
+                overrideNameSpace, extensionReceiver );
+    }
+
+    Object invoke(
+        Object[] argValues, Interpreter interpreter, CallStack callstack,
+            Node callerInfo, boolean overrideNameSpace )
+        throws EvalError
+    {
+        return invoke(argValues, interpreter, callstack, callerInfo, overrideNameSpace, null);
     }
 
     private Object invokeMethodCallback(
@@ -389,7 +404,7 @@ private Object invokeMethodCallback(
 
     private Object invokeImpl(
         Object[] argValues, Interpreter interpreter, CallStack callstack,
-            Node callerInfo, boolean overrideNameSpace )
+            Node callerInfo, boolean overrideNameSpace, Object extensionReceiver )
         throws EvalError
     {
         if (hasModifier("abstract"))
@@ -435,6 +450,15 @@ private Object invokeImpl(
             localNameSpace = new NameSpace( declaringNameSpace, name );
             localNameSpace.isMethod = true;
         }
+
+        if ( isExtension && extensionReceiver != null ) {
+            Object rawReceiver = Primitive.unwrap(extensionReceiver);
+            localNameSpace.importObject(rawReceiver);
+            try {
+                localNameSpace.setLocalVariable(""+BSHEXTENSIONMETHODRECEIVER, extensionReceiver, false/*strict*/);
+            } catch (UtilEvalError e) { }
+        }
+
         localNameSpace.setNode( callerInfo );
 
         /*
@@ -598,6 +622,14 @@ private Object invokeImpl(
         return ret;
     }
 
+    private Object invokeImpl(
+        Object[] argValues, Interpreter interpreter, CallStack callstack,
+            Node callerInfo, boolean overrideNameSpace )
+        throws EvalError
+    {
+        return invokeImpl(argValues, interpreter,callstack, callerInfo, overrideNameSpace, null );
+    }
+
     public boolean hasModifier( String name ) {
         if ( javaMethod != null )
             return Reflect.hasModifier(name, javaMethod.getModifiers());
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Name.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Name.java
index 61e599d..2aa76d1 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Name.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Name.java
@@ -25,6 +25,8 @@
  *****************************************************************************/
 package bsh;
 
+import static bsh.This.Keys.BSHEXTENSIONMETHODRECEIVER;
+
 import java.lang.reflect.Array;
 import java.lang.reflect.InvocationTargetException;
 import java.util.Arrays;
@@ -474,6 +476,16 @@ Object resolveThisFieldReference(
     {
         if ( varName.equals("this") )
         {
+            NameSpace ns = thisNameSpace;
+            while (ns != null) {
+                Object receiver = ns.getVariable(BSHEXTENSIONMETHODRECEIVER.toString(), false);
+                if ( receiver != Primitive.VOID && receiver != Primitive.NULL )
+                    return receiver;
+                if ( ns.isClass )
+                    break;
+                ns = ns.getParent();
+            }
+
             /*
                 Somewhat of a hack.  If the special fields are visible (we're
                 operating relative to a 'this' type already) dissallow further
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java
index 67ac3d8..7a9c038 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/NameSpace.java
@@ -813,6 +813,34 @@ public BshMethod getMethod(final String name, final Class<?>[] sig,
         return method;
     }
 
+    /** Get the extension method matching the specified receiver type and
+     * signature declared in this name space or a parent.
+     * @param receiverType the receiver type
+     * @param name the name
+     * @param sig the sig
+     * @return the BshMethod or null if not found */
+    public BshMethod getExtensionMethod(final Class<?> receiverType,
+            final String name, final Class<?>[] sig) {
+        List<BshMethod> matches = new ArrayList<>();
+
+        NameSpace currentNS = this;
+        while (currentNS != null) {
+            List<BshMethod> methods = currentNS.methods.get(name);
+            if (methods != null) {
+                for (BshMethod method : methods) {
+                    if (!method.isExtension || method.receiverType == null) continue;
+                    if (!Types.isJavaBoxTypesAssignable(method.receiverType, receiverType)) continue;
+                    matches.add(method);
+                }
+            }
+            currentNS = currentNS.getParent();
+        }
+
+        if (!matches.isEmpty())
+            return Reflect.findMostSpecificBshMethod(sig, matches);
+        return null;
+    }
+
     /** Import a class name. Subsequent imports override earlier ones
      * @param name the name */
     public void importClass(final String name) {
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
index f299abc..3d73cf1 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Parser.java
@@ -693,8 +693,8 @@ final public void MethodDeclaration() throws ParseException {/*@bgen(jjtree) Met
       mods = Modifiers(Modifiers.METHOD, false);
 if (null != mods) jjtn000.modifiers = mods;
       if (jj_2_3(2147483647)) {
-        t = jj_consume_token(IDENTIFIER);
-jjtn000.name = t.image;
+        ReturnType();
+        ExtensionName();
       } else {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case BOOLEAN:
@@ -705,11 +705,8 @@ final public void MethodDeclaration() throws ParseException {/*@bgen(jjtree) Met
         case INT:
         case LONG:
         case SHORT:
-        case VOID:
         case IDENTIFIER:{
-          ReturnType();
-          t = jj_consume_token(IDENTIFIER);
-jjtn000.name = t.image;
+          ExtensionName();
           break;
           }
         default:
@@ -1466,17 +1463,113 @@ final public void AmbiguousName() throws ParseException {/*@bgen(jjtree) Ambiguo
     }
 }
 
+  final public void ExtensionName() throws ParseException {/*@bgen(jjtree) AmbiguousName */
+    BSHAmbiguousName jjtn000 = new BSHAmbiguousName(JJTAMBIGUOUSNAME);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);
+    jjtreeOpenNodeScope(jjtn000);Token t;
+    StringBuilder s;
+    try {
+      switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
+      case IDENTIFIER:{
+        t = jj_consume_token(IDENTIFIER);
+        break;
+        }
+      case BOOLEAN:{
+        t = jj_consume_token(BOOLEAN);
+        break;
+        }
+      case CHAR:{
+        t = jj_consume_token(CHAR);
+        break;
+        }
+      case BYTE:{
+        t = jj_consume_token(BYTE);
+        break;
+        }
+      case SHORT:{
+        t = jj_consume_token(SHORT);
+        break;
+        }
+      case INT:{
+        t = jj_consume_token(INT);
+        break;
+        }
+      case LONG:{
+        t = jj_consume_token(LONG);
+        break;
+        }
+      case FLOAT:{
+        t = jj_consume_token(FLOAT);
+        break;
+        }
+      case DOUBLE:{
+        t = jj_consume_token(DOUBLE);
+        break;
+        }
+      default:
+        jj_la1[33] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+s = new StringBuilder(t.image);
+      label_10:
+      while (true) {
+        if (jj_2_10(2)) {
+        } else {
+          break label_10;
+        }
+        jj_consume_token(LBRACKET);
+        jj_consume_token(RBRACKET);
+s.append("[]");
+      }
+      label_11:
+      while (true) {
+        if (jj_2_11(2)) {
+        } else {
+          break label_11;
+        }
+        jj_consume_token(DOT);
+        t = jj_consume_token(IDENTIFIER);
+s.append("."+t.image);
+        label_12:
+        while (true) {
+          if (jj_2_12(2)) {
+          } else {
+            break label_12;
+          }
+          jj_consume_token(LBRACKET);
+          jj_consume_token(RBRACKET);
+s.append("[]");
+        }
+      }
+jjtree.closeNodeScope(jjtn000, true);
+       jjtc000 = false;
+       if (jjtree.nodeCreated()) {
+        jjtreeCloseNodeScope(jjtn000);
+       }
+jjtn000.text = s.toString();
+    } finally {
+if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+      if (jjtree.nodeCreated()) {
+       jjtreeCloseNodeScope(jjtn000);
+      }
+    }
+    }
+}
+
   final public int NameList() throws ParseException {int count = 1;
     AmbiguousName();
-    label_10:
+    label_13:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case COMMA:{
         break;
         }
       default:
-        jj_la1[33] = jj_gen;
-        break label_10;
+        jj_la1[34] = jj_gen;
+        break label_13;
       }
       jj_consume_token(COMMA);
       AmbiguousName();
@@ -1527,7 +1620,7 @@ final public void Expression() throws ParseException {/*@bgen(jjtree) Assignment
         break;
         }
       default:
-        jj_la1[34] = jj_gen;
+        jj_la1[35] = jj_gen;
         ;
       }
     } catch (Throwable jjte000) {
@@ -1645,7 +1738,7 @@ final public void Expression() throws ParseException {/*@bgen(jjtree) Assignment
       break;
       }
     default:
-      jj_la1[35] = jj_gen;
+      jj_la1[36] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
@@ -1692,14 +1785,14 @@ final public void ConditionalExpression() throws ParseException {
       break;
       }
     default:
-      jj_la1[36] = jj_gen;
+      jj_la1[37] = jj_gen;
       ;
     }
 }
 
   final public void NullCoalesceElvisSpaceShipExpression() throws ParseException {Token t=null;
     ConditionalOrExpression();
-    label_11:
+    label_14:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case SPACESHIP:
@@ -1708,8 +1801,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[37] = jj_gen;
-        break label_11;
+        jj_la1[38] = jj_gen;
+        break label_14;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case NULLCOALESCE:{
@@ -1725,7 +1818,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[38] = jj_gen;
+        jj_la1[39] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -1754,7 +1847,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void ConditionalOrExpression() throws ParseException {Token t=null;
     ConditionalAndExpression();
-    label_12:
+    label_15:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BOOL_OR:
@@ -1762,8 +1855,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[39] = jj_gen;
-        break label_12;
+        jj_la1[40] = jj_gen;
+        break label_15;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BOOL_OR:{
@@ -1775,7 +1868,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[40] = jj_gen;
+        jj_la1[41] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -1804,7 +1897,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void ConditionalAndExpression() throws ParseException {Token t=null;
     InclusiveOrExpression();
-    label_13:
+    label_16:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BOOL_AND:
@@ -1812,8 +1905,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[41] = jj_gen;
-        break label_13;
+        jj_la1[42] = jj_gen;
+        break label_16;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BOOL_AND:{
@@ -1825,7 +1918,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[42] = jj_gen;
+        jj_la1[43] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -1854,7 +1947,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void InclusiveOrExpression() throws ParseException {Token t=null;
     ExclusiveOrExpression();
-    label_14:
+    label_17:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BIT_OR:
@@ -1862,8 +1955,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[43] = jj_gen;
-        break label_14;
+        jj_la1[44] = jj_gen;
+        break label_17;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BIT_OR:{
@@ -1875,7 +1968,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[44] = jj_gen;
+        jj_la1[45] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -1904,7 +1997,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void ExclusiveOrExpression() throws ParseException {Token t=null;
     AndExpression();
-    label_15:
+    label_18:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case XOR:
@@ -1912,8 +2005,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[45] = jj_gen;
-        break label_15;
+        jj_la1[46] = jj_gen;
+        break label_18;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case XOR:{
@@ -1925,7 +2018,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[46] = jj_gen;
+        jj_la1[47] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -1954,7 +2047,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void AndExpression() throws ParseException {Token t=null;
     EqualityExpression();
-    label_16:
+    label_19:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BIT_AND:
@@ -1962,8 +2055,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[47] = jj_gen;
-        break label_16;
+        jj_la1[48] = jj_gen;
+        break label_19;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case BIT_AND:{
@@ -1975,7 +2068,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[48] = jj_gen;
+        jj_la1[49] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2004,7 +2097,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void EqualityExpression() throws ParseException {Token t = null;
     InstanceOfExpression();
-    label_17:
+    label_20:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case EQ:
@@ -2012,8 +2105,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[49] = jj_gen;
-        break label_17;
+        jj_la1[50] = jj_gen;
+        break label_20;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case EQ:{
@@ -2025,7 +2118,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[50] = jj_gen;
+        jj_la1[51] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2080,14 +2173,14 @@ final public void ConditionalExpression() throws ParseException {
       break;
       }
     default:
-      jj_la1[51] = jj_gen;
+      jj_la1[52] = jj_gen;
       ;
     }
 }
 
   final public void RelationalExpression() throws ParseException {Token t = null;
     ShiftExpression();
-    label_18:
+    label_21:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case GT:
@@ -2101,8 +2194,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[52] = jj_gen;
-        break label_18;
+        jj_la1[53] = jj_gen;
+        break label_21;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case LT:{
@@ -2138,7 +2231,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[53] = jj_gen;
+        jj_la1[54] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2167,7 +2260,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void ShiftExpression() throws ParseException {Token t = null;
     AdditiveExpression();
-    label_19:
+    label_22:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case LSHIFT:
@@ -2179,8 +2272,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[54] = jj_gen;
-        break label_19;
+        jj_la1[55] = jj_gen;
+        break label_22;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case LSHIFT:{
@@ -2208,7 +2301,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[55] = jj_gen;
+        jj_la1[56] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2237,7 +2330,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void AdditiveExpression() throws ParseException {Token t = null;
     MultiplicativeExpression();
-    label_20:
+    label_23:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case PLUS:
@@ -2245,8 +2338,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[56] = jj_gen;
-        break label_20;
+        jj_la1[57] = jj_gen;
+        break label_23;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case PLUS:{
@@ -2258,7 +2351,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[57] = jj_gen;
+        jj_la1[58] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2287,7 +2380,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void MultiplicativeExpression() throws ParseException {Token t = null;
     PowerExpression();
-    label_21:
+    label_24:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case STAR:
@@ -2297,8 +2390,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[58] = jj_gen;
-        break label_21;
+        jj_la1[59] = jj_gen;
+        break label_24;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case STAR:{
@@ -2318,7 +2411,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[59] = jj_gen;
+        jj_la1[60] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2347,7 +2440,7 @@ final public void ConditionalExpression() throws ParseException {
 
   final public void PowerExpression() throws ParseException {Token t = null;
     UnaryExpression();
-    label_22:
+    label_25:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case POWER:
@@ -2355,8 +2448,8 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[60] = jj_gen;
-        break label_22;
+        jj_la1[61] = jj_gen;
+        break label_25;
       }
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case POWER:{
@@ -2368,7 +2461,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[61] = jj_gen;
+        jj_la1[62] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2419,7 +2512,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[62] = jj_gen;
+        jj_la1[63] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2457,7 +2550,7 @@ final public void ConditionalExpression() throws ParseException {
         break;
         }
       default:
-        jj_la1[63] = jj_gen;
+        jj_la1[64] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2484,10 +2577,10 @@ final public void ConditionalExpression() throws ParseException {
       break;
       }
     default:
-      jj_la1[66] = jj_gen;
-      if (jj_2_10(2147483647)) {
+      jj_la1[67] = jj_gen;
+      if (jj_2_13(2147483647)) {
         LambdaExpression();
-      } else if (jj_2_11(2147483647)) {
+      } else if (jj_2_14(2147483647)) {
         CastExpression();
       } else {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2528,7 +2621,7 @@ final public void ConditionalExpression() throws ParseException {
               break;
               }
             default:
-              jj_la1[64] = jj_gen;
+              jj_la1[65] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -2554,13 +2647,13 @@ final public void ConditionalExpression() throws ParseException {
             break;
             }
           default:
-            jj_la1[65] = jj_gen;
+            jj_la1[66] = jj_gen;
             ;
           }
           break;
           }
         default:
-          jj_la1[67] = jj_gen;
+          jj_la1[68] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2609,11 +2702,11 @@ final public void PrimaryExpression() throws ParseException {/*@bgen(jjtree) Pri
   jjtreeOpenNodeScope(jjtn000);
     try {
       PrimaryPrefix();
-      label_23:
+      label_26:
       while (true) {
-        if (jj_2_12(1)) {
+        if (jj_2_15(1)) {
         } else {
-          break label_23;
+          break label_26;
         }
         PrimarySuffix();
       }
@@ -2689,7 +2782,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[68] = jj_gen;
+        jj_la1[69] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2732,7 +2825,7 @@ final public void LambdaExpression() throws ParseException {/*@bgen(jjtree) Lamb
         break;
         }
       default:
-        jj_la1[69] = jj_gen;
+        jj_la1[70] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2777,7 +2870,7 @@ final public void WhenExpression() throws ParseException {/*@bgen(jjtree) WhenEx
       Expression();
       jj_consume_token(RPAREN);
       jj_consume_token(LBRACE);
-      label_24:
+      label_27:
       while (true) {
         WhenEntry();
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2814,8 +2907,8 @@ final public void WhenExpression() throws ParseException {/*@bgen(jjtree) WhenEx
           break;
           }
         default:
-          jj_la1[70] = jj_gen;
-          break label_24;
+          jj_la1[71] = jj_gen;
+          break label_27;
         }
       }
       jj_consume_token(RBRACE);
@@ -2888,15 +2981,15 @@ final public void WhenEntry() throws ParseException {/*@bgen(jjtree) WhenEntry *
       case MINUS:{
         Expression();
 count = 1;
-        label_25:
+        label_28:
         while (true) {
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
           case COMMA:{
             break;
             }
           default:
-            jj_la1[71] = jj_gen;
-            break label_25;
+            jj_la1[72] = jj_gen;
+            break label_28;
           }
           jj_consume_token(COMMA);
           Expression();
@@ -2913,7 +3006,7 @@ final public void WhenEntry() throws ParseException {/*@bgen(jjtree) WhenEntry *
         break;
         }
       default:
-        jj_la1[72] = jj_gen;
+        jj_la1[73] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -2972,10 +3065,10 @@ final public void PrimaryPrefix() throws ParseException {
       break;
       }
     default:
-      jj_la1[73] = jj_gen;
-      if (jj_2_13(2147483647)) {
+      jj_la1[74] = jj_gen;
+      if (jj_2_16(2147483647)) {
         MethodInvocation();
-      } else if (jj_2_14(2147483647)) {
+      } else if (jj_2_17(2147483647)) {
         Type();
       } else {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -2984,7 +3077,7 @@ final public void PrimaryPrefix() throws ParseException {
           break;
           }
         default:
-          jj_la1[74] = jj_gen;
+          jj_la1[75] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -2998,7 +3091,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
     jjtree.openNodeScope(jjtn000);
     jjtreeOpenNodeScope(jjtn000);Token t = null;
     try {
-      if (jj_2_15(2)) {
+      if (jj_2_18(2)) {
         jj_consume_token(DOT);
         jj_consume_token(CLASS);
 jjtree.closeNodeScope(jjtn000, true);
@@ -3046,7 +3139,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
             break;
             }
           default:
-            jj_la1[75] = jj_gen;
+            jj_la1[76] = jj_gen;
             ;
           }
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3089,7 +3182,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[76] = jj_gen;
+                jj_la1[77] = jj_gen;
                 ;
               }
 jjtn000.slice = true; jjtn000.step = true;
@@ -3133,7 +3226,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                 break;
                 }
               default:
-                jj_la1[77] = jj_gen;
+                jj_la1[78] = jj_gen;
                 ;
               }
               switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3174,26 +3267,26 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                   break;
                   }
                 default:
-                  jj_la1[78] = jj_gen;
+                  jj_la1[79] = jj_gen;
                   ;
                 }
                 break;
                 }
               default:
-                jj_la1[79] = jj_gen;
+                jj_la1[80] = jj_gen;
                 ;
               }
               break;
               }
             default:
-              jj_la1[80] = jj_gen;
+              jj_la1[81] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
             break;
             }
           default:
-            jj_la1[81] = jj_gen;
+            jj_la1[82] = jj_gen;
             ;
           }
           jj_consume_token(RBRACKET);
@@ -3206,7 +3299,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
           break;
           }
         default:
-          jj_la1[85] = jj_gen;
+          jj_la1[86] = jj_gen;
           if (getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET) {
             jj_consume_token(COLON_COLON);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3219,7 +3312,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[82] = jj_gen;
+              jj_la1[83] = jj_gen;
               jj_consume_token(-1);
               throw new ParseException();
             }
@@ -3230,7 +3323,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
                                     }
 jjtn000.operation = BSHPrimarySuffix.METHODREF;
     jjtn000.field = t.image;
-          } else if (jj_2_16(2)) {
+          } else if (jj_2_19(2)) {
             jj_consume_token(153);
             t = jj_consume_token(IDENTIFIER);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3239,7 +3332,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[83] = jj_gen;
+              jj_la1[84] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3250,7 +3343,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
 jjtn000.operation = BSHPrimarySuffix.NAME;
         jjtn000.field = t.image;
         jjtn000.safeNavigate = true;
-          } else if (jj_2_17(2)) {
+          } else if (jj_2_20(2)) {
             jj_consume_token(DOT);
             t = jj_consume_token(IDENTIFIER);
             switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3259,7 +3352,7 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[84] = jj_gen;
+              jj_la1[85] = jj_gen;
               ;
             }
 jjtree.closeNodeScope(jjtn000, true);
@@ -3284,8 +3377,8 @@ final public void PrimarySuffix() throws ParseException {/*@bgen(jjtree) Primary
               break;
               }
             default:
-              jj_la1[86] = jj_gen;
-              if (jj_2_18(2)) {
+              jj_la1[87] = jj_gen;
+              if (jj_2_21(2)) {
                 jj_consume_token(DOT);
                 AllocationExpression();
 jjtree.closeNodeScope(jjtn000, true);
@@ -3453,7 +3546,7 @@ final public void Literal() throws ParseException {/*@bgen(jjtree) Literal */
         break;
         }
       default:
-        jj_la1[87] = jj_gen;
+        jj_la1[88] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3494,7 +3587,7 @@ final public boolean BooleanLiteral() throws ParseException {
       break;
       }
     default:
-      jj_la1[88] = jj_gen;
+      jj_la1[89] = jj_gen;
       jj_consume_token(-1);
       throw new ParseException();
     }
@@ -3550,7 +3643,7 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
         break;
         }
       default:
-        jj_la1[89] = jj_gen;
+        jj_la1[90] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -3581,15 +3674,15 @@ final public void Arguments() throws ParseException {/*@bgen(jjtree) Arguments *
 // leave these on the stack for Arguments() to handle
   final public void ArgumentList() throws ParseException {
     Expression();
-    label_26:
+    label_29:
     while (true) {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
       case COMMA:{
         break;
         }
       default:
-        jj_la1[90] = jj_gen;
-        break label_26;
+        jj_la1[91] = jj_gen;
+        break label_29;
       }
       jj_consume_token(COMMA);
       Expression();
@@ -3628,7 +3721,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
             }
           case LPAREN:{
             Arguments();
-            if (jj_2_19(2)) {
+            if (jj_2_22(2)) {
               Block();
             } else {
               ;
@@ -3636,7 +3729,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[91] = jj_gen;
+            jj_la1[92] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3648,7 +3741,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[92] = jj_gen;
+          jj_la1[93] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3660,7 +3753,7 @@ final public void AllocationExpression() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[93] = jj_gen;
+        jj_la1[94] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -3694,23 +3787,23 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
   jjtree.openNodeScope(jjtn000);
   jjtreeOpenNodeScope(jjtn000);
     try {
-      if (jj_2_22(2)) {
-        label_27:
+      if (jj_2_25(2)) {
+        label_30:
         while (true) {
           jj_consume_token(LBRACKET);
           Expression();
           jj_consume_token(RBRACKET);
 jjtn000.addDefinedDimension();
-          if (jj_2_20(2)) {
+          if (jj_2_23(2)) {
           } else {
-            break label_27;
+            break label_30;
           }
         }
-        label_28:
+        label_31:
         while (true) {
-          if (jj_2_21(2)) {
+          if (jj_2_24(2)) {
           } else {
-            break label_28;
+            break label_31;
           }
           jj_consume_token(LBRACKET);
           jj_consume_token(RBRACKET);
@@ -3719,7 +3812,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
       } else {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case LBRACKET:{
-          label_29:
+          label_32:
           while (true) {
             jj_consume_token(LBRACKET);
             jj_consume_token(RBRACKET);
@@ -3729,8 +3822,8 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
               break;
               }
             default:
-              jj_la1[94] = jj_gen;
-              break label_29;
+              jj_la1[95] = jj_gen;
+              break label_32;
             }
           }
           ArrayInitializer();
@@ -3747,7 +3840,7 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
           break;
           }
         default:
-          jj_la1[95] = jj_gen;
+          jj_la1[96] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -3781,9 +3874,9 @@ final public void ArrayDimensions() throws ParseException {/*@bgen(jjtree) Array
  */
   final public 
 void Statement() throws ParseException {
-    if (jj_2_23(2)) {
+    if (jj_2_26(2)) {
       LabeledStatement();
-    } else if (jj_2_24(3)) {
+    } else if (jj_2_27(3)) {
       Block();
     } else {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -3841,7 +3934,7 @@ void Statement() throws ParseException {
         break;
         }
       default:
-        jj_la1[96] = jj_gen;
+        jj_la1[97] = jj_gen;
         if (isRegularForStatement()) {
           ForStatement();
         } else {
@@ -3875,7 +3968,7 @@ void Statement() throws ParseException {
             break;
             }
           default:
-            jj_la1[97] = jj_gen;
+            jj_la1[98] = jj_gen;
             jj_consume_token(-1);
             throw new ParseException();
           }
@@ -3935,15 +4028,15 @@ final public void Block() throws ParseException {/*@bgen(jjtree) Block */
         break;
         }
       default:
-        jj_la1[98] = jj_gen;
+        jj_la1[99] = jj_gen;
         ;
       }
       jj_consume_token(LBRACE);
-      label_30:
+      label_33:
       while (true) {
-        if (jj_2_25(1)) {
+        if (jj_2_28(1)) {
         } else {
-          break label_30;
+          break label_33;
         }
         BlockStatement();
       }
@@ -3979,16 +4072,16 @@ final public void Block() throws ParseException {/*@bgen(jjtree) Block */
 }
 
   final public void BlockStatement() throws ParseException {
-    if (jj_2_26(2147483647)) {
+    if (jj_2_29(2147483647)) {
       ClassDeclaration();
-    } else if (jj_2_27(2147483647)) {
+    } else if (jj_2_30(2147483647)) {
       MethodDeclaration();
-    } else if (jj_2_28(2147483647)) {
+    } else if (jj_2_31(2147483647)) {
       MethodDeclaration();
-    } else if (jj_2_29(2147483647)) {
+    } else if (jj_2_32(2147483647)) {
       TypedVariableDeclaration();
       StatementTerminator();
-    } else if (jj_2_30(1)) {
+    } else if (jj_2_33(1)) {
       Statement();
     } else {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -4001,7 +4094,7 @@ final public void BlockStatement() throws ParseException {
         break;
         }
       default:
-        jj_la1[99] = jj_gen;
+        jj_la1[100] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4019,7 +4112,7 @@ final public void MethodDeclTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[100] = jj_gen;
+      jj_la1[101] = jj_gen;
       if (isImplicitMethodTerminator()) {
 
       } else {
@@ -4036,7 +4129,7 @@ final public void StatementTerminator() throws ParseException {
       break;
       }
     default:
-      jj_la1[101] = jj_gen;
+      jj_la1[102] = jj_gen;
       ;
     }
 }
@@ -4056,7 +4149,7 @@ final public void SwitchStatement() throws ParseException {/*@bgen(jjtree) Switc
       Expression();
       jj_consume_token(RPAREN);
       jj_consume_token(LBRACE);
-      label_31:
+      label_34:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CASE:
@@ -4064,15 +4157,15 @@ final public void SwitchStatement() throws ParseException {/*@bgen(jjtree) Switc
           break;
           }
         default:
-          jj_la1[102] = jj_gen;
-          break label_31;
+          jj_la1[103] = jj_gen;
+          break label_34;
         }
         SwitchLabel();
-        label_32:
+        label_35:
         while (true) {
-          if (jj_2_31(1)) {
+          if (jj_2_34(1)) {
           } else {
-            break label_32;
+            break label_35;
           }
           BlockStatement();
         }
@@ -4126,7 +4219,7 @@ final public void SwitchLabel() throws ParseException {/*@bgen(jjtree) SwitchLab
         break;
         }
       default:
-        jj_la1[103] = jj_gen;
+        jj_la1[104] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4171,8 +4264,8 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[104] = jj_gen;
-        if (jj_2_32(1)) {
+        jj_la1[105] = jj_gen;
+        if (jj_2_35(1)) {
           Statement();
         } else {
           jj_consume_token(-1);
@@ -4186,7 +4279,7 @@ final public void IfStatement() throws ParseException {/*@bgen(jjtree) IfStateme
         break;
         }
       default:
-        jj_la1[105] = jj_gen;
+        jj_la1[106] = jj_gen;
         ;
       }
     } catch (Throwable jjte000) {
@@ -4350,7 +4443,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[106] = jj_gen;
+        jj_la1[107] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4389,7 +4482,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[107] = jj_gen;
+        jj_la1[108] = jj_gen;
         ;
       }
       jj_consume_token(SEMICOLON);
@@ -4428,7 +4521,7 @@ final public void ForStatement() throws ParseException {/*@bgen(jjtree) ForState
         break;
         }
       default:
-        jj_la1[108] = jj_gen;
+        jj_la1[109] = jj_gen;
         ;
       }
       jj_consume_token(RPAREN);
@@ -4466,7 +4559,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
   jjtree.openNodeScope(jjtn000);
   jjtreeOpenNodeScope(jjtn000);Token t = null;
     try {
-      if (jj_2_33(4)) {
+      if (jj_2_36(4)) {
         jj_consume_token(FOR);
         jj_consume_token(LPAREN);
         t = jj_consume_token(IDENTIFIER);
@@ -4492,7 +4585,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
             break;
             }
           default:
-            jj_la1[109] = jj_gen;
+            jj_la1[110] = jj_gen;
             ;
           }
           Type();
@@ -4510,7 +4603,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
           break;
           }
         default:
-          jj_la1[110] = jj_gen;
+          jj_la1[111] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -4540,7 +4633,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
 }
 
   final public void ForInit() throws ParseException {Token t = null;
-    if (jj_2_34(2147483647)) {
+    if (jj_2_37(2147483647)) {
       TypedVariableDeclaration();
     } else {
       switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
@@ -4577,7 +4670,7 @@ final public void EnhancedForStatement() throws ParseException {/*@bgen(jjtree)
         break;
         }
       default:
-        jj_la1[111] = jj_gen;
+        jj_la1[112] = jj_gen;
         jj_consume_token(-1);
         throw new ParseException();
       }
@@ -4599,15 +4692,15 @@ final public void TypedVariableDeclaration() throws ParseException {/*@bgen(jjtr
       mods = Modifiers(Modifiers.FIELD, false);
       Type();
       VariableDeclarator();
-      label_33:
+      label_36:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case COMMA:{
           break;
           }
         default:
-          jj_la1[112] = jj_gen;
-          break label_33;
+          jj_la1[113] = jj_gen;
+          break label_36;
         }
         jj_consume_token(COMMA);
         VariableDeclarator();
@@ -4649,15 +4742,15 @@ final public void StatementExpressionList() throws ParseException {/*@bgen(jjtre
   jjtreeOpenNodeScope(jjtn000);
     try {
       StatementExpression();
-      label_34:
+      label_37:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case COMMA:{
           break;
           }
         default:
-          jj_la1[113] = jj_gen;
-          break label_34;
+          jj_la1[114] = jj_gen;
+          break label_37;
         }
         jj_consume_token(COMMA);
         StatementExpression();
@@ -4697,7 +4790,7 @@ final public void BreakStatement() throws ParseException {/*@bgen(jjtree) Return
   jjtreeOpenNodeScope(jjtn000);Token t = null;
     try {
       jj_consume_token(BREAK);
-      if (jj_2_35(2)) {
+      if (jj_2_38(2)) {
         t = jj_consume_token(IDENTIFIER);
         jj_consume_token(SEMICOLON);
 jjtn000.label = t.image;
@@ -4741,7 +4834,7 @@ final public void ContinueStatement() throws ParseException {/*@bgen(jjtree) Ret
   jjtreeOpenNodeScope(jjtn000);Token t = null;
     try {
       jj_consume_token(CONTINUE);
-      if (jj_2_36(2)) {
+      if (jj_2_39(2)) {
         t = jj_consume_token(IDENTIFIER);
         jj_consume_token(SEMICOLON);
 jjtn000.label = t.image;
@@ -4908,19 +5001,19 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[114] = jj_gen;
+        jj_la1[115] = jj_gen;
         ;
       }
       Block();
-      label_35:
+      label_38:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case CATCH:{
           break;
           }
         default:
-          jj_la1[115] = jj_gen;
-          break label_35;
+          jj_la1[116] = jj_gen;
+          break label_38;
         }
         jj_consume_token(CATCH);
         jj_consume_token(LPAREN);
@@ -4937,7 +5030,7 @@ final public void TryStatement() throws ParseException {/*@bgen(jjtree) TryState
         break;
         }
       default:
-        jj_la1[116] = jj_gen;
+        jj_la1[117] = jj_gen;
         ;
       }
 jjtree.closeNodeScope(jjtn000, true);
@@ -4976,7 +5069,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
   jjtree.openNodeScope(jjtn000);
   jjtreeOpenNodeScope(jjtn000);Token t;
     try {
-      if (jj_2_37(2)) {
+      if (jj_2_40(2)) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case FINAL:{
           jj_consume_token(FINAL);
@@ -4984,19 +5077,19 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[117] = jj_gen;
+          jj_la1[118] = jj_gen;
           ;
         }
         Type();
-        label_36:
+        label_39:
         while (true) {
           switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
           case BIT_OR:{
             break;
             }
           default:
-            jj_la1[118] = jj_gen;
-            break label_36;
+            jj_la1[119] = jj_gen;
+            break label_39;
           }
           jj_consume_token(BIT_OR);
           Type();
@@ -5021,7 +5114,7 @@ final public void MultiCatch() throws ParseException {/*@bgen(jjtree) MultiCatch
           break;
           }
         default:
-          jj_la1[119] = jj_gen;
+          jj_la1[120] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5058,15 +5151,15 @@ final public void TryWithResources() throws ParseException {/*@bgen(jjtree) TryW
     try {
       jj_consume_token(LPAREN);
       AutoCloseable();
-      label_37:
+      label_40:
       while (true) {
         switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
         case SEMICOLON:{
           break;
           }
         default:
-          jj_la1[120] = jj_gen;
-          break label_37;
+          jj_la1[121] = jj_gen;
+          break label_40;
         }
         jj_consume_token(SEMICOLON);
         AutoCloseable();
@@ -5102,7 +5195,7 @@ final public void AutoCloseable() throws ParseException {/*@bgen(jjtree) AutoClo
   jjtree.openNodeScope(jjtn000);
   jjtreeOpenNodeScope(jjtn000);
     try {
-      if (jj_2_38(2)) {
+      if (jj_2_41(2)) {
         Type();
         VariableDeclarator();
       } else {
@@ -5112,7 +5205,7 @@ final public void AutoCloseable() throws ParseException {/*@bgen(jjtree) AutoClo
           break;
           }
         default:
-          jj_la1[121] = jj_gen;
+          jj_la1[122] = jj_gen;
           jj_consume_token(-1);
           throw new ParseException();
         }
@@ -5521,54 +5614,104 @@ private boolean jj_2_38(int xla)
     finally { jj_save(37, xla); }
   }
 
-  private boolean jj_3_33()
+  private boolean jj_2_39(int xla)
  {
-    if (jj_scan_token(FOR)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_59()) return true;
-    return false;
+    jj_la = xla;
+    jj_scanpos = token;
+    jj_lastpos = token;
+    try { return (!jj_3_39()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(38, xla); }
   }
 
-  private boolean jj_3R_115()
+  private boolean jj_2_40(int xla)
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_33()) {
-    jj_scanpos = xsp;
-    if (jj_3R_142()) return true;
-    }
-    return false;
+    jj_la = xla;
+    jj_scanpos = token;
+    jj_lastpos = token;
+    try { return (!jj_3_40()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(39, xla); }
   }
 
-  private boolean jj_3R_171()
+  private boolean jj_2_41(int xla)
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(104)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(105)) return true;
+    jj_la = xla;
+    jj_scanpos = token;
+    jj_lastpos = token;
+    try { return (!jj_3_41()); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(40, xla); }
+  }
+
+  private boolean jj_3R_168()
+ {
+    if (jj_3R_170()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_171()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_117()
+ {
+    if (jj_scan_token(DO)) return true;
+    if (jj_3R_63()) return true;
+    if (jj_scan_token(WHILE)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_48()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_171()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(88)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(89)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(86)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(87)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(93)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(94)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(95)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(96)) return true;
+    }
+    }
+    }
+    }
+    }
+    }
     }
     if (jj_3R_170()) return true;
     return false;
   }
 
-  private boolean jj_3R_142()
+  private boolean jj_3R_118()
  {
     if (jj_scan_token(FOR)) return true;
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_262()) jj_scanpos = xsp;
-    if (jj_3R_46()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(COLON)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_257()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_258()) jj_scanpos = xsp;
+    if (jj_scan_token(SEMICOLON)) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_259()) jj_scanpos = xsp;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_59()) return true;
+    if (jj_3R_63()) return true;
     return false;
   }
 
@@ -5584,6 +5727,127 @@ private boolean jj_3R_170()
   }
 
   private boolean jj_3R_173()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(118)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(119)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(120)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(121)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(122)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(123)) return true;
+    }
+    }
+    }
+    }
+    }
+    if (jj_3R_172()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_255()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_258()
+ {
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_259()
+ {
+    if (jj_3R_265()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_172()
+ {
+    if (jj_3R_174()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_175()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_257()
+ {
+    if (jj_3R_264()) return true;
+    return false;
+  }
+
+  private boolean jj_3_36()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_63()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_119()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_36()) {
+    jj_scanpos = xsp;
+    if (jj_3R_146()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_175()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(104)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(105)) return true;
+    }
+    if (jj_3R_174()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_146()
+ {
+    if (jj_scan_token(FOR)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_266()) jj_scanpos = xsp;
+    if (jj_3R_52()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_63()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_174()
+ {
+    if (jj_3R_176()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_177()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_177()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -5597,51 +5861,51 @@ private boolean jj_3R_173()
     }
     }
     }
-    if (jj_3R_172()) return true;
+    if (jj_3R_176()) return true;
     return false;
   }
 
-  private boolean jj_3R_260()
+  private boolean jj_3R_264()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_268()) {
+    if (jj_3R_272()) {
     jj_scanpos = xsp;
-    if (jj_3R_269()) return true;
+    if (jj_3R_273()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_268()
+  private boolean jj_3R_272()
  {
-    if (jj_3R_99()) return true;
+    if (jj_3R_103()) return true;
     return false;
   }
 
-  private boolean jj_3R_172()
+  private boolean jj_3R_176()
  {
-    if (jj_3R_174()) return true;
+    if (jj_3R_178()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_175()) { jj_scanpos = xsp; break; }
+      if (jj_3R_179()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_269()
+  private boolean jj_3R_273()
  {
-    if (jj_3R_270()) return true;
+    if (jj_3R_274()) return true;
     return false;
   }
 
-  private boolean jj_3R_262()
+  private boolean jj_3R_266()
  {
     if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_175()
+  private boolean jj_3R_179()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -5649,31 +5913,31 @@ private boolean jj_3R_175()
     jj_scanpos = xsp;
     if (jj_scan_token(117)) return true;
     }
-    if (jj_3R_174()) return true;
+    if (jj_3R_178()) return true;
     return false;
   }
 
-  private boolean jj_3_34()
+  private boolean jj_3_37()
  {
-    if (jj_3R_55()) return true;
-    if (jj_3R_46()) return true;
+    if (jj_3R_61()) return true;
+    if (jj_3R_52()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_174()
+  private boolean jj_3R_178()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_176()) {
+    if (jj_3R_180()) {
     jj_scanpos = xsp;
-    if (jj_3R_177()) {
+    if (jj_3R_181()) {
     jj_scanpos = xsp;
-    if (jj_3R_178()) {
+    if (jj_3R_182()) {
     jj_scanpos = xsp;
-    if (jj_3R_179()) {
+    if (jj_3R_183()) {
     jj_scanpos = xsp;
-    if (jj_3R_180()) return true;
+    if (jj_3R_184()) return true;
     }
     }
     }
@@ -5681,7 +5945,7 @@ private boolean jj_3R_174()
     return false;
   }
 
-  private boolean jj_3R_176()
+  private boolean jj_3R_180()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -5695,11 +5959,11 @@ private boolean jj_3R_176()
     }
     }
     }
-    if (jj_3R_174()) return true;
+    if (jj_3R_178()) return true;
     return false;
   }
 
-  private boolean jj_3R_177()
+  private boolean jj_3R_181()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -5707,66 +5971,66 @@ private boolean jj_3R_177()
     jj_scanpos = xsp;
     if (jj_scan_token(103)) return true;
     }
-    if (jj_3R_183()) return true;
+    if (jj_3R_187()) return true;
     return false;
   }
 
-  private boolean jj_3R_99()
+  private boolean jj_3R_103()
  {
-    if (jj_3R_55()) return true;
-    if (jj_3R_46()) return true;
-    if (jj_3R_62()) return true;
+    if (jj_3R_61()) return true;
+    if (jj_3R_52()) return true;
+    if (jj_3R_66()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_237()) { jj_scanpos = xsp; break; }
+      if (jj_3R_241()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_178()
+  private boolean jj_3R_182()
  {
-    if (jj_3R_181()) return true;
+    if (jj_3R_185()) return true;
     return false;
   }
 
-  private boolean jj_3R_179()
+  private boolean jj_3R_183()
  {
-    if (jj_3R_182()) return true;
+    if (jj_3R_186()) return true;
     return false;
   }
 
-  private boolean jj_3_32()
+  private boolean jj_3_35()
  {
-    if (jj_3R_59()) return true;
+    if (jj_3R_63()) return true;
     return false;
   }
 
-  private boolean jj_3R_270()
+  private boolean jj_3R_274()
  {
-    if (jj_3R_109()) return true;
+    if (jj_3R_113()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_274()) { jj_scanpos = xsp; break; }
+      if (jj_3R_278()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_180()
+  private boolean jj_3R_184()
  {
-    if (jj_3R_183()) return true;
+    if (jj_3R_187()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_184()) jj_scanpos = xsp;
+    if (jj_3R_188()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3_10()
+  private boolean jj_3_13()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_48()) {
+    if (jj_3R_54()) {
     jj_scanpos = xsp;
     if (jj_scan_token(73)) return true;
     }
@@ -5774,86 +6038,86 @@ private boolean jj_3_10()
     return false;
   }
 
-  private boolean jj_3R_48()
+  private boolean jj_3R_54()
  {
-    if (jj_3R_57()) return true;
+    if (jj_3R_44()) return true;
     return false;
   }
 
-  private boolean jj_3R_261()
+  private boolean jj_3R_265()
  {
-    if (jj_3R_270()) return true;
+    if (jj_3R_274()) return true;
     return false;
   }
 
-  private boolean jj_3R_182()
+  private boolean jj_3R_186()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_46()) return true;
+    if (jj_3R_52()) return true;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_174()) return true;
+    if (jj_3R_178()) return true;
     return false;
   }
 
-  private boolean jj_3_11()
+  private boolean jj_3_14()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_46()) return true;
+    if (jj_3R_52()) return true;
     if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_116()
+  private boolean jj_3R_120()
  {
     if (jj_scan_token(BREAK)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_35()) {
+    if (jj_3_38()) {
     jj_scanpos = xsp;
-    if (jj_3R_154()) return true;
+    if (jj_3R_158()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_183()
+  private boolean jj_3R_187()
  {
-    if (jj_3R_186()) return true;
+    if (jj_3R_190()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_12()) { jj_scanpos = xsp; break; }
+      if (jj_3_15()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_252()
+  private boolean jj_3R_256()
  {
     if (jj_scan_token(ELSE)) return true;
-    if (jj_3R_59()) return true;
+    if (jj_3R_63()) return true;
     return false;
   }
 
-  private boolean jj_3_35()
+  private boolean jj_3_38()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_154()
+  private boolean jj_3R_158()
  {
-    if (jj_3R_42()) return true;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3R_198()
+  private boolean jj_3R_202()
  {
-    if (jj_3R_40()) return true;
-    if (jj_3R_208()) return true;
+    if (jj_3R_46()) return true;
+    if (jj_3R_212()) return true;
     return false;
   }
 
-  private boolean jj_3R_184()
+  private boolean jj_3R_188()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -5864,184 +6128,184 @@ private boolean jj_3R_184()
     return false;
   }
 
-  private boolean jj_3R_237()
+  private boolean jj_3R_241()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_62()) return true;
+    if (jj_3R_66()) return true;
     return false;
   }
 
-  private boolean jj_3R_117()
+  private boolean jj_3R_121()
  {
     if (jj_scan_token(CONTINUE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_36()) {
+    if (jj_3_39()) {
     jj_scanpos = xsp;
-    if (jj_3R_155()) return true;
+    if (jj_3R_159()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_181()
+  private boolean jj_3R_185()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_185()) {
+    if (jj_3R_189()) {
     jj_scanpos = xsp;
     if (jj_scan_token(73)) return true;
     }
     if (jj_scan_token(ARROW)) return true;
     xsp = jj_scanpos;
-    if (jj_3R_187()) {
+    if (jj_3R_191()) {
     jj_scanpos = xsp;
-    if (jj_3R_188()) return true;
+    if (jj_3R_192()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_274()
+  private boolean jj_3R_278()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_109()) return true;
+    if (jj_3R_113()) return true;
     return false;
   }
 
-  private boolean jj_3R_185()
+  private boolean jj_3R_189()
  {
-    if (jj_3R_57()) return true;
+    if (jj_3R_44()) return true;
     return false;
   }
 
-  private boolean jj_3_36()
+  private boolean jj_3_39()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_scan_token(SEMICOLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_187()
+  private boolean jj_3R_191()
  {
-    if (jj_3R_52()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_155()
+  private boolean jj_3R_159()
  {
-    if (jj_3R_42()) return true;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3_12()
+  private boolean jj_3_15()
  {
-    if (jj_3R_49()) return true;
+    if (jj_3R_55()) return true;
     return false;
   }
 
-  private boolean jj_3R_197()
+  private boolean jj_3R_201()
  {
     if (jj_scan_token(WHEN)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(RPAREN)) return true;
     if (jj_scan_token(LBRACE)) return true;
     Token xsp;
-    if (jj_3R_207()) return true;
+    if (jj_3R_211()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_207()) { jj_scanpos = xsp; break; }
+      if (jj_3R_211()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_118()
+  private boolean jj_3R_122()
  {
     if (jj_scan_token(RETURN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_156()) jj_scanpos = xsp;
-    if (jj_3R_42()) return true;
+    if (jj_3R_160()) jj_scanpos = xsp;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3R_188()
+  private boolean jj_3R_192()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_207()
+  private boolean jj_3R_211()
  {
-    if (jj_3R_214()) return true;
+    if (jj_3R_218()) return true;
     return false;
   }
 
-  private boolean jj_3R_214()
+  private boolean jj_3R_218()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_223()) {
+    if (jj_3R_227()) {
     jj_scanpos = xsp;
-    if (jj_3R_224()) return true;
+    if (jj_3R_228()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_223()
+  private boolean jj_3R_227()
  {
     if (jj_scan_token(ELSE)) return true;
     if (jj_scan_token(ARROW)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_119()
+  private boolean jj_3R_123()
  {
     if (jj_scan_token(SYNCHRONIZED)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_52()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_224()
+  private boolean jj_3R_228()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_231()) { jj_scanpos = xsp; break; }
+      if (jj_3R_235()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(ARROW)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_156()
+  private boolean jj_3R_160()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_186()
+  private boolean jj_3R_190()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_189()) {
+    if (jj_3R_193()) {
     jj_scanpos = xsp;
-    if (jj_3R_190()) {
+    if (jj_3R_194()) {
     jj_scanpos = xsp;
-    if (jj_3R_191()) {
+    if (jj_3R_195()) {
     jj_scanpos = xsp;
-    if (jj_3R_192()) {
+    if (jj_3R_196()) {
     jj_scanpos = xsp;
-    if (jj_3R_193()) {
+    if (jj_3R_197()) {
     jj_scanpos = xsp;
-    if (jj_3R_194()) {
+    if (jj_3R_198()) {
     jj_scanpos = xsp;
-    if (jj_3R_195()) return true;
+    if (jj_3R_199()) return true;
     }
     }
     }
@@ -6051,177 +6315,177 @@ private boolean jj_3R_186()
     return false;
   }
 
-  private boolean jj_3R_189()
+  private boolean jj_3R_193()
  {
-    if (jj_3R_196()) return true;
+    if (jj_3R_200()) return true;
     return false;
   }
 
-  private boolean jj_3R_120()
+  private boolean jj_3R_124()
  {
     if (jj_scan_token(THROW)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_3R_42()) return true;
+    if (jj_3R_59()) return true;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3R_190()
+  private boolean jj_3R_194()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_191()
+  private boolean jj_3R_195()
  {
-    if (jj_3R_197()) return true;
+    if (jj_3R_201()) return true;
     return false;
   }
 
-  private boolean jj_3R_192()
+  private boolean jj_3R_196()
  {
-    if (jj_3R_51()) return true;
+    if (jj_3R_57()) return true;
     return false;
   }
 
-  private boolean jj_3R_193()
+  private boolean jj_3R_197()
  {
-    if (jj_3R_198()) return true;
+    if (jj_3R_202()) return true;
     return false;
   }
 
-  private boolean jj_3R_194()
+  private boolean jj_3R_198()
  {
-    if (jj_3R_46()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_121()
+  private boolean jj_3R_125()
  {
     if (jj_scan_token(TRY)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_157()) jj_scanpos = xsp;
-    if (jj_3R_52()) return true;
+    if (jj_3R_161()) jj_scanpos = xsp;
+    if (jj_3R_58()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_256()) { jj_scanpos = xsp; break; }
+      if (jj_3R_260()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_257()) jj_scanpos = xsp;
+    if (jj_3R_261()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_195()
+  private boolean jj_3R_199()
  {
-    if (jj_3R_40()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_256()
+  private boolean jj_3R_260()
  {
     if (jj_scan_token(CATCH)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_263()) return true;
+    if (jj_3R_267()) return true;
     if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_52()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_257()
+  private boolean jj_3R_261()
  {
     if (jj_scan_token(FINALLY)) return true;
-    if (jj_3R_52()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3_13()
+  private boolean jj_3_16()
  {
-    if (jj_3R_40()) return true;
+    if (jj_3R_46()) return true;
     if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_50()) {
+    if (jj_3R_56()) {
     jj_scanpos = xsp;
     if (jj_scan_token(77)) return true;
     }
     return false;
   }
 
-  private boolean jj_3_14()
+  private boolean jj_3_17()
  {
-    if (jj_3R_46()) return true;
+    if (jj_3R_52()) return true;
     if (jj_scan_token(DOT)) return true;
     if (jj_scan_token(CLASS)) return true;
     return false;
   }
 
-  private boolean jj_3R_157()
+  private boolean jj_3R_161()
  {
-    if (jj_3R_160()) return true;
+    if (jj_3R_164()) return true;
     return false;
   }
 
-  private boolean jj_3_37()
+  private boolean jj_3_40()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_60()) jj_scanpos = xsp;
-    if (jj_3R_46()) return true;
+    if (jj_3R_64()) jj_scanpos = xsp;
+    if (jj_3R_52()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_61()) { jj_scanpos = xsp; break; }
+      if (jj_3R_65()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_263()
+  private boolean jj_3R_267()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_37()) {
+    if (jj_3_40()) {
     jj_scanpos = xsp;
-    if (jj_3R_273()) return true;
+    if (jj_3R_277()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_231()
+  private boolean jj_3R_235()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3_15()
+  private boolean jj_3_18()
  {
     if (jj_scan_token(DOT)) return true;
     if (jj_scan_token(CLASS)) return true;
     return false;
   }
 
-  private boolean jj_3R_49()
+  private boolean jj_3R_55()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_15()) {
+    if (jj_3_18()) {
     jj_scanpos = xsp;
-    if (jj_3R_73()) {
+    if (jj_3R_80()) {
     jj_scanpos = xsp;
     jj_lookingAhead = true;
     jj_semLA = getToken(1).kind == COLON_COLON && (getToken(2).kind == IDENTIFIER || getToken(2).kind == NEW ) && getToken(3).kind != RBRACKET;
     jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_74()) {
+    if (!jj_semLA || jj_3R_81()) {
     jj_scanpos = xsp;
-    if (jj_3_16()) {
+    if (jj_3_19()) {
     jj_scanpos = xsp;
-    if (jj_3_17()) {
+    if (jj_3_20()) {
     jj_scanpos = xsp;
-    if (jj_3R_75()) {
+    if (jj_3R_82()) {
     jj_scanpos = xsp;
-    if (jj_3_18()) return true;
+    if (jj_3_21()) return true;
     }
     }
     }
@@ -6231,112 +6495,118 @@ private boolean jj_3R_49()
     return false;
   }
 
-  private boolean jj_3R_273()
+  private boolean jj_3R_277()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_73()
+  private boolean jj_3_1()
+ {
+    if (jj_3R_41()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_80()
  {
     if (jj_scan_token(LBRACKET)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_209()) jj_scanpos = xsp;
+    if (jj_3R_213()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_210()) jj_scanpos = xsp;
+    if (jj_3R_214()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_61()
+  private boolean jj_3R_65()
  {
     if (jj_scan_token(BIT_OR)) return true;
-    if (jj_3R_46()) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_160()
+  private boolean jj_3R_164()
  {
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_271()) return true;
+    if (jj_3R_275()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_272()) { jj_scanpos = xsp; break; }
+      if (jj_3R_276()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_209()
+  private boolean jj_3R_213()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_60()
+  private boolean jj_3R_64()
  {
     if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
-  private boolean jj_3_38()
+  private boolean jj_3_41()
  {
-    if (jj_3R_46()) return true;
-    if (jj_3R_62()) return true;
+    if (jj_3R_52()) return true;
+    if (jj_3R_66()) return true;
     return false;
   }
 
-  private boolean jj_3R_210()
+  private boolean jj_3R_214()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_219()) {
+    if (jj_3R_223()) {
     jj_scanpos = xsp;
-    if (jj_3R_220()) return true;
+    if (jj_3R_224()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_219()
+  private boolean jj_3R_223()
  {
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_228()) jj_scanpos = xsp;
+    if (jj_3R_232()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_271()
+  private boolean jj_3R_275()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_38()) {
+    if (jj_3_41()) {
     jj_scanpos = xsp;
-    if (jj_3R_275()) return true;
+    if (jj_3R_279()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_220()
+  private boolean jj_3R_224()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_229()) jj_scanpos = xsp;
+    if (jj_3R_233()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_230()) jj_scanpos = xsp;
+    if (jj_3R_234()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_50()
+  private boolean jj_3R_56()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_74()
+  private boolean jj_3R_81()
  {
     if (jj_scan_token(COLON_COLON)) return true;
     Token xsp;
@@ -6348,92 +6618,48 @@ private boolean jj_3R_74()
     return false;
   }
 
-  private boolean jj_3R_228()
+  private boolean jj_3R_232()
  {
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_230()
+  private boolean jj_3R_234()
  {
     if (jj_scan_token(COLON)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_233()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_275()
- {
-    if (jj_3R_62()) return true;
+    if (jj_3R_237()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3_16()
+  private boolean jj_3R_61()
  {
-    if (jj_scan_token(153)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_211()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3_1()
- {
-    if (jj_3R_38()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_86()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_272()
+  private boolean jj_3R_279()
  {
-    if (jj_scan_token(SEMICOLON)) return true;
-    if (jj_3R_271()) return true;
+    if (jj_3R_66()) return true;
     return false;
   }
 
-  private boolean jj_3_17()
+  private boolean jj_3_19()
  {
-    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(153)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_212()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_75()
- {
-    if (jj_scan_token(LBRACE)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RBRACE)) return true;
-    return false;
-  }
-
-  private boolean jj_3_18()
- {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_3R_51()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_55()
- {
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_79()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_229()
- {
-    if (jj_3R_53()) return true;
+    if (jj_3R_215()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_79()
+  private boolean jj_3R_86()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -6474,318 +6700,334 @@ private boolean jj_3R_79()
     return false;
   }
 
-  private boolean jj_3R_211()
+  private boolean jj_3R_276()
  {
-    if (jj_3R_208()) return true;
+    if (jj_scan_token(SEMICOLON)) return true;
+    if (jj_3R_275()) return true;
     return false;
   }
 
-  private boolean jj_3R_233()
+  private boolean jj_3_20()
  {
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_216()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_212()
+  private boolean jj_3R_82()
  {
-    if (jj_3R_208()) return true;
+    if (jj_scan_token(LBRACE)) return true;
+    if (jj_3R_59()) return true;
+    if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_196()
+  private boolean jj_3_21()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_199()) {
-    jj_scanpos = xsp;
-    if (jj_3R_200()) {
-    jj_scanpos = xsp;
-    if (jj_3R_201()) {
-    jj_scanpos = xsp;
-    if (jj_3R_202()) {
-    jj_scanpos = xsp;
-    if (jj_3R_203()) {
-    jj_scanpos = xsp;
-    if (jj_3R_204()) {
-    jj_scanpos = xsp;
-    if (jj_3R_205()) {
-    jj_scanpos = xsp;
-    if (jj_3R_206()) return true;
-    }
-    }
-    }
-    }
-    }
-    }
-    }
+    if (jj_scan_token(DOT)) return true;
+    if (jj_3R_57()) return true;
     return false;
   }
 
-  private boolean jj_3R_199()
+  private boolean jj_3R_233()
  {
-    if (jj_scan_token(INTEGER_LITERAL)) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3R_200()
+  private boolean jj_3R_215()
  {
-    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
+    if (jj_3R_212()) return true;
     return false;
   }
 
-  private boolean jj_3R_97()
+  private boolean jj_3R_237()
  {
-    if (jj_3R_55()) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_101()
+ {
+    if (jj_3R_61()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_122()) {
+    if (jj_3R_126()) {
     jj_scanpos = xsp;
-    if (jj_3R_123()) return true;
+    if (jj_3R_127()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_122()
+  private boolean jj_3R_126()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_143()) {
+    if (jj_3R_147()) {
     jj_scanpos = xsp;
-    if (jj_3R_144()) return true;
+    if (jj_3R_148()) return true;
     }
-    if (jj_3R_52()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_143()
+  private boolean jj_3R_216()
+ {
+    if (jj_3R_212()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_200()
+ {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_203()) {
+    jj_scanpos = xsp;
+    if (jj_3R_204()) {
+    jj_scanpos = xsp;
+    if (jj_3R_205()) {
+    jj_scanpos = xsp;
+    if (jj_3R_206()) {
+    jj_scanpos = xsp;
+    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_203()
+ {
+    if (jj_scan_token(INTEGER_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_147()
  {
     if (jj_scan_token(CLASS)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_243()) jj_scanpos = xsp;
+    if (jj_3R_247()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_244()) jj_scanpos = xsp;
+    if (jj_3R_248()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_243()
+  private boolean jj_3R_247()
  {
     if (jj_scan_token(EXTENDS)) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_244()
+  private boolean jj_3R_248()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
-    if (jj_3R_83()) return true;
+    if (jj_3R_87()) return true;
     return false;
   }
 
-  private boolean jj_3R_144()
+  private boolean jj_3R_148()
  {
     if (jj_scan_token(INTERFACE)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_245()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_201()
- {
-    if (jj_scan_token(CHARACTER_LITERAL)) return true;
+    if (jj_3R_249()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_123()
+  private boolean jj_3R_127()
  {
     if (jj_scan_token(ENUM)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_238()) jj_scanpos = xsp;
-    if (jj_3R_239()) return true;
+    if (jj_3R_242()) jj_scanpos = xsp;
+    if (jj_3R_243()) return true;
     return false;
   }
 
-  private boolean jj_3R_245()
+  private boolean jj_3R_249()
  {
     if (jj_scan_token(EXTENDS)) return true;
-    if (jj_3R_83()) return true;
+    if (jj_3R_87()) return true;
     return false;
   }
 
-  private boolean jj_3R_238()
+  private boolean jj_3R_242()
  {
     if (jj_scan_token(IMPLEMENTS)) return true;
-    if (jj_3R_83()) return true;
+    if (jj_3R_87()) return true;
     return false;
   }
 
-  private boolean jj_3R_202()
+  private boolean jj_3R_204()
  {
-    if (jj_scan_token(STRING_LITERAL)) return true;
+    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_258()
+  private boolean jj_3R_262()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_264()) jj_scanpos = xsp;
+    if (jj_3R_268()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_265()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_203()
- {
-    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_204()
- {
-    if (jj_3R_213()) return true;
+    if (jj_3R_269()) jj_scanpos = xsp;
     return false;
   }
 
   private boolean jj_3R_205()
  {
-    if (jj_scan_token(42)) return true;
+    if (jj_scan_token(CHARACTER_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_239()
+  private boolean jj_3R_243()
  {
     if (jj_scan_token(LBRACE)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_246()) jj_scanpos = xsp;
+    if (jj_3R_250()) jj_scanpos = xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_247()) { jj_scanpos = xsp; break; }
+      if (jj_3R_251()) { jj_scanpos = xsp; break; }
     }
     xsp = jj_scanpos;
-    if (jj_3R_248()) jj_scanpos = xsp;
+    if (jj_3R_252()) jj_scanpos = xsp;
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_206()
+  private boolean jj_3R_268()
  {
-    if (jj_scan_token(58)) return true;
+    if (jj_3R_212()) return true;
     return false;
   }
 
-  private boolean jj_3R_264()
+  private boolean jj_3R_206()
  {
-    if (jj_3R_208()) return true;
+    if (jj_scan_token(STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_246()
+  private boolean jj_3R_250()
  {
-    if (jj_3R_258()) return true;
+    if (jj_3R_262()) return true;
     return false;
   }
 
-  private boolean jj_3R_98()
+  private boolean jj_3R_102()
  {
-    if (jj_3R_55()) return true;
+    if (jj_3R_61()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_124()) {
+    if (jj_3R_128()) {
     jj_scanpos = xsp;
-    if (jj_3R_125()) return true;
+    if (jj_3R_129()) return true;
     }
-    if (jj_3R_57()) return true;
+    if (jj_3R_44()) return true;
     xsp = jj_scanpos;
-    if (jj_3R_234()) jj_scanpos = xsp;
+    if (jj_3R_238()) jj_scanpos = xsp;
     xsp = jj_scanpos;
-    if (jj_3R_235()) {
+    if (jj_3R_239()) {
     jj_scanpos = xsp;
-    if (jj_3R_236()) return true;
+    if (jj_3R_240()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_213()
+  private boolean jj_3R_128()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_221()) {
-    jj_scanpos = xsp;
-    if (jj_3R_222()) return true;
-    }
+    if (jj_3R_42()) return true;
+    if (jj_3R_43()) return true;
     return false;
   }
 
-  private boolean jj_3R_221()
+  private boolean jj_3R_207()
  {
-    if (jj_scan_token(TRUE)) return true;
+    if (jj_scan_token(LONG_STRING_LITERAL)) return true;
     return false;
   }
 
-  private boolean jj_3R_124()
+  private boolean jj_3R_129()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_43()) return true;
     return false;
   }
 
-  private boolean jj_3R_222()
+  private boolean jj_3R_238()
  {
-    if (jj_scan_token(FALSE)) return true;
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_87()) return true;
     return false;
   }
 
-  private boolean jj_3R_125()
+  private boolean jj_3R_269()
  {
-    if (jj_3R_56()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_265()
+  private boolean jj_3R_208()
  {
-    if (jj_3R_52()) return true;
+    if (jj_3R_217()) return true;
     return false;
   }
 
-  private boolean jj_3R_234()
+  private boolean jj_3R_239()
  {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_83()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_235()
+  private boolean jj_3_3()
  {
-    if (jj_3R_52()) return true;
+    if (jj_3R_42()) return true;
+    if (jj_3R_43()) return true;
+    if (jj_3R_44()) return true;
     return false;
   }
 
-  private boolean jj_3_3()
+  private boolean jj_3R_209()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_scan_token(LPAREN)) return true;
+    if (jj_scan_token(42)) return true;
     return false;
   }
 
-  private boolean jj_3R_101()
+  private boolean jj_3R_105()
  {
     if (jj_scan_token(PACKAGE)) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_247()
+  private boolean jj_3R_251()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_258()) return true;
+    if (jj_3R_262()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_210()
+ {
+    if (jj_scan_token(58)) return true;
     return false;
   }
 
@@ -6794,439 +7036,527 @@ private boolean jj_3_4()
     if (jj_scan_token(IMPORT)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_39()) jj_scanpos = xsp;
-    if (jj_3R_40()) return true;
+    if (jj_3R_45()) jj_scanpos = xsp;
+    if (jj_3R_46()) return true;
     xsp = jj_scanpos;
-    if (jj_3R_41()) jj_scanpos = xsp;
-    if (jj_3R_42()) return true;
+    if (jj_3R_47()) jj_scanpos = xsp;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3R_100()
+  private boolean jj_3R_104()
  {
     Token xsp;
     xsp = jj_scanpos;
     if (jj_3_4()) {
     jj_scanpos = xsp;
-    if (jj_3R_126()) return true;
+    if (jj_3R_130()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_208()
+  private boolean jj_3R_240()
+ {
+    if (jj_3R_244()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_130()
+ {
+    if (jj_scan_token(IMPORT)) return true;
+    if (jj_scan_token(STAR)) return true;
+    if (jj_3R_48()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_217()
  {
-    if (jj_scan_token(LPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_218()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_225()) {
+    jj_scanpos = xsp;
+    if (jj_3R_226()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_236()
+  private boolean jj_3R_225()
  {
-    if (jj_3R_240()) return true;
+    if (jj_scan_token(TRUE)) return true;
     return false;
   }
 
-  private boolean jj_3R_126()
+  private boolean jj_3R_226()
  {
-    if (jj_scan_token(IMPORT)) return true;
-    if (jj_scan_token(STAR)) return true;
-    if (jj_3R_42()) return true;
+    if (jj_scan_token(FALSE)) return true;
     return false;
   }
 
-  private boolean jj_3R_218()
+  private boolean jj_3R_45()
  {
-    if (jj_3R_227()) return true;
+    if (jj_scan_token(STATIC)) return true;
     return false;
   }
 
-  private boolean jj_3R_227()
+  private boolean jj_3R_66()
  {
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_232()) { jj_scanpos = xsp; break; }
+      if (jj_3R_245()) { jj_scanpos = xsp; break; }
     }
+    xsp = jj_scanpos;
+    if (jj_3R_246()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_232()
+  private boolean jj_3R_245()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_39()
+  private boolean jj_3R_246()
  {
-    if (jj_scan_token(STATIC)) return true;
+    if (jj_scan_token(ASSIGN)) return true;
+    if (jj_3R_50()) return true;
     return false;
   }
 
-  private boolean jj_3R_51()
+  private boolean jj_3R_47()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_76()) {
-    jj_scanpos = xsp;
-    if (jj_3R_77()) return true;
-    }
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(STAR)) return true;
     return false;
   }
 
-  private boolean jj_3R_76()
+  private boolean jj_3R_252()
+ {
+    if (jj_scan_token(SEMICOLON)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_2()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3_5()
+ {
+    if (jj_3R_49()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_50()
  {
-    if (jj_scan_token(NEW)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_215()) {
-    jj_scanpos = xsp;
-    if (jj_3R_216()) {
+    if (jj_3_5()) {
     jj_scanpos = xsp;
-    if (jj_3R_217()) return true;
+    if (jj_3R_77()) return true;
     }
+    return false;
+  }
+
+  private boolean jj_3R_77()
+ {
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_212()
+ {
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_222()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3_2()
+ {
+    if (jj_3R_41()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_49()
+ {
+    if (jj_scan_token(LBRACE)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_76()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(83)) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_222()
+ {
+    if (jj_3R_231()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_231()
+ {
+    if (jj_3R_59()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_236()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_62()
+  private boolean jj_3R_236()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_76()
+ {
+    if (jj_3R_50()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_241()) { jj_scanpos = xsp; break; }
+      if (jj_3_6()) { jj_scanpos = xsp; break; }
     }
-    xsp = jj_scanpos;
-    if (jj_3R_242()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_241()
+  private boolean jj_3R_44()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_75()) jj_scanpos = xsp;
+    if (jj_scan_token(RPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_215()
+  private boolean jj_3_6()
  {
-    if (jj_3R_102()) return true;
-    if (jj_3R_104()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_50()) return true;
     return false;
   }
 
-  private boolean jj_3R_242()
+  private boolean jj_3R_57()
  {
-    if (jj_scan_token(ASSIGN)) return true;
-    if (jj_3R_44()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_83()) {
+    jj_scanpos = xsp;
+    if (jj_3R_84()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_41()
+  private boolean jj_3R_83()
  {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_scan_token(STAR)) return true;
+    if (jj_scan_token(NEW)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    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_248()
+  private boolean jj_3R_75()
  {
-    if (jj_scan_token(SEMICOLON)) return true;
+    if (jj_3R_106()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_2()) { jj_scanpos = xsp; break; }
+      if (jj_3R_107()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_216()
+  private boolean jj_3R_106()
  {
-    if (jj_3R_40()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_225()) {
+    if (jj_3_7()) {
     jj_scanpos = xsp;
-    if (jj_3R_226()) return true;
+    if (jj_3R_131()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_132()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3_5()
+  private boolean jj_3R_219()
  {
-    if (jj_3R_43()) return true;
+    if (jj_3R_108()) return true;
+    if (jj_3R_110()) return true;
     return false;
   }
 
-  private boolean jj_3R_44()
+  private boolean jj_3_7()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_5()) {
-    jj_scanpos = xsp;
-    if (jj_3R_70()) return true;
-    }
+    if (jj_3R_51()) jj_scanpos = xsp;
+    if (jj_3R_52()) return true;
+    xsp = jj_scanpos;
+    if (jj_3R_53()) jj_scanpos = xsp;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_225()
+  private boolean jj_3R_220()
  {
-    if (jj_3R_104()) return true;
+    if (jj_3R_46()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_229()) {
+    jj_scanpos = xsp;
+    if (jj_3R_230()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_70()
+  private boolean jj_3R_131()
  {
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3_2()
+  private boolean jj_3R_229()
  {
-    if (jj_3R_38()) return true;
+    if (jj_3R_110()) return true;
     return false;
   }
 
-  private boolean jj_3R_226()
+  private boolean jj_3R_230()
  {
-    if (jj_3R_208()) return true;
+    if (jj_3R_212()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_19()) jj_scanpos = xsp;
+    if (jj_3_22()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_77()
+  private boolean jj_3R_84()
  {
-    if (jj_3R_104()) return true;
+    if (jj_3R_110()) return true;
     return false;
   }
 
-  private boolean jj_3R_217()
+  private boolean jj_3R_221()
  {
-    if (jj_3R_104()) return true;
+    if (jj_3R_110()) return true;
     return false;
   }
 
-  private boolean jj_3R_43()
+  private boolean jj_3R_132()
  {
-    if (jj_scan_token(LBRACE)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_69()) jj_scanpos = xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(83)) jj_scanpos = xsp;
-    if (jj_scan_token(RBRACE)) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_104()
+  private boolean jj_3R_53()
+ {
+    if (jj_scan_token(ELLIPSIS)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_110()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_22()) {
+    if (jj_3_25()) {
     jj_scanpos = xsp;
-    if (jj_3R_137()) {
+    if (jj_3R_143()) {
     jj_scanpos = xsp;
-    if (jj_3R_138()) return true;
+    if (jj_3R_144()) return true;
     }
     }
     return false;
   }
 
-  private boolean jj_3_22()
+  private boolean jj_3_25()
  {
     Token xsp;
-    if (jj_3_20()) return true;
+    if (jj_3_23()) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_20()) { jj_scanpos = xsp; break; }
+      if (jj_3_23()) { jj_scanpos = xsp; break; }
     }
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_21()) { jj_scanpos = xsp; break; }
+      if (jj_3_24()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3_20()
+  private boolean jj_3R_51()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(FINAL)) return true;
     return false;
   }
 
-  private boolean jj_3_21()
+  private boolean jj_3_23()
  {
     if (jj_scan_token(LBRACKET)) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_69()
+  private boolean jj_3R_52()
  {
-    if (jj_3R_44()) return true;
     Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_78()) {
+    jj_scanpos = xsp;
+    if (jj_3R_79()) return true;
+    }
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_6()) { jj_scanpos = xsp; break; }
+      if (jj_3_8()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_57()
+  private boolean jj_3_24()
  {
-    if (jj_scan_token(LPAREN)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_82()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_137()
+  private boolean jj_3R_107()
  {
-    Token xsp;
-    if (jj_3R_146()) return true;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_146()) { jj_scanpos = xsp; break; }
-    }
-    if (jj_3R_43()) return true;
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_106()) return true;
     return false;
   }
 
-  private boolean jj_3_6()
+  private boolean jj_3R_143()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_44()) return true;
+    Token xsp;
+    if (jj_3R_150()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_150()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_3R_49()) return true;
     return false;
   }
 
-  private boolean jj_3_19()
+  private boolean jj_3_22()
  {
-    if (jj_3R_52()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_146()
+  private boolean jj_3R_150()
  {
     if (jj_scan_token(LBRACKET)) return true;
     if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_138()
- {
-    if (jj_3R_43()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_82()
+  private boolean jj_3R_144()
  {
-    if (jj_3R_106()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_107()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_49()) return true;
     return false;
   }
 
-  private boolean jj_3R_106()
+  private boolean jj_3R_78()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3_7()) {
-    jj_scanpos = xsp;
-    if (jj_3R_140()) return true;
-    }
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_141()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_108()) return true;
     return false;
   }
 
-  private boolean jj_3_7()
+  private boolean jj_3_8()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_45()) jj_scanpos = xsp;
-    if (jj_3R_46()) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_47()) jj_scanpos = xsp;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_140()
+  private boolean jj_3_26()
  {
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_60()) return true;
     return false;
   }
 
-  private boolean jj_3_23()
+  private boolean jj_3R_42()
  {
-    if (jj_3R_54()) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_73()) {
+    jj_scanpos = xsp;
+    if (jj_3R_74()) return true;
+    }
     return false;
   }
 
-  private boolean jj_3R_59()
+  private boolean jj_3R_63()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3_23()) {
+    if (jj_3_26()) {
     jj_scanpos = xsp;
-    if (jj_3_24()) {
+    if (jj_3_27()) {
     jj_scanpos = xsp;
     if (jj_scan_token(82)) {
     jj_scanpos = xsp;
-    if (jj_3R_84()) {
+    if (jj_3R_88()) {
     jj_scanpos = xsp;
-    if (jj_3R_85()) {
+    if (jj_3R_89()) {
     jj_scanpos = xsp;
-    if (jj_3R_86()) {
+    if (jj_3R_90()) {
     jj_scanpos = xsp;
-    if (jj_3R_87()) {
+    if (jj_3R_91()) {
     jj_scanpos = xsp;
-    if (jj_3R_88()) {
+    if (jj_3R_92()) {
     jj_scanpos = xsp;
     jj_lookingAhead = true;
     jj_semLA = isRegularForStatement();
     jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_89()) {
+    if (!jj_semLA || jj_3R_93()) {
     jj_scanpos = xsp;
-    if (jj_3R_90()) {
+    if (jj_3R_94()) {
     jj_scanpos = xsp;
-    if (jj_3R_91()) {
+    if (jj_3R_95()) {
     jj_scanpos = xsp;
-    if (jj_3R_92()) {
+    if (jj_3R_96()) {
     jj_scanpos = xsp;
-    if (jj_3R_93()) {
+    if (jj_3R_97()) {
     jj_scanpos = xsp;
-    if (jj_3R_94()) {
+    if (jj_3R_98()) {
     jj_scanpos = xsp;
-    if (jj_3R_95()) {
+    if (jj_3R_99()) {
     jj_scanpos = xsp;
-    if (jj_3R_96()) return true;
-    }
-    }
-    }
-    }
-    }
-    }
-    }
-    }
-    }
-    }
-    }
+    if (jj_3R_100()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
     }
     }
     }
@@ -7234,87 +7564,81 @@ private boolean jj_3R_59()
     return false;
   }
 
-  private boolean jj_3_24()
- {
-    if (jj_3R_52()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_141()
- {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_47()
- {
-    if (jj_scan_token(ELLIPSIS)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_84()
+  private boolean jj_3R_73()
  {
-    if (jj_3R_109()) return true;
-    if (jj_3R_42()) return true;
+    if (jj_scan_token(VOID)) return true;
     return false;
   }
 
-  private boolean jj_3R_45()
+  private boolean jj_3R_74()
  {
-    if (jj_scan_token(FINAL)) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
-  private boolean jj_3R_85()
+  private boolean jj_3_27()
  {
-    if (jj_3R_110()) return true;
+    if (jj_3R_58()) return true;
     return false;
   }
 
-  private boolean jj_3R_46()
+  private boolean jj_3R_108()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_71()) {
+    if (jj_3R_133()) {
     jj_scanpos = xsp;
-    if (jj_3R_72()) return true;
+    if (jj_3R_134()) {
+    jj_scanpos = xsp;
+    if (jj_3R_135()) {
+    jj_scanpos = xsp;
+    if (jj_3R_136()) {
+    jj_scanpos = xsp;
+    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()) return true;
+    }
+    }
+    }
+    }
+    }
     }
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3_8()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_86()
+  private boolean jj_3R_133()
  {
-    if (jj_3R_111()) return true;
+    if (jj_scan_token(BOOLEAN)) return true;
     return false;
   }
 
-  private boolean jj_3R_107()
+  private boolean jj_3R_88()
  {
-    if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_106()) return true;
+    if (jj_3R_113()) return true;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3R_87()
+  private boolean jj_3R_134()
  {
-    if (jj_3R_112()) return true;
+    if (jj_scan_token(CHAR)) return true;
     return false;
   }
 
-  private boolean jj_3R_88()
+  private boolean jj_3R_135()
  {
-    if (jj_3R_113()) return true;
+    if (jj_scan_token(BYTE)) return true;
     return false;
   }
 
-  private boolean jj_3R_71()
+  private boolean jj_3R_79()
  {
-    if (jj_3R_102()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
@@ -7324,10 +7648,15 @@ private boolean jj_3R_89()
     return false;
   }
 
-  private boolean jj_3_8()
+  private boolean jj_3R_136()
  {
-    if (jj_scan_token(LBRACKET)) return true;
-    if (jj_scan_token(RBRACKET)) return true;
+    if (jj_scan_token(SHORT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_137()
+ {
+    if (jj_scan_token(INT)) return true;
     return false;
   }
 
@@ -7337,44 +7666,39 @@ private boolean jj_3R_90()
     return false;
   }
 
-  private boolean jj_3R_91()
+  private boolean jj_3R_138()
  {
-    if (jj_3R_116()) return true;
+    if (jj_scan_token(LONG)) return true;
     return false;
   }
 
-  private boolean jj_3R_92()
+  private boolean jj_3R_139()
  {
-    if (jj_3R_117()) return true;
+    if (jj_scan_token(FLOAT)) return true;
     return false;
   }
 
-  private boolean jj_3R_56()
+  private boolean jj_3R_91()
  {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_80()) {
-    jj_scanpos = xsp;
-    if (jj_3R_81()) return true;
-    }
+    if (jj_3R_116()) return true;
     return false;
   }
 
-  private boolean jj_3R_80()
+  private boolean jj_3R_140()
  {
-    if (jj_scan_token(VOID)) return true;
+    if (jj_scan_token(DOUBLE)) return true;
     return false;
   }
 
-  private boolean jj_3R_93()
+  private boolean jj_3R_92()
  {
-    if (jj_3R_118()) return true;
+    if (jj_3R_117()) return true;
     return false;
   }
 
-  private boolean jj_3R_81()
+  private boolean jj_3R_93()
  {
-    if (jj_3R_46()) return true;
+    if (jj_3R_118()) return true;
     return false;
   }
 
@@ -7396,98 +7720,97 @@ private boolean jj_3R_96()
     return false;
   }
 
-  private boolean jj_3R_102()
+  private boolean jj_3R_46()
  {
+    if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_127()) {
-    jj_scanpos = xsp;
-    if (jj_3R_128()) {
-    jj_scanpos = xsp;
-    if (jj_3R_129()) {
-    jj_scanpos = xsp;
-    if (jj_3R_130()) {
-    jj_scanpos = xsp;
-    if (jj_3R_131()) {
-    jj_scanpos = xsp;
-    if (jj_3R_132()) {
-    jj_scanpos = xsp;
-    if (jj_3R_133()) {
-    jj_scanpos = xsp;
-    if (jj_3R_134()) return true;
-    }
-    }
-    }
-    }
-    }
-    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_9()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_127()
- {
-    if (jj_scan_token(BOOLEAN)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_128()
- {
-    if (jj_scan_token(CHAR)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_129()
+  private boolean jj_3R_97()
  {
-    if (jj_scan_token(BYTE)) return true;
+    if (jj_3R_122()) return true;
     return false;
   }
 
-  private boolean jj_3R_72()
+  private boolean jj_3R_98()
  {
-    if (jj_3R_40()) return true;
+    if (jj_3R_123()) return true;
     return false;
   }
 
-  private boolean jj_3R_130()
+  private boolean jj_3R_99()
  {
-    if (jj_scan_token(SHORT)) return true;
+    if (jj_3R_124()) return true;
     return false;
   }
 
-  private boolean jj_3R_131()
+  private boolean jj_3_9()
  {
-    if (jj_scan_token(INT)) return true;
+    if (jj_scan_token(DOT)) return true;
+    if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_132()
+  private boolean jj_3R_100()
  {
-    if (jj_scan_token(LONG)) return true;
+    if (jj_3R_125()) return true;
     return false;
   }
 
-  private boolean jj_3R_54()
+  private boolean jj_3R_60()
  {
     if (jj_scan_token(IDENTIFIER)) return true;
     if (jj_scan_token(COLON)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_133()
- {
-    if (jj_scan_token(FLOAT)) return true;
+    if (jj_3R_63()) return true;
     return false;
   }
 
-  private boolean jj_3R_134()
+  private boolean jj_3R_43()
  {
-    if (jj_scan_token(DOUBLE)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(73)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(12)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(18)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(15)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(48)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(37)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(39)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(30)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(23)) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_10()) { jj_scanpos = xsp; break; }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_11()) { jj_scanpos = xsp; break; }
+    }
     return false;
   }
 
-  private boolean jj_3R_52()
+  private boolean jj_3R_58()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7495,47 +7818,55 @@ private boolean jj_3R_52()
     if (jj_scan_token(LBRACE)) return true;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_25()) { jj_scanpos = xsp; break; }
+      if (jj_3_28()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_40()
+  private boolean jj_3_10()
+ {
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3_11()
  {
+    if (jj_scan_token(DOT)) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_9()) { jj_scanpos = xsp; break; }
+      if (jj_3_12()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3_9()
+  private boolean jj_3_12()
  {
-    if (jj_scan_token(DOT)) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_scan_token(LBRACKET)) return true;
+    if (jj_scan_token(RBRACKET)) return true;
     return false;
   }
 
-  private boolean jj_3R_38()
+  private boolean jj_3R_41()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_63()) {
+    if (jj_3R_67()) {
     jj_scanpos = xsp;
-    if (jj_3R_64()) {
+    if (jj_3R_68()) {
     jj_scanpos = xsp;
-    if (jj_3R_65()) {
+    if (jj_3R_69()) {
     jj_scanpos = xsp;
-    if (jj_3R_66()) {
+    if (jj_3R_70()) {
     jj_scanpos = xsp;
-    if (jj_3_30()) {
+    if (jj_3_33()) {
     jj_scanpos = xsp;
-    if (jj_3R_67()) {
+    if (jj_3R_71()) {
     jj_scanpos = xsp;
-    if (jj_3R_68()) return true;
+    if (jj_3R_72()) return true;
     }
     }
     }
@@ -7545,38 +7876,38 @@ private boolean jj_3R_38()
     return false;
   }
 
-  private boolean jj_3R_63()
+  private boolean jj_3R_67()
  {
-    if (jj_3R_97()) return true;
+    if (jj_3R_101()) return true;
     return false;
   }
 
-  private boolean jj_3R_83()
+  private boolean jj_3R_87()
  {
-    if (jj_3R_40()) return true;
+    if (jj_3R_46()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_108()) { jj_scanpos = xsp; break; }
+      if (jj_3R_112()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_64()
+  private boolean jj_3R_68()
  {
-    if (jj_3R_98()) return true;
+    if (jj_3R_102()) return true;
     return false;
   }
 
-  private boolean jj_3R_65()
+  private boolean jj_3R_69()
  {
-    if (jj_3R_98()) return true;
+    if (jj_3R_102()) return true;
     return false;
   }
 
-  private boolean jj_3_26()
+  private boolean jj_3_29()
  {
-    if (jj_3R_55()) return true;
+    if (jj_3R_61()) return true;
     Token xsp;
     xsp = jj_scanpos;
     if (jj_scan_token(14)) {
@@ -7589,76 +7920,76 @@ private boolean jj_3_26()
     return false;
   }
 
-  private boolean jj_3R_53()
+  private boolean jj_3R_59()
  {
-    if (jj_3R_78()) return true;
+    if (jj_3R_85()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_103()) jj_scanpos = xsp;
+    if (jj_3R_109()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_66()
+  private boolean jj_3R_70()
  {
-    if (jj_3R_99()) return true;
-    if (jj_3R_42()) return true;
+    if (jj_3R_103()) return true;
+    if (jj_3R_48()) return true;
     return false;
   }
 
-  private boolean jj_3_25()
+  private boolean jj_3_28()
  {
-    if (jj_3R_38()) return true;
+    if (jj_3R_41()) return true;
     return false;
   }
 
-  private boolean jj_3_27()
+  private boolean jj_3_30()
  {
-    if (jj_3R_55()) return true;
-    if (jj_3R_56()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
+    if (jj_3R_61()) return true;
+    if (jj_3R_42()) return true;
+    if (jj_3R_43()) return true;
     if (jj_scan_token(LPAREN)) return true;
     return false;
   }
 
-  private boolean jj_3R_103()
+  private boolean jj_3R_109()
  {
-    if (jj_3R_136()) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_142()) return true;
+    if (jj_3R_59()) return true;
     return false;
   }
 
-  private boolean jj_3_30()
+  private boolean jj_3_33()
  {
-    if (jj_3R_59()) return true;
+    if (jj_3R_63()) return true;
     return false;
   }
 
-  private boolean jj_3R_108()
+  private boolean jj_3R_112()
  {
     if (jj_scan_token(COMMA)) return true;
-    if (jj_3R_40()) return true;
+    if (jj_3R_46()) return true;
     return false;
   }
 
-  private boolean jj_3R_67()
+  private boolean jj_3R_71()
  {
-    if (jj_3R_100()) return true;
+    if (jj_3R_104()) return true;
     return false;
   }
 
-  private boolean jj_3_28()
+  private boolean jj_3_31()
  {
-    if (jj_3R_55()) return true;
-    if (jj_scan_token(IDENTIFIER)) return true;
-    if (jj_3R_57()) return true;
+    if (jj_3R_61()) return true;
+    if (jj_3R_43()) return true;
+    if (jj_3R_44()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_58()) jj_scanpos = xsp;
+    if (jj_3R_62()) jj_scanpos = xsp;
     if (jj_scan_token(LBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_136()
+  private boolean jj_3R_142()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7729,30 +8060,30 @@ private boolean jj_3R_136()
     return false;
   }
 
-  private boolean jj_3R_68()
+  private boolean jj_3R_72()
  {
-    if (jj_3R_101()) return true;
+    if (jj_3R_105()) return true;
     return false;
   }
 
-  private boolean jj_3_29()
+  private boolean jj_3_32()
  {
-    if (jj_3R_55()) return true;
-    if (jj_3R_46()) return true;
+    if (jj_3R_61()) return true;
+    if (jj_3R_52()) return true;
     if (jj_scan_token(IDENTIFIER)) return true;
     return false;
   }
 
-  private boolean jj_3R_78()
+  private boolean jj_3R_85()
  {
-    if (jj_3R_105()) return true;
+    if (jj_3R_111()) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_135()) jj_scanpos = xsp;
+    if (jj_3R_141()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_240()
+  private boolean jj_3R_244()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7761,28 +8092,28 @@ private boolean jj_3R_240()
     jj_lookingAhead = true;
     jj_semLA = isImplicitMethodTerminator();
     jj_lookingAhead = false;
-    if (!jj_semLA || jj_3R_249()) return true;
+    if (!jj_semLA || jj_3R_253()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_249()
+  private boolean jj_3R_253()
  {
     return false;
   }
 
-  private boolean jj_3R_105()
+  private boolean jj_3R_111()
  {
-    if (jj_3R_139()) return true;
+    if (jj_3R_145()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_145()) { jj_scanpos = xsp; break; }
+      if (jj_3R_149()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_42()
+  private boolean jj_3R_48()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7790,7 +8121,7 @@ private boolean jj_3R_42()
     return false;
   }
 
-  private boolean jj_3R_145()
+  private boolean jj_3R_149()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7801,29 +8132,22 @@ private boolean jj_3R_145()
     if (jj_scan_token(145)) return true;
     }
     }
-    if (jj_3R_139()) return true;
+    if (jj_3R_145()) return true;
     return false;
   }
 
-  private boolean jj_3R_139()
+  private boolean jj_3R_145()
  {
-    if (jj_3R_147()) return true;
+    if (jj_3R_151()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_148()) { jj_scanpos = xsp; break; }
+      if (jj_3R_152()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_58()
- {
-    if (jj_scan_token(THROWS)) return true;
-    if (jj_3R_83()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_148()
+  private boolean jj_3R_152()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7831,28 +8155,35 @@ private boolean jj_3R_148()
     jj_scanpos = xsp;
     if (jj_scan_token(99)) return true;
     }
-    if (jj_3R_147()) return true;
+    if (jj_3R_151()) return true;
     return false;
   }
 
-  private boolean jj_3R_109()
+  private boolean jj_3R_62()
  {
-    if (jj_3R_53()) return true;
+    if (jj_scan_token(THROWS)) return true;
+    if (jj_3R_87()) return true;
     return false;
   }
 
-  private boolean jj_3R_147()
+  private boolean jj_3R_113()
+ {
+    if (jj_3R_59()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_151()
  {
-    if (jj_3R_149()) return true;
+    if (jj_3R_153()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_150()) { jj_scanpos = xsp; break; }
+      if (jj_3R_154()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_150()
+  private boolean jj_3R_154()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7860,22 +8191,22 @@ private boolean jj_3R_150()
     jj_scanpos = xsp;
     if (jj_scan_token(101)) return true;
     }
-    if (jj_3R_149()) return true;
+    if (jj_3R_153()) return true;
     return false;
   }
 
-  private boolean jj_3R_149()
+  private boolean jj_3R_153()
  {
-    if (jj_3R_151()) return true;
+    if (jj_3R_155()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_152()) { jj_scanpos = xsp; break; }
+      if (jj_3R_156()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_152()
+  private boolean jj_3R_156()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7883,58 +8214,58 @@ private boolean jj_3R_152()
     jj_scanpos = xsp;
     if (jj_scan_token(111)) return true;
     }
-    if (jj_3R_151()) return true;
+    if (jj_3R_155()) return true;
     return false;
   }
 
-  private boolean jj_3R_135()
+  private boolean jj_3R_141()
  {
     if (jj_scan_token(HOOK)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(COLON)) return true;
-    if (jj_3R_78()) return true;
+    if (jj_3R_85()) return true;
     return false;
   }
 
-  private boolean jj_3R_110()
+  private boolean jj_3R_114()
  {
     if (jj_scan_token(SWITCH)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) 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_250()) { jj_scanpos = xsp; break; }
+      if (jj_3R_254()) { jj_scanpos = xsp; break; }
     }
     if (jj_scan_token(RBRACE)) return true;
     return false;
   }
 
-  private boolean jj_3R_151()
+  private boolean jj_3R_155()
  {
-    if (jj_3R_153()) return true;
+    if (jj_3R_157()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_158()) { jj_scanpos = xsp; break; }
+      if (jj_3R_162()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_250()
+  private boolean jj_3R_254()
  {
-    if (jj_3R_259()) return true;
+    if (jj_3R_263()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3_31()) { jj_scanpos = xsp; break; }
+      if (jj_3_34()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_158()
+  private boolean jj_3R_162()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7942,47 +8273,47 @@ private boolean jj_3R_158()
     jj_scanpos = xsp;
     if (jj_scan_token(113)) return true;
     }
-    if (jj_3R_153()) return true;
+    if (jj_3R_157()) return true;
     return false;
   }
 
-  private boolean jj_3R_259()
+  private boolean jj_3R_263()
  {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_266()) {
+    if (jj_3R_270()) {
     jj_scanpos = xsp;
-    if (jj_3R_267()) return true;
+    if (jj_3R_271()) return true;
     }
     return false;
   }
 
-  private boolean jj_3R_266()
+  private boolean jj_3R_270()
  {
     if (jj_scan_token(CASE)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(COLON)) return true;
     return false;
   }
 
-  private boolean jj_3R_153()
+  private boolean jj_3R_157()
  {
-    if (jj_3R_159()) return true;
+    if (jj_3R_163()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_161()) { jj_scanpos = xsp; break; }
+      if (jj_3R_165()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3R_267()
+  private boolean jj_3R_271()
  {
     if (jj_scan_token(154)) return true;
     return false;
   }
 
-  private boolean jj_3R_161()
+  private boolean jj_3R_165()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -7990,45 +8321,45 @@ private boolean jj_3R_161()
     jj_scanpos = xsp;
     if (jj_scan_token(109)) return true;
     }
-    if (jj_3R_159()) return true;
+    if (jj_3R_163()) return true;
     return false;
   }
 
-  private boolean jj_3R_159()
+  private boolean jj_3R_163()
  {
-    if (jj_3R_162()) return true;
+    if (jj_3R_166()) return true;
     Token xsp;
     while (true) {
       xsp = jj_scanpos;
-      if (jj_3R_163()) { jj_scanpos = xsp; break; }
+      if (jj_3R_167()) { jj_scanpos = xsp; break; }
     }
     return false;
   }
 
-  private boolean jj_3_31()
+  private boolean jj_3_34()
  {
-    if (jj_3R_38()) return true;
+    if (jj_3R_41()) return true;
     return false;
   }
 
-  private boolean jj_3R_111()
+  private boolean jj_3R_115()
  {
     if (jj_scan_token(IF)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
+    if (jj_3R_59()) return true;
     if (jj_scan_token(RPAREN)) return true;
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_3R_251()) {
+    if (jj_3R_255()) {
     jj_scanpos = xsp;
-    if (jj_3_32()) return true;
+    if (jj_3_35()) return true;
     }
     xsp = jj_scanpos;
-    if (jj_3R_252()) jj_scanpos = xsp;
+    if (jj_3R_256()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_163()
+  private boolean jj_3R_167()
  {
     Token xsp;
     xsp = jj_scanpos;
@@ -8036,174 +8367,33 @@ private boolean jj_3R_163()
     jj_scanpos = xsp;
     if (jj_scan_token(97)) return true;
     }
-    if (jj_3R_162()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_112()
- {
-    if (jj_scan_token(WHILE)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_59()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_162()
- {
-    if (jj_3R_164()) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_165()) jj_scanpos = xsp;
-    return false;
-  }
-
-  private boolean jj_3R_165()
- {
-    if (jj_scan_token(INSTANCEOF)) return true;
-    if (jj_3R_46()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_164()
- {
     if (jj_3R_166()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_167()) { jj_scanpos = xsp; break; }
-    }
     return false;
   }
 
-  private boolean jj_3R_113()
+  private boolean jj_3R_116()
  {
-    if (jj_scan_token(DO)) return true;
-    if (jj_3R_59()) return true;
     if (jj_scan_token(WHILE)) return true;
     if (jj_scan_token(LPAREN)) return true;
-    if (jj_3R_53()) return true;
-    if (jj_scan_token(RPAREN)) return true;
-    if (jj_3R_42()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_167()
- {
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_scan_token(88)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(89)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(86)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(87)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(93)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(94)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(95)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(96)) return true;
-    }
-    }
-    }
-    }
-    }
-    }
-    }
-    if (jj_3R_166()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_114()
- {
-    if (jj_scan_token(FOR)) return true;
-    if (jj_scan_token(LPAREN)) return true;
-    Token xsp;
-    xsp = jj_scanpos;
-    if (jj_3R_253()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMICOLON)) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_254()) jj_scanpos = xsp;
-    if (jj_scan_token(SEMICOLON)) return true;
-    xsp = jj_scanpos;
-    if (jj_3R_255()) jj_scanpos = xsp;
-    if (jj_scan_token(RPAREN)) return true;
     if (jj_3R_59()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    if (jj_3R_63()) return true;
     return false;
   }
 
   private boolean jj_3R_166()
  {
     if (jj_3R_168()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_169()) { jj_scanpos = xsp; break; }
-    }
-    return false;
-  }
-
-  private boolean jj_3R_169()
- {
     Token xsp;
     xsp = jj_scanpos;
-    if (jj_scan_token(118)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(119)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(120)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(121)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(122)) {
-    jj_scanpos = xsp;
-    if (jj_scan_token(123)) return true;
-    }
-    }
-    }
-    }
-    }
-    if (jj_3R_168()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_251()
- {
-    if (jj_scan_token(SEMICOLON)) return true;
-    return false;
-  }
-
-  private boolean jj_3R_254()
- {
-    if (jj_3R_53()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_255()
- {
-    if (jj_3R_261()) return true;
-    return false;
-  }
-
-  private boolean jj_3R_168()
- {
-    if (jj_3R_170()) return true;
-    Token xsp;
-    while (true) {
-      xsp = jj_scanpos;
-      if (jj_3R_171()) { jj_scanpos = xsp; break; }
-    }
+    if (jj_3R_169()) jj_scanpos = xsp;
     return false;
   }
 
-  private boolean jj_3R_253()
+  private boolean jj_3R_169()
  {
-    if (jj_3R_260()) return true;
+    if (jj_scan_token(INSTANCEOF)) return true;
+    if (jj_3R_52()) return true;
     return false;
   }
 
@@ -8221,7 +8411,7 @@ private boolean jj_3R_253()
   private boolean jj_lookingAhead = false;
   private boolean jj_semLA;
   private int jj_gen;
-  final private int[] jj_la1 = new int[122];
+  final private int[] jj_la1 = new int[123];
   static private int[] jj_la1_0;
   static private int[] jj_la1_1;
   static private int[] jj_la1_2;
@@ -8235,21 +8425,21 @@ private boolean jj_3R_253()
 	   jj_la1_init_4();
 	}
 	private static void jj_la1_init_0() {
-	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x49849000,0x0,0x49849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
+	   jj_la1_0 = new int[] {0x1,0x10200800,0x10200800,0x4000000,0x0,0x4000000,0x4000,0x0,0x2004000,0x0,0x0,0x0,0x0,0x0,0x40849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48849000,0x48849000,0x0,0x0,0x50849000,0x10000000,0x0,0x0,0x40849000,0x40849000,0x40849000,0x40849000,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,0x48849000,0x0,0x48849000,0x49849000,0x0,0x49849000,0x8000000,0x0,0x48849000,0x48849000,0x48849000,0x48849000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x48849000,0x0,0x0,0x40849000,0x0,0x0,0x0,0x48c49000,0x80102000,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x1000000,0x58a49800,0x48849000,0x48849000,0x10000000,0x80000000,0x48849000,0x0,0x0,0x0,0x20000,0x20000000,0x10000000,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_1() {
-	   jj_la1_1 = new int[] {0x0,0x8367100,0x8367100,0x0,0x4,0x0,0x40,0x4,0x40,0x0,0x20000,0x0,0x0,0x0,0x40100a0,0x800000,0x20000,0x20000,0x0,0x8,0x0,0x0,0x550106a0,0x550106a0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x100a0,0x40100a0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x550106a0,0x0,0x550306a0,0x550106a0,0x0,0x550106a0,0x55000600,0x0,0x550106a0,0x550106a0,0x550106a0,0x550106a0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x45000400,0x1000000,0x550106a0,0x0,0x0,0x100a0,0x200,0x0,0x0,0x750906a2,0x2508000,0x20000,0x808,0x0,0x0,0x0,0x0,0x0,0x0,0x5d3777a0,0x550106a0,0x550106a0,0x0,0x0,0x550106a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_1 = new int[] {0x0,0x8367100,0x8367100,0x0,0x4,0x0,0x40,0x4,0x40,0x0,0x20000,0x0,0x0,0x0,0x100a0,0x800000,0x20000,0x20000,0x0,0x8,0x0,0x0,0x550106a0,0x550106a0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x100a0,0x40100a0,0x100a0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x550106a0,0x0,0x550306a0,0x550106a0,0x0,0x550106a0,0x55000600,0x0,0x550106a0,0x550106a0,0x550106a0,0x550106a0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x45000400,0x1000000,0x550106a0,0x0,0x0,0x100a0,0x200,0x0,0x0,0x750906a2,0x2508000,0x20000,0x808,0x0,0x0,0x0,0x0,0x0,0x0,0x5d3777a0,0x550106a0,0x550106a0,0x0,0x0,0x550106a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_2() {
-	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x4000,0x200,0x80000,0x40000,0x200,0x0,0x4000,0x0,0x100000,0x0,0x10000,0x200000,0xc0153c8,0xc0153c8,0x80000,0x80000,0x200,0x0,0x0,0x200,0x200,0x200,0x0,0x80000,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0xe3c00000,0xe3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0x0,0x0,0x0,0xc000000,0x153c8,0x1200,0xc0153c8,0xc0153c8,0x80000,0xc0153c8,0x151c8,0x200,0xc0153c8,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0x0,0x200,0x1000,0x1000,0x10000,0x4000,0x1c8,0x0,0xc0153c8,0x80000,0x15000,0x14200,0x14000,0x10000,0x14000,0xc0553c8,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x40000,0x0,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0xc0153c8,0x80000,0x80000,0x1000,0x0,0x0,0x0,0x0,0x200,0x40000,0x200,};
+	   jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x4000,0x200,0x80000,0x40000,0x200,0x0,0x4000,0x0,0x100000,0x0,0x10000,0x200000,0xc0153c8,0xc0153c8,0x80000,0x80000,0x200,0x0,0x0,0x200,0x200,0x200,0x0,0x200,0x80000,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0xe3c00000,0xe3c00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000000,0x0,0x0,0x0,0xc000000,0x153c8,0x1200,0xc0153c8,0xc0153c8,0x80000,0xc0153c8,0x151c8,0x200,0xc0153c8,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0x0,0x200,0x1000,0x1000,0x10000,0x4000,0x1c8,0x0,0xc0153c8,0x80000,0x15000,0x14200,0x14000,0x10000,0x14000,0xc0553c8,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x40000,0x0,0xc0153c8,0xc0153c8,0xc0153c8,0x0,0x0,0xc0153c8,0x80000,0x80000,0x1000,0x0,0x0,0x0,0x0,0x200,0x40000,0x200,};
 	}
 	private static void jj_la1_init_3() {
-	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0xf0000000,0x0,0x0,0x0,0xc,0xc,0x30,0x30,0xc000,0xc000,0x30000,0x30000,0x3000,0x3000,0x2,0x2,0x0,0x1,0x1,0xfc00000,0xfc00000,0x300,0x300,0xc0c00,0xc0c00,0x300000,0x300000,0x300,0xc0,0xc0,0xc0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,};
+	   jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf0000000,0xf0000000,0x0,0x0,0x0,0xc,0xc,0x30,0x30,0xc000,0xc000,0x30000,0x30000,0x3000,0x3000,0x2,0x2,0x0,0x1,0x1,0xfc00000,0xfc00000,0x300,0x300,0xc0c00,0xc0c00,0x300000,0x300000,0x300,0xc0,0xc0,0xc0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x0,0x3c0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x3c0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,};
 	}
 	private static void jj_la1_init_4() {
-	   jj_la1_4 = new int[] {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,0x1000000,0x0,0x0,0x0,0x0,0x0,0x4ffff,0x4ffff,0x200000,0x1a0000,0x1a0000,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,0x400000,0xc00000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
+	   jj_la1_4 = new int[] {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,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4ffff,0x4ffff,0x200000,0x1a0000,0x1a0000,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,0x400000,0xc00000,0xc00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
 	}
-  private final JJCalls[] jj_2_rtns = new JJCalls[38];
+  private final JJCalls[] jj_2_rtns = new JJCalls[41];
   private boolean jj_rescan = false;
   private int jj_gc = 0;
 
@@ -8264,7 +8454,7 @@ public Parser(final java.io.InputStream stream, final java.nio.charset.Charset e
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 123; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8279,7 +8469,7 @@ public void ReInit(final java.io.InputStream stream, final java.nio.charset.Char
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 123; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8293,7 +8483,7 @@ public Parser(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 122; i++)
+   for (int i = 0; i < 123; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8317,7 +8507,7 @@ public void ReInit(final java.io.Reader stream) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-   for (int i = 0; i < 122; i++)
+   for (int i = 0; i < 123; i++)
      jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++)
      jj_2_rtns[i] = new JJCalls();
@@ -8332,7 +8522,7 @@ public Parser(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 123; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8345,7 +8535,7 @@ public void ReInit(final ParserTokenManager tm) {
 	 token = new Token();
 	 jj_ntk = -1;
 	 jj_gen = 0;
-	 for (int i = 0; i < 122; i++) jj_la1[i] = -1;
+	 for (int i = 0; i < 123; i++) jj_la1[i] = -1;
 	 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
   }
 
@@ -8495,7 +8685,7 @@ public ParseException generateParseException() {
       la1tokens[jj_kind] = true;
       jj_kind = -1;
     }
-    for (int i = 0; i < 122; i++) {
+    for (int i = 0; i < 123; i++) {
       if (jj_la1[i] == jj_gen) {
         for (int j = 0; j < 32; j++) {
           if ((jj_la1_0[i] & (1<<j)) != 0) {
@@ -8548,7 +8738,7 @@ public final void disable_tracing() {}
 
   private void jj_rescan_token() {
     jj_rescan = true;
-    for (int i = 0; i < 38; i++) {
+    for (int i = 0; i < 41; i++) {
       try {
         JJCalls p = jj_2_rtns[i];
         do {
@@ -8595,6 +8785,9 @@ private void jj_rescan_token() {
               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;
             }
           }
           p = p.next;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
index 74ef619..88bdef8 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/ParserTokenManager.java
@@ -39,11 +39,11 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
    {
       case 0:
          if ((active1 & 0x40000021000000L) != 0x0L || (active2 & 0x20400L) != 0x0L)
-            return 75;
+            return 80;
          if ((active1 & 0x100000L) != 0x0L || (active2 & 0x1000000L) != 0x0L)
             return 18;
          if ((active1 & 0x8000080000000000L) != 0x0L)
-            return 64;
+            return 69;
          if ((active0 & 0x3ffffffffffff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
          {
             jjmatchedKind = 73;
@@ -54,7 +54,7 @@ private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1,
          return -1;
       case 1:
          if ((active1 & 0x40000000000000L) != 0x0L || (active2 & 0x400L) != 0x0L)
-            return 75;
+            return 80;
          if ((active0 & 0x200c00000L) != 0x0L)
             return 42;
          if ((active0 & 0x3ffffffdff3ff800L) != 0x0L || (active2 & 0x4000000L) != 0x0L)
@@ -1371,7 +1371,7 @@ private int jjStartNfaWithStates_0(int pos, int kind, int state)
 private int jjMoveNfa_0(int startState, int curPos)
 {
    int startsAt = 0;
-   jjnewStateCnt = 75;
+   jjnewStateCnt = 80;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
@@ -1386,7 +1386,7 @@ private int jjMoveNfa_0(int startState, int curPos)
          {
             switch(jjstateSet[--i])
             {
-               case 75:
+               case 80:
                   if ((0x97ffffbfffffdbffL & l) != 0x0L)
                      { jjCheckNAddStates(0, 3); }
                   else if (curChar == 62)
@@ -1400,16 +1400,6 @@ else if (curChar == 38)
                   if (curChar == 62)
                      jjstateSet[jjnewStateCnt++] = 5;
                   break;
-               case 64:
-                  if (curChar == 42)
-                     { jjCheckNAddTwoStates(70, 71); }
-                  else if (curChar == 47)
-                  {
-                     if (kind > 8)
-                        kind = 8;
-                     { jjCheckNAddStates(4, 6); }
-                  }
-                  break;
                case 1:
                   if ((0x1ffffffffL & l) != 0x0L)
                   {
@@ -1418,9 +1408,9 @@ else if (curChar == 47)
                      { jjCheckNAdd(0); }
                   }
                   else if ((0x3ff000000000000L & l) != 0x0L)
-                     { jjCheckNAddStates(7, 12); }
+                     { jjCheckNAddStates(4, 11); }
                   else if (curChar == 47)
-                     { jjAddStates(13, 14); }
+                     { jjAddStates(12, 13); }
                   else if (curChar == 36)
                   {
                      if (kind > 73)
@@ -1430,7 +1420,7 @@ else if (curChar == 36)
                   else if (curChar == 34)
                      jjstateSet[jjnewStateCnt++] = 39;
                   else if (curChar == 39)
-                     { jjCheckNAddStates(15, 17); }
+                     { jjCheckNAddStates(14, 16); }
                   else if (curChar == 46)
                      { jjCheckNAdd(18); }
                   else if (curChar == 35)
@@ -1447,10 +1437,20 @@ else if (curChar == 48)
                   {
                      if (kind > 62)
                         kind = 62;
-                     { jjCheckNAddStates(18, 21); }
+                     { jjCheckNAddStates(17, 20); }
                   }
                   else if (curChar == 34)
-                     { jjCheckNAddStates(22, 24); }
+                     { jjCheckNAddStates(21, 23); }
+                  break;
+               case 69:
+                  if (curChar == 42)
+                     { jjCheckNAddTwoStates(75, 76); }
+                  else if (curChar == 47)
+                  {
+                     if (kind > 8)
+                        kind = 8;
+                     { jjCheckNAddStates(24, 26); }
+                  }
                   break;
                case 0:
                   if ((0x1ffffffffL & l) == 0x0L)
@@ -1488,11 +1488,11 @@ else if (curChar == 34)
                   break;
                case 8:
                   if (curChar == 33)
-                     { jjCheckNAddStates(25, 27); }
+                     { jjCheckNAddStates(27, 29); }
                   break;
                case 9:
                   if ((0xffffffffffffdbffL & l) != 0x0L)
-                     { jjCheckNAddStates(25, 27); }
+                     { jjCheckNAddStates(27, 29); }
                   break;
                case 10:
                   if ((0x2400L & l) != 0x0L && kind > 9)
@@ -1533,7 +1533,7 @@ else if (curChar == 34)
                      break;
                   if (kind > 67)
                      kind = 67;
-                  { jjCheckNAddStates(28, 30); }
+                  { jjCheckNAddStates(30, 32); }
                   break;
                case 20:
                   if ((0x280000000000L & l) != 0x0L)
@@ -1548,14 +1548,14 @@ else if (curChar == 34)
                   break;
                case 23:
                   if (curChar == 39)
-                     { jjCheckNAddStates(15, 17); }
+                     { jjCheckNAddStates(14, 16); }
                   break;
                case 24:
                   if ((0xffffff7fffffdbffL & l) != 0x0L)
-                     { jjCheckNAddStates(15, 17); }
+                     { jjCheckNAddStates(14, 16); }
                   break;
                case 26:
-                  { jjCheckNAddStates(15, 17); }
+                  { jjCheckNAddStates(14, 16); }
                   break;
                case 27:
                   if (curChar == 39 && kind > 70)
@@ -1563,14 +1563,14 @@ else if (curChar == 34)
                   break;
                case 28:
                   if (curChar == 34)
-                     { jjCheckNAddStates(22, 24); }
+                     { jjCheckNAddStates(21, 23); }
                   break;
                case 29:
                   if ((0xfffffffbffffdbffL & l) != 0x0L)
-                     { jjCheckNAddStates(22, 24); }
+                     { jjCheckNAddStates(21, 23); }
                   break;
                case 31:
-                  { jjCheckNAddStates(22, 24); }
+                  { jjCheckNAddStates(21, 23); }
                   break;
                case 32:
                   if (curChar == 34 && kind > 71)
@@ -1583,7 +1583,7 @@ else if (curChar == 34)
                   break;
                case 34:
                   if ((0xfffffffbffffffffL & l) != 0x0L)
-                     { jjCheckNAddStates(31, 33); }
+                     { jjCheckNAddStates(33, 35); }
                   break;
                case 36:
                   if (curChar == 34 && kind > 72)
@@ -1621,25 +1621,22 @@ else if (curChar == 34)
                   break;
                case 43:
                   if ((0x3ff000000000000L & l) != 0x0L)
-                     { jjCheckNAddStates(7, 12); }
+                     { jjCheckNAddStates(4, 11); }
                   break;
                case 44:
                   if ((0x3ff000000000000L & l) != 0x0L)
                      { jjCheckNAddTwoStates(44, 45); }
                   break;
                case 45:
-                  if (curChar != 46)
-                     break;
-                  if (kind > 67)
-                     kind = 67;
-                  { jjCheckNAddStates(34, 36); }
+                  if (curChar == 46)
+                     { jjCheckNAdd(46); }
                   break;
                case 46:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
                   if (kind > 67)
                      kind = 67;
-                  { jjCheckNAddStates(34, 36); }
+                  { jjCheckNAddStates(36, 38); }
                   break;
                case 48:
                   if ((0x280000000000L & l) != 0x0L)
@@ -1656,100 +1653,119 @@ else if (curChar == 34)
                   if ((0x3ff000000000000L & l) != 0x0L)
                      { jjCheckNAddTwoStates(50, 51); }
                   break;
-               case 52:
-                  if ((0x280000000000L & l) != 0x0L)
-                     { jjCheckNAdd(53); }
+               case 51:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 52;
                   break;
                case 53:
+                  if ((0x280000000000L & l) != 0x0L)
+                     { jjCheckNAdd(54); }
+                  break;
+               case 54:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
                   if (kind > 67)
                      kind = 67;
-                  { jjCheckNAddTwoStates(53, 22); }
+                  { jjCheckNAddTwoStates(54, 22); }
                   break;
-               case 54:
+               case 55:
                   if ((0x3ff000000000000L & l) != 0x0L)
-                     { jjCheckNAddTwoStates(54, 55); }
+                     { jjCheckNAddTwoStates(55, 56); }
                   break;
-               case 56:
+               case 57:
+                  if ((0x280000000000L & l) != 0x0L)
+                     { jjCheckNAdd(58); }
+                  break;
+               case 58:
+                  if ((0x3ff000000000000L & l) == 0x0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  { jjCheckNAddTwoStates(58, 22); }
+                  break;
+               case 59:
+                  if ((0x3ff000000000000L & l) != 0x0L)
+                     { jjCheckNAddTwoStates(59, 60); }
+                  break;
+               case 61:
                   if (curChar != 48)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddStates(18, 21); }
+                  { jjCheckNAddStates(17, 20); }
                   break;
-               case 58:
+               case 63:
                   if ((0x3ff000000000000L & l) == 0x0L)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddTwoStates(58, 16); }
+                  { jjCheckNAddTwoStates(63, 16); }
                   break;
-               case 60:
+               case 65:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddStates(37, 39); }
+                  { jjCheckNAddStates(39, 41); }
                   break;
-               case 61:
+               case 66:
                   if ((0x3000000000000L & l) == 0x0L)
                      break;
                   if (kind > 62)
                      kind = 62;
                   { jjCheckNAdd(16); }
                   break;
-               case 62:
+               case 67:
                   if ((0xff000000000000L & l) == 0x0L)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddTwoStates(62, 16); }
+                  { jjCheckNAddTwoStates(67, 16); }
                   break;
-               case 63:
+               case 68:
                   if (curChar == 47)
-                     { jjAddStates(13, 14); }
+                     { jjAddStates(12, 13); }
                   break;
-               case 65:
+               case 70:
                   if ((0xffffffffffffdbffL & l) == 0x0L)
                      break;
                   if (kind > 8)
                      kind = 8;
-                  { jjCheckNAddStates(4, 6); }
+                  { jjCheckNAddStates(24, 26); }
                   break;
-               case 66:
+               case 71:
                   if ((0x2400L & l) != 0x0L && kind > 8)
                      kind = 8;
                   break;
-               case 67:
+               case 72:
                   if (curChar == 10 && kind > 8)
                      kind = 8;
                   break;
-               case 68:
+               case 73:
                   if (curChar == 13)
-                     jjstateSet[jjnewStateCnt++] = 67;
+                     jjstateSet[jjnewStateCnt++] = 72;
                   break;
-               case 69:
+               case 74:
                   if (curChar == 42)
-                     { jjCheckNAddTwoStates(70, 71); }
+                     { jjCheckNAddTwoStates(75, 76); }
                   break;
-               case 70:
+               case 75:
                   if ((0xfffffbffffffffffL & l) != 0x0L)
-                     { jjCheckNAddTwoStates(70, 71); }
+                     { jjCheckNAddTwoStates(75, 76); }
                   break;
-               case 71:
+               case 76:
                   if (curChar == 42)
-                     { jjCheckNAddStates(40, 42); }
+                     { jjCheckNAddStates(42, 44); }
                   break;
-               case 72:
+               case 77:
                   if ((0xffff7bffffffffffL & l) != 0x0L)
-                     { jjCheckNAddTwoStates(73, 71); }
+                     { jjCheckNAddTwoStates(78, 76); }
                   break;
-               case 73:
+               case 78:
                   if ((0xfffffbffffffffffL & l) != 0x0L)
-                     { jjCheckNAddTwoStates(73, 71); }
+                     { jjCheckNAddTwoStates(78, 76); }
                   break;
-               case 74:
+               case 79:
                   if (curChar == 47 && kind > 10)
                      kind = 10;
                   break;
@@ -1764,7 +1780,7 @@ else if (curChar < 128)
          {
             switch(jjstateSet[--i])
             {
-               case 75:
+               case 80:
                case 2:
                   if ((0xefffffffffffffffL & l) != 0x0L)
                      { jjCheckNAddStates(0, 3); }
@@ -1778,7 +1794,7 @@ else if (curChar < 128)
                   { jjCheckNAdd(42); }
                   break;
                case 9:
-                  { jjAddStates(25, 27); }
+                  { jjAddStates(27, 29); }
                   break;
                case 15:
                   if (curChar != 95)
@@ -1793,7 +1809,7 @@ else if (curChar < 128)
                   break;
                case 19:
                   if ((0x2000000020L & l) != 0x0L)
-                     { jjAddStates(43, 44); }
+                     { jjAddStates(45, 46); }
                   break;
                case 22:
                   if ((0x80005000800050L & l) != 0x0L && kind > 67)
@@ -1801,77 +1817,81 @@ else if (curChar < 128)
                   break;
                case 24:
                   if ((0xffffffffefffffffL & l) != 0x0L)
-                     { jjCheckNAddStates(15, 17); }
+                     { jjCheckNAddStates(14, 16); }
                   break;
                case 25:
                   if (curChar == 92)
                      jjstateSet[jjnewStateCnt++] = 26;
                   break;
                case 26:
-                  { jjCheckNAddStates(15, 17); }
+                  { jjCheckNAddStates(14, 16); }
                   break;
                case 29:
                   if ((0xffffffffefffffffL & l) != 0x0L)
-                     { jjCheckNAddStates(22, 24); }
+                     { jjCheckNAddStates(21, 23); }
                   break;
                case 30:
                   if (curChar == 92)
                      jjstateSet[jjnewStateCnt++] = 31;
                   break;
                case 31:
-                  { jjCheckNAddStates(22, 24); }
+                  { jjCheckNAddStates(21, 23); }
                   break;
                case 34:
-                  { jjAddStates(31, 33); }
+                  { jjAddStates(33, 35); }
                   break;
                case 47:
                   if ((0x2000000020L & l) != 0x0L)
-                     { jjAddStates(45, 46); }
+                     { jjAddStates(47, 48); }
                   break;
-               case 51:
+               case 52:
                   if ((0x2000000020L & l) != 0x0L)
-                     { jjAddStates(47, 48); }
+                     { jjAddStates(49, 50); }
                   break;
-               case 55:
+               case 56:
+                  if ((0x2000000020L & l) != 0x0L)
+                     { jjAddStates(51, 52); }
+                  break;
+               case 60:
                   if ((0x5000000050L & l) != 0x0L && kind > 67)
                      kind = 67;
                   break;
-               case 57:
+               case 62:
                   if ((0x100000001000000L & l) != 0x0L)
-                     { jjCheckNAdd(58); }
+                     { jjCheckNAdd(63); }
                   break;
-               case 58:
+               case 63:
                   if ((0x7e8000007eL & l) == 0x0L)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddTwoStates(58, 16); }
+                  { jjCheckNAddTwoStates(63, 16); }
                   break;
-               case 59:
+               case 64:
                   if ((0x400000004L & l) == 0x0L)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddStates(37, 39); }
+                  { jjCheckNAddStates(39, 41); }
                   break;
-               case 60:
+               case 65:
                   if (curChar != 95)
                      break;
                   if (kind > 62)
                      kind = 62;
-                  { jjCheckNAddStates(37, 39); }
+                  { jjCheckNAddStates(39, 41); }
                   break;
-               case 65:
+               case 70:
                   if (kind > 8)
                      kind = 8;
-                  { jjAddStates(4, 6); }
+                  { jjAddStates(24, 26); }
                   break;
-               case 70:
-                  { jjCheckNAddTwoStates(70, 71); }
+               case 75:
+                  { jjCheckNAddTwoStates(75, 76); }
                   break;
-               case 72:
-               case 73:
-                  { jjCheckNAddTwoStates(73, 71); }
+               case 77:
+               case 78:
+                  { jjCheckNAddTwoStates(78, 76); }
                   break;
                default : break;
             }
@@ -1888,7 +1908,7 @@ else if (curChar < 128)
          {
             switch(jjstateSet[--i])
             {
-               case 75:
+               case 80:
                case 2:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
                      { jjCheckNAddStates(0, 3); }
@@ -1916,21 +1936,21 @@ else if (curChar < 128)
                   break;
                case 9:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjAddStates(25, 27); }
+                     { jjAddStates(27, 29); }
                   break;
                case 24:
                case 26:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddStates(15, 17); }
+                     { jjCheckNAddStates(14, 16); }
                   break;
                case 29:
                case 31:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddStates(22, 24); }
+                     { jjCheckNAddStates(21, 23); }
                   break;
                case 34:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjAddStates(31, 33); }
+                     { jjAddStates(33, 35); }
                   break;
                case 41:
                case 42:
@@ -1940,21 +1960,21 @@ else if (curChar < 128)
                      kind = 73;
                   { jjCheckNAdd(42); }
                   break;
-               case 65:
+               case 70:
                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                      break;
                   if (kind > 8)
                      kind = 8;
-                  { jjAddStates(4, 6); }
+                  { jjAddStates(24, 26); }
                   break;
-               case 70:
+               case 75:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddTwoStates(70, 71); }
+                     { jjCheckNAddTwoStates(75, 76); }
                   break;
-               case 72:
-               case 73:
+               case 77:
+               case 78:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddTwoStates(73, 71); }
+                     { jjCheckNAddTwoStates(78, 76); }
                   break;
                default : if (i1 == 0 || l1 == 0 || i2 == 0 ||  l2 == 0) break; else break;
             }
@@ -1969,7 +1989,7 @@ else if (curChar < 128)
       ++curPos;
       i = jjnewStateCnt;
       jjnewStateCnt = startsAt;
-      startsAt = 75 - jjnewStateCnt;
+      startsAt = 80 - jjnewStateCnt;
       if (i == startsAt)
          return curPos;
       try { curChar = input_stream.readChar(); }
@@ -2036,10 +2056,10 @@ protected Token jjFillToken()
    return t;
 }
 static final int[] jjnextStates = {
-   2, 4, 6, 7, 65, 66, 68, 44, 45, 50, 51, 54, 55, 64, 69, 24, 
-   25, 27, 57, 59, 62, 16, 29, 30, 32, 9, 10, 12, 18, 19, 22, 34, 
-   35, 38, 46, 47, 22, 60, 61, 16, 71, 72, 74, 20, 21, 48, 49, 52, 
-   53, 
+   2, 4, 6, 7, 44, 45, 50, 51, 55, 56, 59, 60, 69, 74, 24, 25, 
+   27, 62, 64, 67, 16, 29, 30, 32, 70, 71, 73, 9, 10, 12, 18, 19, 
+   22, 34, 35, 38, 46, 47, 22, 65, 66, 16, 76, 77, 79, 20, 21, 48, 
+   49, 53, 54, 57, 58, 
 };
 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
 {
@@ -2250,7 +2270,7 @@ private void ReInitRounds()
   {
     int i;
     jjround = 0x80000001;
-    for (i = 75; i-- > 0;)
+    for (i = 80; i-- > 0;)
       jjrounds[i] = 0x80000000;
   }
 
@@ -2300,8 +2320,8 @@ public void SwitchTo(int lexState)
 };
     protected JavaCharStream  input_stream;
 
-    private final int[] jjrounds = new int[75];
-    private final int[] jjstateSet = new int[2 * 75];
+    private final int[] jjrounds = new int[80];
+    private final int[] jjstateSet = new int[2 * 80];
     private final StringBuilder jjimage = new StringBuilder();
     private StringBuilder image = jjimage;
     private int jjimageLen;
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Reflect.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Reflect.java
index c1cd5a0..1911c5b 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Reflect.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Reflect.java
@@ -121,6 +121,15 @@ public static Object invokeObjectMethod(
             } catch (ReflectError re) { // Void has overstayed its welcome round about here
                 if (object == Primitive.VOID) throw new EvalError("Attempt to invoke method: "
                     + methodName + "() on undefined", callerInfo, callstack, re);
+
+                NameSpace ns = callstack.top();
+                Class<?>[] argTypes = Types.getTypes(args);
+                BshMethod extensionMethod = ns.getExtensionMethod(type, methodName, argTypes);
+                if (extensionMethod != null) {
+                    return extensionMethod.invoke(
+                        args, interpreter, callstack, callerInfo, false, object);
+                }
+
                 // Handle primitive method not found. Autoboxing or magic math method lookup.
                 // Errors gets rolled up, and not found is deferred back to exposed type.
                 if (isPrimitive && !interpreter.getStrictJava()) try { // mitigate recursion
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/This.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/This.java
index bc76fb8..0a0bd1b 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/This.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/This.java
@@ -74,7 +74,9 @@ enum Keys {
         /** The bsh static namespace variable that holds the constructor methods */
         BSHCONSTRUCTORS { public String toString() { return "_bshConstructors"; } },
         /** The bsh static namespace variable that holds the class modifiers */
-        BSHCLASSMODIFIERS { public String toString() { return "_bshClassModifiers"; } }
+        BSHCLASSMODIFIERS { public String toString() { return "_bshClassModifiers"; } },
+        /** The bsh namespace variable that holds the receiver for extension method calls */
+        BSHEXTENSIONMETHODRECEIVER { public String toString() { return "_bshExtensionMethodReceiver"; } },
     }
 
 
diff --git a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
index c02f905..0ca314d 100644
--- a/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
+++ b/bsh-lambda-300-eee36c8/src/main/jjtree/bsh.jjt
@@ -490,7 +490,8 @@ TOKEN : /* LITERALS */
   < #OCTAL_LITERAL: "0" (["0"-"7"])* >
 |
   < FLOATING_POINT_LITERAL:
-        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D","w","W"])?
+        (["0"-"9"])+ "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D","w","W"])?
+      | (["0"-"9"])+ "." <EXPONENT> (["f","F","d","D","w","W"])?
       | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D","w","W"])?
       | (["0"-"9"])+ <EXPONENT> (["f","F","d","D","w","W"])?
       | (["0"-"9"])+ ["f","F","d","D"]
@@ -750,11 +751,10 @@ void MethodDeclaration() #MethodDeclaration :
 {
     mods = Modifiers( Modifiers.METHOD, false ) { if (null != mods) jjtThis.modifiers = mods; }
 (
-    LOOKAHEAD( <IDENTIFIER> "(" )
-    t = <IDENTIFIER> { jjtThis.name = t.image; }
+    LOOKAHEAD( ReturnType() ExtensionName() FormalParameters() )
+    ReturnType() ExtensionName()
 |
-    ReturnType()
-    t = <IDENTIFIER> { jjtThis.name = t.image; }
+    ExtensionName()
 )
     FormalParameters()
     [ "throws" count=NameList() { jjtThis.numThrows=count; } ]
@@ -882,6 +882,32 @@ void AmbiguousName() #AmbiguousName :
   }
 }
 
+void ExtensionName() #AmbiguousName :
+{
+    Token t;
+    StringBuilder s;
+}
+{
+  ( t = <IDENTIFIER>
+    | t = "boolean"
+    | t = "char"
+    | t = "byte"
+    | t = "short"
+    | t = "int"
+    | t = "long"
+    | t = "float"
+    | t = "double"
+  ) {
+    s = new StringBuilder(t.image);
+  }
+  ( LOOKAHEAD(2) "[" "]" { s.append("[]"); } )*
+  ( LOOKAHEAD(2) "." t = <IDENTIFIER> { s.append("."+t.image); }
+    ( LOOKAHEAD(2) "[" "]" { s.append("[]"); } )*
+  )* {
+    jjtThis.text = s.toString();
+  }
+}
+
 int NameList() :
 { int count = 1; }
 {
@@ -1401,12 +1427,12 @@ void BlockStatement() :
   ClassDeclaration()
 |
   LOOKAHEAD ( Modifiers( Modifiers.METHOD, true )
-        ReturnType() <IDENTIFIER> "("
+        ReturnType() ExtensionName() "("
   )
     MethodDeclaration()
 |
   LOOKAHEAD ( Modifiers( Modifiers.METHOD, true )
-        <IDENTIFIER> FormalParameters() [ "throws" NameList() ] "{"
+        ExtensionName() FormalParameters() [ "throws" NameList() ] "{"
   )
     MethodDeclaration()
 |

From 63eab059b47607d2571ebb739021d4bd6f220038 Mon Sep 17 00:00:00 2001
From: Young Y <3900183615@qq.com>
Date: Sun, 3 May 2026 11:03:44 +0800
Subject: [PATCH 24/27] fix: resolve plugin class isolation (#2)

---
 .../src/main/java/bsh/BshClassManager.java      |  8 ++++++++
 .../java/bsh/classpath/ClassManagerImpl.java    | 17 +++++++++++++++++
 .../bsh/classpath/DiscreteFilesClassLoader.java |  3 +--
 .../main/java/bsh/loader/BshPluginLoader.java   | 15 +++++++++++++--
 4 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshClassManager.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshClassManager.java
index 4c97729..1578d86 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/BshClassManager.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/BshClassManager.java
@@ -41,6 +41,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import bsh.loader.BshLoaderManager;
+import bsh.loader.BshPluginLoader;
 import bsh.util.ValueReferenceMap;
 
 import static bsh.Reflect.isPublic;
@@ -326,6 +327,8 @@ An external classloader supplied by the setClassLoader() command.
 
     protected BshLoaderManager loaderManager = new BshLoaderManager();
 
+    protected BshPluginLoader pluginLoader;
+
     /**
         Global cache for things we know are classes.
         Note: these should probably be re-implemented with Soft references.
@@ -630,6 +633,11 @@ public Class<?> defineClass( String name, byte [] code ) {
             +") without class manager package.");
     }
 
+    public Class<?> loadGeneratedClass( String name, byte [] code ) {
+        throw new InterpreterError("Can't load generated class ("+name
+            +") without class manager package.");
+    }
+
     protected void classLoaderChanged() { }
 
     protected static UtilEvalError cmUnavailable() {
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/ClassManagerImpl.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/ClassManagerImpl.java
index cd27132..d643d68 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/ClassManagerImpl.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/ClassManagerImpl.java
@@ -47,6 +47,8 @@
 import bsh.classpath.BshClassPath.ClassSource;
 import bsh.classpath.BshClassPath.GeneratedClassSource;
 import bsh.classpath.BshClassPath.JarClassSource;
+import bsh.loader.BshLoaderHelper;
+import bsh.loader.BshPluginLoader;
 
 /**
     <pre>
@@ -360,6 +362,7 @@ public void reset()
         baseClassPath = new BshClassPath("baseClassPath");
         baseLoader = null;
         loaderMap.clear();
+        initPluginLoader();
         classLoaderChanged(); // calls clearCaches() for us.
     }
 
@@ -390,6 +393,12 @@ public void reloadAllClasses() throws ClassPathException
         setClassPath( bcp.getPathComponents() );
     }
 
+    private void initPluginLoader() {
+        pluginLoader = new BshPluginLoader(
+            externalClassLoader != null ? externalClassLoader : getClass().getClassLoader()
+        );
+    }
+
     /**
         init the baseLoader from the baseClassPath
     */
@@ -595,6 +604,14 @@ public Class<?> defineClass( String name, byte [] code )
         return classForName( name );
     }
 
+    @Override
+    public Class<?> loadGeneratedClass( String name, byte [] code )
+    {
+        Class<?> clazz = BshLoaderHelper.getClassByCode(name, code, pluginLoader);
+        pluginLoader.putClass(name, clazz);
+        return clazz;
+    }
+
     /**
         Clear global class cache and notify namespaces to clear their
         class caches.
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/DiscreteFilesClassLoader.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/DiscreteFilesClassLoader.java
index e54e441..634642e 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/DiscreteFilesClassLoader.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/classpath/DiscreteFilesClassLoader.java
@@ -29,7 +29,6 @@
 
 import bsh.BshClassManager;
 import bsh.classpath.BshClassPath.ClassSource;
-import bsh.loader.BshLoaderHelper;
 
 /**
     A classloader which can load one or more classes from specified sources.
@@ -82,7 +81,7 @@ public Class findClass( String name ) throws ClassNotFoundException
         if ( source != null )
         {
             byte [] code = source.getCode( name );
-            return BshLoaderHelper.getClassByCode(name, code);
+            return getClassManager().loadGeneratedClass(name, code);
         } else
             // Let superclass BshClassLoader (URLClassLoader) findClass try
             // to find the class...
diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/loader/BshPluginLoader.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/loader/BshPluginLoader.java
index 51af303..5235313 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/loader/BshPluginLoader.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/loader/BshPluginLoader.java
@@ -1,12 +1,23 @@
 package bsh.loader;
 
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
 public class BshPluginLoader extends ClassLoader {
+    private final ConcurrentMap<String, Class<?>> clazzMap = new ConcurrentHashMap<>();
+
     public BshPluginLoader(ClassLoader parent) {
         super(parent);
     }
 
+    public void putClass(String name, Class<?> clazz) {
+        clazzMap.put(name, clazz);
+    }
+
     @Override
-    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-        return super.loadClass(name, resolve);
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        Class<?> clazz = clazzMap.get(name);
+        if (clazz != null) return clazz;
+        throw new ClassNotFoundException(name);
     }
 }

From 6656ee132942cb0d7353be2b77d81161024bd29d Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Sun, 3 May 2026 12:22:04 +0800
Subject: [PATCH 25/27] refactor: simplify app into single editor activity

---
 app/build.gradle.kts                          |  4 --
 .../copylibs/bsh/plugin/PluginManager.kt      | 25 +++-----
 .../copylibs/bsh/plugin/log/PluginLogger.kt   |  9 ---
 .../method/{TestClass1.kt => LogClass.kt}     |  2 +-
 .../copylibs/bsh/plugin/method/TestClass2.kt  |  7 ---
 .../copylibs/bsh/ui/activity/MainActivity.kt  | 43 ++++++++++++++
 .../copylibs/bsh/ui/adapter/MVP2Adapter.kt    | 18 ------
 .../copylibs/bsh/ui/base/FragmentBase.kt      | 25 --------
 .../copylibs/bsh/ui/fragment/NavFragment.kt   | 39 ------------
 .../bsh/ui/fragment/page/AboutFragment.kt     | 18 ------
 .../bsh/ui/fragment/page/CodeFragment.kt      | 55 -----------------
 .../bsh/ui/fragment/page/LogFragment.kt       | 40 -------------
 app/src/main/res/drawable/ic_about_24dp.xml   | 27 ---------
 app/src/main/res/drawable/ic_code_24dp.xml    | 34 -----------
 app/src/main/res/drawable/ic_log_24dp.xml     | 20 -------
 app/src/main/res/layout/activity_main.xml     | 42 ++++++++++---
 app/src/main/res/layout/fragment_about.xml    | 39 ------------
 app/src/main/res/layout/fragment_code.xml     | 41 -------------
 app/src/main/res/layout/fragment_log.xml      | 59 -------------------
 app/src/main/res/layout/fragment_nav.xml      | 24 --------
 app/src/main/res/menu/menu_nav.xml            | 15 -----
 app/src/main/res/navigation/nav_container.xml | 12 ----
 gradle/libs.versions.toml                     |  4 --
 23 files changed, 86 insertions(+), 516 deletions(-)
 rename app/src/main/java/io/github/copylibs/bsh/plugin/method/{TestClass1.kt => LogClass.kt} (85%)
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass2.kt
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/ui/adapter/MVP2Adapter.kt
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/ui/base/FragmentBase.kt
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/ui/fragment/NavFragment.kt
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/AboutFragment.kt
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/CodeFragment.kt
 delete mode 100644 app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/LogFragment.kt
 delete mode 100644 app/src/main/res/drawable/ic_about_24dp.xml
 delete mode 100644 app/src/main/res/drawable/ic_code_24dp.xml
 delete mode 100644 app/src/main/res/drawable/ic_log_24dp.xml
 delete mode 100644 app/src/main/res/layout/fragment_about.xml
 delete mode 100644 app/src/main/res/layout/fragment_code.xml
 delete mode 100644 app/src/main/res/layout/fragment_log.xml
 delete mode 100644 app/src/main/res/layout/fragment_nav.xml
 delete mode 100644 app/src/main/res/menu/menu_nav.xml
 delete mode 100644 app/src/main/res/navigation/nav_container.xml

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 051a8c6..66b3924 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -34,10 +34,6 @@ kotlin {
 
 dependencies {
     implementation(libs.material)
-    implementation(libs.appcompat)
-    implementation(libs.core.ktx)
-    implementation(libs.navigation.fragment.ktx)
-    implementation(libs.navigation.ui.ktx)
     implementation(libs.editor)
     implementation(libs.language.java)
     implementation(project(":bsh-lambda-300-eee36c8"))
diff --git a/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt b/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt
index e5c506c..9bb1b77 100644
--- a/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt
+++ b/app/src/main/java/io/github/copylibs/bsh/plugin/PluginManager.kt
@@ -2,33 +2,26 @@ package io.github.copylibs.bsh.plugin
 
 import android.content.Context
 import bsh.BshMethod
-import io.github.copylibs.bsh.plugin.method.TestClass1
-import io.github.copylibs.bsh.plugin.method.TestClass2
+import io.github.copylibs.bsh.plugin.method.LogClass
 
 object PluginManager {
-    fun getPlugin(context: Context): Plugin {
+    fun getPlugin(ctx: Context): Plugin {
         return Plugin().apply {
-            registerVariable(this, context)
-            registerMethod(this, context)
+            registerVariable(this, ctx)
+            registerMethod(this, ctx)
         }
     }
 
-    private fun registerVariable(plugin: Plugin, context: Context) {
-        plugin.setVariable("context", context)
+    private fun registerVariable(plugin: Plugin, ctx: Context) {
+        plugin.setVariable("ctx", ctx)
         plugin.setVariable("tag", "BeanShell")
     }
 
-    private fun registerMethod(plugin: Plugin, context: Context) {
-        val testClass1 = TestClass1(context)
-        val testClass2 = TestClass2
+    private fun registerMethod(plugin: Plugin, ctx: Context) {
+        val logInstance = LogClass(ctx)
         plugin.setMethod(
             BshMethod("log", arrayOf(Any::class.java)) { args ->
-                testClass1.log(args[0])
-            }
-        )
-        plugin.setMethod(
-            BshMethod("print", arrayOf(Any::class.java)) { args ->
-                testClass2.print(args[0])
+                logInstance.log(args[0])
             }
         )
         plugin.setMethod(
diff --git a/app/src/main/java/io/github/copylibs/bsh/plugin/log/PluginLogger.kt b/app/src/main/java/io/github/copylibs/bsh/plugin/log/PluginLogger.kt
index 853ca31..6ce2c62 100644
--- a/app/src/main/java/io/github/copylibs/bsh/plugin/log/PluginLogger.kt
+++ b/app/src/main/java/io/github/copylibs/bsh/plugin/log/PluginLogger.kt
@@ -20,15 +20,6 @@ object PluginLogger {
         logFile.appendText("$formatMsg\n")
     }
 
-    fun readLog(ctx: Context): String {
-        val logFile = getLogFile(ctx)
-        return if (logFile.exists()) {
-            logFile.readText()
-        } else {
-            "日志文件不存在"
-        }
-    }
-
     fun clearLog(ctx: Context) {
         val logFile = getLogFile(ctx)
         logFile.writeText("")
diff --git a/app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass1.kt b/app/src/main/java/io/github/copylibs/bsh/plugin/method/LogClass.kt
similarity index 85%
rename from app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass1.kt
rename to app/src/main/java/io/github/copylibs/bsh/plugin/method/LogClass.kt
index f253c6d..faf7eb2 100644
--- a/app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass1.kt
+++ b/app/src/main/java/io/github/copylibs/bsh/plugin/method/LogClass.kt
@@ -3,7 +3,7 @@ package io.github.copylibs.bsh.plugin.method
 import android.content.Context
 import io.github.copylibs.bsh.plugin.log.PluginLogger
 
-class TestClass1(val ctx: Context) {
+class LogClass(val ctx: Context) {
     fun log(msg: Any) {
         PluginLogger.writeLog(ctx, msg.toString())
     }
diff --git a/app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass2.kt b/app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass2.kt
deleted file mode 100644
index 59f1853..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/plugin/method/TestClass2.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package io.github.copylibs.bsh.plugin.method
-
-object TestClass2 {
-    fun print(msg: Any) {
-        println(msg)
-    }
-}
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt b/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt
index 589c689..8112e3a 100644
--- a/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt
+++ b/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt
@@ -1,13 +1,56 @@
 package io.github.copylibs.bsh.ui.activity
 
+import android.graphics.Typeface
 import android.os.Bundle
+import android.view.MenuItem
 import io.github.copylibs.bsh.databinding.ActivityMainBinding
+import io.github.copylibs.bsh.plugin.PluginManager
+import io.github.copylibs.bsh.plugin.log.PluginLogger
 import io.github.copylibs.bsh.ui.base.ActivityBase
+import io.github.rosemoe.sora.langs.java.JavaLanguage
 
 class MainActivity : ActivityBase<ActivityMainBinding>(
     ActivityMainBinding::inflate
 ) {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        initView()
+    }
+
+    private fun initView() {
+        binding.codeToolbar.menu.apply {
+            add("运行").apply {
+                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
+                setOnMenuItemClickListener {
+                    val context = this@MainActivity
+                    val code = binding.codeEditor.text.toString()
+                    runCatching {
+                        PluginManager.getPlugin(context).eval(code)
+                    }.onFailure {
+                        PluginLogger.writeLog(context, "运行异常: $it")
+                        it.printStackTrace()
+                    }
+                    true
+                }
+            }
+            add("撤销").apply {
+                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
+                setOnMenuItemClickListener {
+                    binding.codeEditor.undo()
+                    true
+                }
+            }
+            add("重做").apply {
+                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
+                setOnMenuItemClickListener {
+                    binding.codeEditor.redo()
+                    true
+                }
+            }
+        }
+        binding.codeEditor.apply {
+            typefaceText = Typeface.createFromAsset(context.assets, "font/mono.ttf")
+            setEditorLanguage(JavaLanguage())
+        }
     }
 }
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/adapter/MVP2Adapter.kt b/app/src/main/java/io/github/copylibs/bsh/ui/adapter/MVP2Adapter.kt
deleted file mode 100644
index ff1e859..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/ui/adapter/MVP2Adapter.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package io.github.copylibs.bsh.ui.adapter
-
-import androidx.fragment.app.Fragment
-import androidx.fragment.app.FragmentActivity
-import androidx.viewpager2.adapter.FragmentStateAdapter
-
-class MVP2Adapter(
-    fragmentActivity: FragmentActivity,
-    private val fragmentList: List<Fragment>
-) : FragmentStateAdapter(fragmentActivity) {
-    override fun createFragment(position: Int): Fragment {
-        return fragmentList[position]
-    }
-
-    override fun getItemCount(): Int {
-        return fragmentList.size
-    }
-}
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/base/FragmentBase.kt b/app/src/main/java/io/github/copylibs/bsh/ui/base/FragmentBase.kt
deleted file mode 100644
index caf99ea..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/ui/base/FragmentBase.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package io.github.copylibs.bsh.ui.base
-
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.fragment.app.Fragment
-import androidx.viewbinding.ViewBinding
-
-abstract class FragmentBase<VB : ViewBinding>(
-    private val inflate: (LayoutInflater, ViewGroup?, Boolean) -> VB
-) : Fragment() {
-    private var _binding: VB? = null
-    protected val binding: VB get() = _binding!!
-
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
-        _binding = inflate.invoke(inflater, container, false)
-        return binding.root
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        _binding = null
-    }
-}
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/NavFragment.kt b/app/src/main/java/io/github/copylibs/bsh/ui/fragment/NavFragment.kt
deleted file mode 100644
index d677f47..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/NavFragment.kt
+++ /dev/null
@@ -1,39 +0,0 @@
-package io.github.copylibs.bsh.ui.fragment
-
-import android.os.Bundle
-import android.view.View
-import io.github.copylibs.bsh.R
-import io.github.copylibs.bsh.databinding.FragmentNavBinding
-import io.github.copylibs.bsh.ui.adapter.MVP2Adapter
-import io.github.copylibs.bsh.ui.base.FragmentBase
-import io.github.copylibs.bsh.ui.fragment.page.AboutFragment
-import io.github.copylibs.bsh.ui.fragment.page.CodeFragment
-import io.github.copylibs.bsh.ui.fragment.page.LogFragment
-
-class NavFragment : FragmentBase<FragmentNavBinding>(
-    FragmentNavBinding::inflate
-) {
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-        initView()
-    }
-
-    private fun initView() {
-        binding.navViewPager2.apply {
-            isUserInputEnabled = false
-            val fragmentPages = listOf(
-                CodeFragment() to R.id.navCodeFragment,
-                LogFragment() to R.id.navLogFragment,
-                AboutFragment() to R.id.navAboutFragment
-            )
-            adapter = MVP2Adapter(requireActivity(), fragmentPages.map { it.first })
-            binding.navBottomNav.setOnItemSelectedListener { item ->
-                val position = fragmentPages.indexOfFirst { it.second == item.itemId }
-                if (position != -1) {
-                    setCurrentItem(position, false)
-                }
-                true
-            }
-        }
-    }
-}
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/AboutFragment.kt b/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/AboutFragment.kt
deleted file mode 100644
index 065433a..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/AboutFragment.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package io.github.copylibs.bsh.ui.fragment.page
-
-import android.os.Bundle
-import android.view.View
-import io.github.copylibs.bsh.databinding.FragmentAboutBinding
-import io.github.copylibs.bsh.ui.base.FragmentBase
-
-class AboutFragment : FragmentBase<FragmentAboutBinding>(
-    FragmentAboutBinding::inflate
-) {
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-        initView()
-    }
-
-    private fun initView() {
-    }
-}
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/CodeFragment.kt b/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/CodeFragment.kt
deleted file mode 100644
index 80b251b..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/CodeFragment.kt
+++ /dev/null
@@ -1,55 +0,0 @@
-package io.github.copylibs.bsh.ui.fragment.page
-
-import android.graphics.Typeface
-import android.os.Bundle
-import android.view.MenuItem
-import android.view.View
-import io.github.copylibs.bsh.databinding.FragmentCodeBinding
-import io.github.copylibs.bsh.plugin.PluginManager
-import io.github.copylibs.bsh.plugin.log.PluginLogger
-import io.github.copylibs.bsh.ui.base.FragmentBase
-import io.github.rosemoe.sora.langs.java.JavaLanguage
-
-class CodeFragment : FragmentBase<FragmentCodeBinding>(
-    FragmentCodeBinding::inflate
-) {
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-        initView()
-    }
-
-    private fun initView() {
-        binding.codeToolbar.apply {
-            menu.add("运行").apply {
-                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                setOnMenuItemClickListener {
-                    runCatching {
-                        PluginManager.getPlugin(requireContext()).eval(binding.codeEditor.text.toString())
-                    }.onFailure {
-                        PluginLogger.writeLog(requireContext(), "运行异常: $it")
-                        it.printStackTrace()
-                    }
-                    true
-                }
-            }
-            menu.add("撤销").apply {
-                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                setOnMenuItemClickListener {
-                    binding.codeEditor.undo()
-                    true
-                }
-            }
-            menu.add("重做").apply {
-                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                setOnMenuItemClickListener {
-                    binding.codeEditor.redo()
-                    true
-                }
-            }
-        }
-        binding.codeEditor.apply {
-            typefaceText = Typeface.createFromAsset(context.assets, "font/mono.ttf")
-            setEditorLanguage(JavaLanguage())
-        }
-    }
-}
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/LogFragment.kt b/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/LogFragment.kt
deleted file mode 100644
index f1ff735..0000000
--- a/app/src/main/java/io/github/copylibs/bsh/ui/fragment/page/LogFragment.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package io.github.copylibs.bsh.ui.fragment.page
-
-import android.os.Bundle
-import android.view.MenuItem
-import android.view.View
-import io.github.copylibs.bsh.databinding.FragmentLogBinding
-import io.github.copylibs.bsh.plugin.log.PluginLogger
-import io.github.copylibs.bsh.ui.base.FragmentBase
-
-class LogFragment : FragmentBase<FragmentLogBinding>(
-    FragmentLogBinding::inflate
-) {
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-        initView()
-    }
-
-    private fun initView() {
-        binding.logToolbar.apply {
-            menu.add("清空").apply {
-                setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
-                setOnMenuItemClickListener {
-                    PluginLogger.clearLog(requireContext())
-                    refreshLog()
-                    true
-                }
-            }
-        }
-        refreshLog()
-    }
-
-    override fun onResume() {
-        super.onResume()
-        refreshLog()
-    }
-
-    private fun refreshLog() {
-        binding.logTvContent.text = PluginLogger.readLog(requireContext())
-    }
-}
diff --git a/app/src/main/res/drawable/ic_about_24dp.xml b/app/src/main/res/drawable/ic_about_24dp.xml
deleted file mode 100644
index eb225cb..0000000
--- a/app/src/main/res/drawable/ic_about_24dp.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24">
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M3,12a9,9 0,1 0,18 0a9,9 0,0 0,-18 0"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M12,9h0.01"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M11,12h1v4h1"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-</vector>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/ic_code_24dp.xml b/app/src/main/res/drawable/ic_code_24dp.xml
deleted file mode 100644
index 1d7e7ca..0000000
--- a/app/src/main/res/drawable/ic_code_24dp.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24">
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M8.5,13.5l-1.5,-1.5l1.5,-1.5"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M15.5,10.5l1.5,1.5l-1.5,1.5"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M12,12m-9,0a9,9 0,1 0,18 0a9,9 0,1 0,-18 0"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M13,9.5l-2,5.5"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-</vector>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/ic_log_24dp.xml b/app/src/main/res/drawable/ic_log_24dp.xml
deleted file mode 100644
index bc2b48a..0000000
--- a/app/src/main/res/drawable/ic_log_24dp.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24">
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M21,12a9,9 0,1 1,-18 0a9,9 0,0 1,18 0z"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M8,11.503a2.5,2.5 0,1 0,4 2v-3a2.5,2.5 0,1 1,4 2"
-        android:strokeWidth="2"
-        android:strokeColor="?attr/colorPrimary"
-        android:strokeLineCap="round"
-        android:strokeLineJoin="round" />
-</vector>
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index ab57c2e..b2aa2a4 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -1,17 +1,41 @@
 <?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
-    android:layout_height="match_parent">
+    android:layout_height="match_parent"
+    tools:context=".ui.activity.MainActivity">
 
-    <androidx.fragment.app.FragmentContainerView
-        android:id="@+id/containerView"
-        android:name="androidx.navigation.fragment.NavHostFragment"
+    <com.google.android.material.appbar.AppBarLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:background="?attr/colorSurface">
+
+        <com.google.android.material.appbar.MaterialToolbar
+            android:id="@+id/codeToolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            android:elevation="0dp"
+            app:title="BeanShell"
+            app:titleMarginStart="16dp"
+            app:titleTextColor="?attr/colorPrimary" />
+
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="match_parent"
-        app:defaultNavHost="true"
-        app:navGraph="@navigation/nav_container"
-        tools:layout="@layout/fragment_nav" />
+        android:orientation="vertical"
+        app:layout_behavior="@string/appbar_scrolling_view_behavior">
+
+        <io.github.rosemoe.sora.widget.CodeEditor
+            android:id="@+id/codeEditor"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            app:lnPanelPosition="center"
+            app:lnPanelPositionMode="follow"
+            app:textSize="14sp" />
+
+    </LinearLayout>
 
-</FrameLayout>
\ No newline at end of file
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
diff --git a/app/src/main/res/layout/fragment_about.xml b/app/src/main/res/layout/fragment_about.xml
deleted file mode 100644
index d14f899..0000000
--- a/app/src/main/res/layout/fragment_about.xml
+++ /dev/null
@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".ui.fragment.page.AboutFragment">
-
-    <com.google.android.material.appbar.AppBarLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:background="?attr/colorSurface">
-
-        <com.google.android.material.appbar.MaterialToolbar
-            android:id="@+id/codeToolbar"
-            android:layout_width="match_parent"
-            android:layout_height="?attr/actionBarSize"
-            android:elevation="0dp"
-            app:title="BeanShell"
-            app:titleMarginStart="16dp"
-            app:titleTextColor="?attr/colorPrimary" />
-
-    </com.google.android.material.appbar.AppBarLayout>
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:orientation="vertical"
-        android:paddingHorizontal="12dp"
-        app:layout_behavior="@string/appbar_scrolling_view_behavior">
-
-        <com.google.android.material.textview.MaterialTextView
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="About" />
-
-    </LinearLayout>
-
-</androidx.coordinatorlayout.widget.CoordinatorLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/fragment_code.xml b/app/src/main/res/layout/fragment_code.xml
deleted file mode 100644
index 6729870..0000000
--- a/app/src/main/res/layout/fragment_code.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".ui.fragment.page.CodeFragment">
-
-    <com.google.android.material.appbar.AppBarLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:background="?attr/colorSurface">
-
-        <com.google.android.material.appbar.MaterialToolbar
-            android:id="@+id/codeToolbar"
-            android:layout_width="match_parent"
-            android:layout_height="?attr/actionBarSize"
-            android:elevation="0dp"
-            app:title="BeanShell"
-            app:titleMarginStart="16dp"
-            app:titleTextColor="?attr/colorPrimary" />
-
-    </com.google.android.material.appbar.AppBarLayout>
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:orientation="vertical"
-        app:layout_behavior="@string/appbar_scrolling_view_behavior">
-
-        <io.github.rosemoe.sora.widget.CodeEditor
-            android:id="@+id/codeEditor"
-            android:layout_width="match_parent"
-            android:layout_height="match_parent"
-            app:lnPanelPosition="center"
-            app:lnPanelPositionMode="follow"
-            app:textSize="14sp" />
-
-    </LinearLayout>
-
-</androidx.coordinatorlayout.widget.CoordinatorLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/fragment_log.xml b/app/src/main/res/layout/fragment_log.xml
deleted file mode 100644
index 49d2697..0000000
--- a/app/src/main/res/layout/fragment_log.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".ui.fragment.page.LogFragment">
-
-    <com.google.android.material.appbar.AppBarLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:background="?attr/colorSurface">
-
-        <com.google.android.material.appbar.MaterialToolbar
-            android:id="@+id/logToolbar"
-            android:layout_width="match_parent"
-            android:layout_height="?attr/actionBarSize"
-            android:elevation="0dp"
-            app:title="BeanShell"
-            app:titleMarginStart="16dp"
-            app:titleTextColor="?attr/colorPrimary" />
-
-    </com.google.android.material.appbar.AppBarLayout>
-
-    <HorizontalScrollView
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:clipToPadding="false"
-        android:fillViewport="true"
-        android:paddingHorizontal="12dp"
-        android:scrollbars="horizontal"
-        app:layout_behavior="@string/appbar_scrolling_view_behavior">
-
-        <ScrollView
-            android:layout_width="wrap_content"
-            android:layout_height="match_parent"
-            android:clipToPadding="false"
-            android:fillViewport="true"
-            android:scrollbars="vertical">
-
-            <com.google.android.material.textview.MaterialTextView
-                android:id="@+id/logTvContent"
-                style="@style/TextAppearance.AppCompat.Small"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:clipToPadding="false"
-                android:fontFamily="monospace"
-                android:hyphenationFrequency="none"
-                android:scrollHorizontally="true"
-                android:textColor="?attr/colorOnSurface"
-                android:textIsSelectable="true"
-                android:textSize="12sp"
-                tools:text="Log" />
-
-        </ScrollView>
-
-    </HorizontalScrollView>
-
-</androidx.coordinatorlayout.widget.CoordinatorLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/fragment_nav.xml b/app/src/main/res/layout/fragment_nav.xml
deleted file mode 100644
index b2803af..0000000
--- a/app/src/main/res/layout/fragment_nav.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:orientation="vertical"
-    tools:context=".ui.fragment.NavFragment">
-
-    <androidx.viewpager2.widget.ViewPager2
-        android:id="@+id/navViewPager2"
-        android:layout_width="match_parent"
-        android:layout_height="0dp"
-        android:layout_weight="1"
-        android:background="?attr/colorSurface" />
-
-    <com.google.android.material.bottomnavigation.BottomNavigationView
-        android:id="@+id/navBottomNav"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        app:labelVisibilityMode="selected"
-        app:menu="@menu/menu_nav" />
-
-</LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/menu/menu_nav.xml b/app/src/main/res/menu/menu_nav.xml
deleted file mode 100644
index 9935971..0000000
--- a/app/src/main/res/menu/menu_nav.xml
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<menu xmlns:android="http://schemas.android.com/apk/res/android">
-    <item
-        android:id="@+id/navCodeFragment"
-        android:icon="@drawable/ic_code_24dp"
-        android:title="代码" />
-    <item
-        android:id="@+id/navLogFragment"
-        android:icon="@drawable/ic_log_24dp"
-        android:title="日志" />
-    <item
-        android:id="@+id/navAboutFragment"
-        android:icon="@drawable/ic_about_24dp"
-        android:title="关于" />
-</menu>
\ No newline at end of file
diff --git a/app/src/main/res/navigation/nav_container.xml b/app/src/main/res/navigation/nav_container.xml
deleted file mode 100644
index 9605517..0000000
--- a/app/src/main/res/navigation/nav_container.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<navigation xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:id="@+id/containerView"
-    app:startDestination="@+id/navFragment">
-    <fragment
-        android:id="@+id/navFragment"
-        android:name="io.github.copylibs.bsh.ui.fragment.NavFragment"
-        android:label="navFragment"
-        tools:layout="@layout/fragment_nav" />
-</navigation>
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 2315279..6685ecc 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -4,10 +4,6 @@ kotlin = "2.3.20"
 
 [libraries]
 material = { group = "com.google.android.material", name = "material", version = "1.13.0" }
-appcompat = { group = "androidx.appcompat", name = "appcompat", version = "1.7.1" }
-core-ktx = { group = "androidx.core", name = "core-ktx", version = "1.18.0" }
-navigation-fragment-ktx = { module = "androidx.navigation:navigation-fragment-ktx", version = "2.9.7" }
-navigation-ui-ktx = { module = "androidx.navigation:navigation-ui-ktx", version = "2.9.7" }
 editor = { module = "io.github.rosemoe:editor", version = "0.24.5" }
 language-java = { module = "io.github.rosemoe:language-java", version = "0.24.5" }
 dalvik-dx = { module = "com.jakewharton.android.repackaged:dalvik-dx", version = "16.0.1" }

From aecf3c2647a4c67f0c00bd3e622123392e829827 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Sun, 3 May 2026 13:22:06 +0800
Subject: [PATCH 26/27] refactor: migrate editor from SoraEditor to SweetEditor

---
 app/build.gradle.kts                          |  3 +-
 .../copylibs/bsh/ui/activity/MainActivity.kt  | 29 ++++++++++++++++---
 app/src/main/res/layout/activity_main.xml     |  8 ++---
 gradle/libs.versions.toml                     |  3 +-
 4 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 66b3924..ff66c38 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -34,7 +34,6 @@ kotlin {
 
 dependencies {
     implementation(libs.material)
-    implementation(libs.editor)
-    implementation(libs.language.java)
+    implementation(libs.sweeteditor)
     implementation(project(":bsh-lambda-300-eee36c8"))
 }
diff --git a/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt b/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt
index 8112e3a..db43005 100644
--- a/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt
+++ b/app/src/main/java/io/github/copylibs/bsh/ui/activity/MainActivity.kt
@@ -3,11 +3,15 @@ package io.github.copylibs.bsh.ui.activity
 import android.graphics.Typeface
 import android.os.Bundle
 import android.view.MenuItem
+import com.qiplat.sweeteditor.EditorTheme
+import com.qiplat.sweeteditor.LanguageConfiguration
+import com.qiplat.sweeteditor.core.Document
+import com.qiplat.sweeteditor.core.foundation.CurrentLineRenderMode
+import com.qiplat.sweeteditor.core.foundation.FoldArrowMode
 import io.github.copylibs.bsh.databinding.ActivityMainBinding
 import io.github.copylibs.bsh.plugin.PluginManager
 import io.github.copylibs.bsh.plugin.log.PluginLogger
 import io.github.copylibs.bsh.ui.base.ActivityBase
-import io.github.rosemoe.sora.langs.java.JavaLanguage
 
 class MainActivity : ActivityBase<ActivityMainBinding>(
     ActivityMainBinding::inflate
@@ -23,7 +27,7 @@ class MainActivity : ActivityBase<ActivityMainBinding>(
                 setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
                 setOnMenuItemClickListener {
                     val context = this@MainActivity
-                    val code = binding.codeEditor.text.toString()
+                    val code = binding.codeEditor.document?.text.toString()
                     runCatching {
                         PluginManager.getPlugin(context).eval(code)
                     }.onFailure {
@@ -49,8 +53,25 @@ class MainActivity : ActivityBase<ActivityMainBinding>(
             }
         }
         binding.codeEditor.apply {
-            typefaceText = Typeface.createFromAsset(context.assets, "font/mono.ttf")
-            setEditorLanguage(JavaLanguage())
+            applyTheme(EditorTheme.light())
+            setLanguageConfiguration(
+                LanguageConfiguration.Builder("bsh")
+                    .addAutoClosingPair("\"", "\"")
+                    .addAutoClosingPair("(", ")")
+                    .addAutoClosingPair("{", "}")
+                    .addAutoClosingPair("[", "]")
+                    .setInsertSpaces(true)
+                    .build()
+            )
+            settings.apply {
+                setEditorTextSize(28f)
+                setTypeface(Typeface.createFromAsset(context.assets, "font/mono.ttf"))
+                setFoldArrowMode(FoldArrowMode.AUTO)
+                setGutterSticky(true)
+                setCurrentLineRenderMode(CurrentLineRenderMode.BORDER)
+                setCompositionEnabled(true)
+            }
+            loadDocument(Document(""))
         }
     }
 }
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index b2aa2a4..8062c55 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -28,13 +28,11 @@
         android:orientation="vertical"
         app:layout_behavior="@string/appbar_scrolling_view_behavior">
 
-        <io.github.rosemoe.sora.widget.CodeEditor
+        <com.qiplat.sweeteditor.SweetEditor
             android:id="@+id/codeEditor"
             android:layout_width="match_parent"
-            android:layout_height="match_parent"
-            app:lnPanelPosition="center"
-            app:lnPanelPositionMode="follow"
-            app:textSize="14sp" />
+            android:layout_height="0dp"
+            android:layout_weight="1" />
 
     </LinearLayout>
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 6685ecc..c6998f3 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -4,8 +4,7 @@ kotlin = "2.3.20"
 
 [libraries]
 material = { group = "com.google.android.material", name = "material", version = "1.13.0" }
-editor = { module = "io.github.rosemoe:editor", version = "0.24.5" }
-language-java = { module = "io.github.rosemoe:language-java", version = "0.24.5" }
+sweeteditor = { module = "com.qiplat:sweeteditor", version = "1.0.6" }
 dalvik-dx = { module = "com.jakewharton.android.repackaged:dalvik-dx", version = "16.0.1" }
 android-gradle = { module = "com.android.tools.build:gradle", version.ref = "agp" }
 kotlin-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }

From 229934bb260a5b1174e8099283cc73283e93a971 Mon Sep 17 00:00:00 2001
From: hd <hdshare@vip.qq.com>
Date: Mon, 4 May 2026 01:11:17 +0800
Subject: [PATCH 27/27] fix: preserve fixed arity for packed Java varargs

String.format(Locale.US, "%.2f", 1.2345f)
---
 bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java b/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
index c1c2a33..5bb2f5b 100644
--- a/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
+++ b/bsh-lambda-300-eee36c8/src/main/java/bsh/Invocable.java
@@ -344,6 +344,7 @@ && getVarArgsComponentType().isAssignableFrom(lastParam.getClass().getComponentT
                     && lastParam != null
                     && lastParam.getClass().isArray()
                     && Object[].class.isAssignableFrom(lastParam.getClass())) {
+                    isFixedArity = true;
                     Object[] source = (Object[]) lastParam;
                     Object varargs = Array.newInstance(getVarArgsComponentType(), source.length);
                     for (int i = 0; i < source.length; i++)
@@ -351,6 +352,7 @@ && getVarArgsComponentType().isAssignableFrom(lastParam.getClass().getComponentT
                             source[i], getVarArgsComponentType()));
                     parameters.add(varargs);
                 } else {
+                    isFixedArity = true;
                     int length = params.length - getLastParameterIndex();
                     Object varargs = Array.newInstance(getVarArgsComponentType(), length);
                     for (int i = 0; i < length; i++)
@@ -359,6 +361,7 @@ && getVarArgsComponentType().isAssignableFrom(lastParam.getClass().getComponentT
                     parameters.add(varargs);
                 }
             } else {
+                isFixedArity = true;
                 parameters.add(Array.newInstance(getVarArgsComponentType(), 0));
             }
         } else if (null != params && getLastParameterIndex() < params.length)