Add java_library to Android.bp and manually generated_sources. am: f2461dce3a am: 2ccb9641e1 am: 67603ab6a1 am: 3a93ff2641

Original change: https://android-review.googlesource.com/c/platform/external/apache-velocity-engine/+/2436333

Change-Id: I0b728fc9fbf78769166aa7feead28c0df015cedd
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

10 files changed, 15080 insertions, 0 deletions

diff --git a/Android.bp b/Android.bp
index 149a5a38..1415c075 100644
--- a/Android.bp
+++ b/Android.bp
@@ -28,3 +28,38 @@ license {
         "NOTICE",
     ],
 }
+
+java_library {
+    name: "apache-velocity-engine-core",
+    srcs: ["velocity-engine-core/src/main/java/**/*.java",
+            // Manually generated code as javacc is not availiable for AOSP build
+            // mvn && cp -r velocity-engine-core/target/generated-srcs .
+           "generated-sources/**/*.java"],
+    exclude_srcs: ["velocity-engine-core/src/main/java/org/apache/velocity/runtime/resource/loader/JarResourceLoader.java",
+                   "velocity-engine-core/src/main/java/org/apache/velocity/runtime/resource/loader/DataSourceResourceLoader.java"],
+    java_resource_dirs: ["velocity-engine-core/src/main/resources"],
+    sdk_version: "current",
+    min_sdk_version: "33",
+    static_libs: [
+        "apache-commons-lang",
+        "apache-commons-io",
+        "slf4j-jdk14",
+    ],
+    java_version: "1.8",
+    apex_available: [
+        "//apex_available:platform",
+        "com.android.ondevicepersonalization",
+    ],
+    visibility: [
+        "//external/apache-velocity-engine",
+        "//packages/modules/OnDevicePersonalization:__subpackages__",
+    ],
+    lint: {
+        warning_checks: ["SuspiciousIndentation"],
+    },
+    errorprone: {
+        javacflags: [
+            "-Xep:ReturnValueIgnored:OFF",
+        ],
+    },
+}
diff --git a/generated-sources/java-templates/org/apache/velocity/runtime/VelocityEngineVersion.java b/generated-sources/java-templates/org/apache/velocity/runtime/VelocityEngineVersion.java
new file mode 100644
index 00000000..55d9caca
--- /dev/null
+++ b/generated-sources/java-templates/org/apache/velocity/runtime/VelocityEngineVersion.java
@@ -0,0 +1,6 @@
+package org.apache.velocity.runtime;
+
+public class VelocityEngineVersion
+{
+    public static final String VERSION = "2.4-SNAPSHOT";
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParser.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParser.java
new file mode 100644
index 00000000..1e857d83
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParser.java
@@ -0,0 +1,5447 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. StandardParser.java */
+package org.apache.velocity.runtime.parser;
+import org.apache.velocity.runtime.parser.node.*;
+
+
+import java.io.*;
+import java.util.*;
+import org.apache.velocity.Template;
+import org.apache.velocity.exception.VelocityException;
+import org.apache.velocity.runtime.RuntimeServices;
+import org.apache.velocity.runtime.parser.*;
+import org.apache.velocity.runtime.parser.node.*;
+import org.apache.velocity.runtime.directive.*;
+import org.apache.velocity.runtime.directive.MacroParseException;
+import org.apache.velocity.runtime.RuntimeConstants;
+import static org.apache.velocity.runtime.RuntimeConstants.SpaceGobbling;
+
+import org.slf4j.Logger;
+
+/**
+ * This class is responsible for parsing a Velocity
+ * template. This class was generated by JavaCC using
+ * the JJTree extension to produce an Abstract
+ * Syntax Tree (AST) of the template.
+ *
+ * Please look at the Parser.jjt file which is
+ * what controls the generation of this class.
+ *
+ * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
+ * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
+ * @author <a href="hps@intermeta.de">Henning P. Schmiedehausen</a>
+ * @version $Id$
+*/
+public class StandardParser implements/*@bgen(jjtree)*/ StandardParserTreeConstants,Parser, StandardParserConstants {/*@bgen(jjtree)*/
+  protected JJTStandardParserState jjtree = new JJTStandardParserState();/**
+     * Parser debugging flag.
+     * When debug is active, javacc Parser will contain (among other things)
+     * a trace_call() method. So we use the presence of this method to
+     * initialize our flag.
+     */
+    private static boolean debugParser;
+    static
+    {
+        try
+        {
+            StandardParser.class.getDeclaredMethod("trace_call", String.class);
+            debugParser = true;
+        }
+        catch(NoSuchMethodException nsfe)
+        {
+            debugParser = false;
+        }
+    }
+
+    /**
+     * Our own trace method. Use sparsingly in production, since each
+     * and every call will introduce an execution branch and slow down parsing.
+     */
+    public static void trace(String message)
+    {
+        if (debugParser) System.out.println(message);
+    }
+
+    /**
+     * Keep track of defined macros, used for escape processing
+     */
+    private Map macroNames = new HashMap();
+
+    /**
+     * Current template we are parsing.  Passed to us in parse()
+     */
+    public Template currentTemplate = null;
+
+    /**
+     * Set to true if the property
+     * RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE is set to true
+     */
+    public boolean strictEscape = false;
+
+    /**
+     * Set to true if the propoerty
+     * RuntimeConstants.PARSER_HYPHEN_ALLOWED is set to true
+     */
+    public boolean hyphenAllowedInIdentifiers = false;
+
+    VelocityCharStream velcharstream = null;
+
+    private RuntimeServices rsvc = null;
+
+    @Override
+    public RuntimeServices getRuntimeServices()
+    {
+        return rsvc;
+    }
+
+    private Logger log = null;
+
+    /**
+     * This constructor was added to allow the re-use of parsers.
+     * The normal constructor takes a single argument which
+     * an InputStream. This simply creates a re-usable parser
+     * object, we satisfy the requirement of an InputStream
+     * by using a newline character as an input stream.
+     */
+    public StandardParser( RuntimeServices rs)
+    {
+        /*
+         * need to call the CTOR first thing.
+         */
+
+        this(   new VelocityCharStream(
+                new ByteArrayInputStream("\u005cn".getBytes()), 1, 1 ));
+
+        /*
+         * then initialize logger
+         */
+
+         log = rs.getLog("parser");
+
+
+        /*
+         * now setup a VCS for later use
+         */
+        velcharstream = new VelocityCharStream(
+                new ByteArrayInputStream("\u005cn".getBytes()), 1, 1 );
+
+
+        strictEscape =
+            rs.getBoolean(RuntimeConstants.RUNTIME_REFERENCES_STRICT_ESCAPE, false);
+
+        hyphenAllowedInIdentifiers =
+            rs.getBoolean(RuntimeConstants.PARSER_HYPHEN_ALLOWED, false);
+
+        /*
+         *  and save the RuntimeServices
+         */
+        rsvc = rs;
+
+        /*
+         * then initialize customizable characters
+         */
+         dollar   = '$';
+         hash     = '#';
+         at       = '@';
+         asterisk = '*';
+    }
+
+    /**
+     * This was also added to allow parsers to be
+     * re-usable. Normal JavaCC use entails passing an
+     * input stream to the constructor and the parsing
+     * process is carried out once. We want to be able
+     * to re-use parsers: we do this by adding this
+     * method and re-initializing the lexer with
+     * the new stream that we want parsed.
+     */
+    @Override
+    public SimpleNode parse( Reader reader, Template template )
+        throws ParseException
+    {
+        SimpleNode sn = null;
+
+        currentTemplate = template;
+
+        try
+        {
+            token_source.clearStateVars();
+
+            /*
+             *  reinitialize the VelocityCharStream
+             *  with the new reader
+             */
+            velcharstream.ReInit( reader, 1, 1 );
+
+            /*
+             * now reinit the Parser with this CharStream
+             */
+            ReInit( velcharstream  );
+
+            /*
+             *  do that voodoo...
+             */
+            sn = process();
+        }
+        catch (MacroParseException mee)
+        {
+            /*
+             *  thrown by the Macro class when something is amiss in the
+             *  Macro specification
+             */
+            log.error("{}: {}", template.getName(), mee.getMessage(), mee);
+            throw mee;
+        }
+        catch (ParseException pe)
+        {
+            log.error("{}: {}", currentTemplate.getName(), pe.getMessage());
+            throw new TemplateParseException (pe.currentToken,
+                                pe.expectedTokenSequences, pe.tokenImage, currentTemplate.getName());
+                }
+        catch (TokenMgrError tme)
+        {
+            throw new ParseException("Lexical error: " + tme.toString());
+        }
+        catch (Exception e)
+        {
+            String msg = template.getName() + ": " + e.getMessage();
+            log.error(msg, e);
+            throw new VelocityException(msg, e, getRuntimeServices().getLogContext().getStackTrace());
+        }
+
+        currentTemplate = null;
+
+        return sn;
+    }
+
+    /**
+     *  This method gets a Directive from the directives Hashtable
+     */
+    @Override
+    public Directive getDirective(String directive)
+    {
+        return (Directive) rsvc.getDirective(directive);
+    }
+
+    /**
+     *  This method finds out of the directive exists in the directives Map.
+     */
+    @Override
+    public boolean isDirective(String directive)
+    {
+        return rsvc.getDirective(directive) != null;
+    }
+
+
+    /**
+     * Produces a processed output for an escaped control or
+     * pluggable directive
+     */
+    private String escapedDirective( String strImage )
+    {
+        int iLast = strImage.lastIndexOf("\u005c\u005c");
+
+        String strDirective = strImage.substring(iLast + 1);
+
+        boolean bRecognizedDirective = false;
+
+        // we don't have to call substring method all the time in this method
+        String dirTag = strDirective.substring(1);
+        if (dirTag.charAt(0) == '{')
+        {
+            dirTag = dirTag.substring(1, dirTag.length() - 1);
+        }
+
+        /*
+         *  If this is a predefined derective or if we detect
+         *  a macro definition (this is aproximate at best) then
+         *  we absorb the forward slash.  If in strict reference
+         *  mode then we always absord the forward slash regardless
+         *  if the derective is defined or not.
+         */
+
+        if (strictEscape
+             || isDirective(dirTag)
+             || macroNames.containsKey(dirTag)
+             || rsvc.isVelocimacro(dirTag, currentTemplate))
+        {
+            bRecognizedDirective = true;
+        }
+        else
+        {
+            /* order for speed? */
+
+            if ( dirTag.equals("if")
+                || dirTag.equals("end")
+                || dirTag.equals("set")
+                || dirTag.equals("else")
+                || dirTag.equals("elseif")
+            )
+            {
+                bRecognizedDirective = true;
+            }
+        }
+
+        /*
+         *  if so, make the proper prefix string (let the escapes do their thing..)
+         *  otherwise, just return what it is..
+         */
+
+        if (bRecognizedDirective)
+            return ( strImage.substring(0,iLast/2) + strDirective);
+        else
+            return ( strImage );
+    }
+
+    /**
+     * Check whether there is a left parenthesis with leading optional
+     * whitespaces. This method is used in the semantic look ahead of
+     * Directive method. This is done in code instead of as a production
+     * for simplicity and efficiency.
+     */
+    private boolean isLeftParenthesis()
+    {
+        char c;
+        int no = 0;
+        try {
+            while(true)
+            {
+                /**
+                 * Read a character
+                 */
+                c = velcharstream.readChar();
+                no++;
+                if (c == '(')
+                {
+                    return true;
+                }
+                /**
+                 * if not a white space return
+                 */
+                else if (c != ' ' && c != '\u005cn' && c != '\u005cr' && c != '\u005ct')
+                {
+                    return false;
+                }
+            }
+        }
+        catch(IOException e)
+        {
+        }
+        finally
+        {
+            /**
+             * Backup the stream to the initial state
+             */
+            velcharstream.backup(no);
+        }
+        return false;
+    }
+
+    /**
+     * Check whether there is a right parenthesis with leading optional
+     * whitespaces. This method is used in the semantic look ahead of
+     * Directive method. This is done in code instead of as a production
+     * for simplicity and efficiency.
+     */
+    private boolean isRightParenthesis()
+    {
+        char c;
+        int no = -1;
+        try {
+            while(true)
+            {
+                /**
+                 * Read a character
+                 */
+                 if (no == -1)
+                 {
+                     switch (getToken(1).kind)
+                     {
+                        case RPAREN:
+                            return true;
+                        case WHITESPACE:
+                        case NEWLINE:
+                            no = 0;
+                            break;
+                        default:
+                            return false;
+                     }
+                 }
+                c = velcharstream.readChar();
+                no++;
+                if (c == ')')
+                {
+                    return true;
+                }
+                /**
+                 * if not a white space return
+                 */
+                else if (c != ' ' && c != '\u005cn' && c != '\u005cr' && c != '\u005ct')
+                {
+                    return false;
+                }
+            }
+        }
+        catch(IOException e)
+        {
+        }
+        finally
+        {
+            /**
+             * Backup the stream to the initial state
+             */
+            if (no > 0) velcharstream.backup(no);
+        }
+        return false;
+    }
+
+    /**
+     * We use this method in a lookahead to determine if we are in a macro
+     * default value assignment.  The standard lookahead is not smart enough.
+     * here we look for the equals after the reference.
+     */
+    private boolean isAssignment()
+    {
+       // Basically if the last character read was not '$' then false
+       if (token_source.getCurrentLexicalState() != REFERENCE) return false;
+
+       char c = ' ';
+       int backup = 0;
+       try
+       {
+           // Read through any white space
+           while(Character.isWhitespace(c))
+           {
+                c = velcharstream.readChar();
+                backup++;
+           }
+
+           // This is what we are ultimately looking for
+           if (c != '=') return false;
+       }
+       catch (IOException e)
+       {
+       }
+       finally
+       {
+           velcharstream.backup(backup);
+       }
+
+       return true;
+    }
+
+    @Override
+    public Template getCurrentTemplate()
+    {
+        return currentTemplate;
+    }
+
+    @Override
+    public void resetCurrentTemplate()
+    {
+        currentTemplate = null;
+    }
+
+    @Override
+    public char dollar()
+    {
+        return dollar;
+    }
+
+    @Override
+    public char hash()
+    {
+        return hash;
+    }
+
+    @Override
+    public char at()
+    {
+        return at;
+    }
+
+    @Override
+    public char asterisk()
+    {
+        return asterisk;
+    }
+
+    private char dollar = '$';
+    private char hash = '#';
+    private char at = '@';
+    private char asterisk = '*';
+
+/**
+ * This method is what starts the whole parsing
+ * process. After the parsing is complete and
+ * the template has been turned into an AST,
+ * this method returns the root of AST which
+ * can subsequently be traversed by a visitor
+ * which implements the ParserVisitor interface
+ * which is generated automatically by JavaCC
+ */
+  final public SimpleNode process() throws ParseException {
+ /*@bgen(jjtree) process */
+    ASTprocess jjtn000 = new ASTprocess(this, JJTPROCESS);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);boolean afterNewline = true;
+    try {
+      label_1:
+      while (true) {
+        if (getToken(1).kind != EOF) {
+          ;
+        } else {
+          break label_1;
+        }
+        afterNewline = Statement(afterNewline);
+      }
+      jj_consume_token(0);
+     jjtree.closeNodeScope(jjtn000, true);
+     jjtc000 = false;
+     {if (true) return jjtn000;}
+    } catch (Throwable jjte000) {
+     if (jjtc000) {
+       jjtree.clearNodeScope(jjtn000);
+       jjtc000 = false;
+     } else {
+       jjtree.popNode();
+     }
+     if (jjte000 instanceof RuntimeException) {
+       {if (true) throw (RuntimeException)jjte000;}
+     }
+     if (jjte000 instanceof ParseException) {
+       {if (true) throw (ParseException)jjte000;}
+     }
+     {if (true) throw (Error)jjte000;}
+    } finally {
+     if (jjtc000) {
+       jjtree.closeNodeScope(jjtn000, true);
+     }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * These are the types of statements that
+ * are acceptable in Velocity templates.
+ */
+  final public boolean Statement(boolean afterNewline) throws ParseException {
+    if (getToken(1).kind == IF_DIRECTIVE || afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == IF_DIRECTIVE) {
+      afterNewline = IfStatement(afterNewline);
+                                                                                                                                                                                       {if (true) return afterNewline;}
+    } else if (jj_2_1(2)) {
+      Reference();
+                               {if (true) return false;}
+    } else if (jj_2_2(2)) {
+      afterNewline = Comment();
+                                            {if (true) return afterNewline;}
+    } else {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case TEXTBLOCK:
+        Textblock();
+                  {if (true) return false;}
+        break;
+      default:
+        jj_la1[1] = jj_gen;
+        if (getToken(1).kind == SET_DIRECTIVE || afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == SET_DIRECTIVE) {
+          afterNewline = SetDirective(afterNewline);
+                                                                                                                                                                                          {if (true) return afterNewline;}
+        } else {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case ESCAPE_DIRECTIVE:
+            EscapedDirective();
+                         {if (true) return false;}
+            break;
+          case DOUBLE_ESCAPE:
+            Escape();
+               {if (true) return false;}
+            break;
+          default:
+            jj_la1[2] = jj_gen;
+            if (getToken(1).kind == WORD || getToken(1).kind == BRACKETED_WORD || afterNewline && getToken(1).kind == WHITESPACE && ( getToken(2).kind == WORD || getToken(2).kind == BRACKETED_WORD )) {
+              afterNewline = Directive(afterNewline);
+                                                                                                                                                                                                                                                     {if (true) return afterNewline;}
+            } else {
+              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+              case LONE_SYMBOL:
+              case PIPE:
+              case LPAREN:
+              case RPAREN:
+              case STRING_LITERAL:
+              case INTEGER_LITERAL:
+              case FLOATING_POINT_LITERAL:
+              case DOT:
+              case LCURLY:
+              case RCURLY:
+              case ESCAPE:
+              case TEXT:
+              case EMPTY_INDEX:
+                afterNewline = Text();
+                            {if (true) return afterNewline;}
+                break;
+              case NEWLINE:
+      ASTText jjtn001 = new ASTText(this, JJTTEXT);
+      boolean jjtc001 = true;
+      jjtree.openNodeScope(jjtn001);
+                try {
+                  jj_consume_token(NEWLINE);
+                } finally {
+      if (jjtc001) {
+        jjtree.closeNodeScope(jjtn001, true);
+      }
+                }
+                        {if (true) return true;}
+                break;
+              case INLINE_TEXT:
+      ASTText jjtn002 = new ASTText(this, JJTTEXT);
+      boolean jjtc002 = true;
+      jjtree.openNodeScope(jjtn002);
+                try {
+                  jj_consume_token(INLINE_TEXT);
+                        afterNewline = false;
+                  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                  case TEXT:
+                    jj_consume_token(TEXT);
+                                                              afterNewline = true;
+                    break;
+                  default:
+                    jj_la1[0] = jj_gen;
+                    ;
+                  }
+                } finally {
+      if (jjtc002) {
+        jjtree.closeNodeScope(jjtn002, true);
+      }
+                }
+                                                                                                 {if (true) return afterNewline;}
+                break;
+              case WHITESPACE:
+      ASTText jjtn003 = new ASTText(this, JJTTEXT);
+      boolean jjtc003 = true;
+      jjtree.openNodeScope(jjtn003);
+                try {
+                  jj_consume_token(WHITESPACE);
+                } finally {
+      if (jjtc003) {
+        jjtree.closeNodeScope(jjtn003, true);
+      }
+                }
+                           {if (true) return false;}
+                break;
+              case SUFFIX:
+      ASTText jjtn004 = new ASTText(this, JJTTEXT);
+      boolean jjtc004 = true;
+      jjtree.openNodeScope(jjtn004);
+                try {
+                  jj_consume_token(SUFFIX);
+                } finally {
+      if (jjtc004) {
+        jjtree.closeNodeScope(jjtn004, true);
+      }
+                }
+                       {if (true) return true;}
+                break;
+              default:
+                jj_la1[3] = jj_gen;
+                if (jj_2_3(2)) {
+                  EndingZeroWidthWhitespace();
+                                               {if (true) return afterNewline;}
+                } else {
+                  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                  case LOGICAL_OR_2:
+      ASTText jjtn005 = new ASTText(this, JJTTEXT);
+      boolean jjtc005 = true;
+      jjtree.openNodeScope(jjtn005);
+                    try {
+                      jj_consume_token(LOGICAL_OR_2);
+                    } finally {
+      if (jjtc005) {
+        jjtree.closeNodeScope(jjtn005, true);
+      }
+                    }
+                             {if (true) return afterNewline;}
+                    break;
+                  case ZERO_WIDTH_WHITESPACE:
+      ASTText jjtn006 = new ASTText(this, JJTTEXT);
+      boolean jjtc006 = true;
+      jjtree.openNodeScope(jjtn006);
+                    try {
+                      jj_consume_token(ZERO_WIDTH_WHITESPACE);
+                    } finally {
+      if (jjtc006) {
+        jjtree.closeNodeScope(jjtn006, true);
+      }
+                    }
+                                      afterNewline = !afterNewline; {if (true) return false;}
+                    break;
+                  default:
+                    jj_la1[4] = jj_gen;
+                    jj_consume_token(-1);
+                    throw new ParseException();
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void EndingZeroWidthWhitespace() throws ParseException {
+    jj_consume_token(ZERO_WIDTH_WHITESPACE);
+    jj_consume_token(0);
+
+  }
+
+/**
+ *  used to separate the notion of a valid directive that has been
+ *  escaped, versus something that looks like a directive and
+ *  is just schmoo.  This is important to do as a separate production
+ *  that creates a node, because we want this, in either case, to stop
+ *  the further parsing of the Directive() tree.
+ */
+  final public void EscapedDirective() throws ParseException {
+                           /*@bgen(jjtree) EscapedDirective */
+  ASTEscapedDirective jjtn000 = new ASTEscapedDirective(this, JJTESCAPEDDIRECTIVE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+        Token t = null;
+      t = jj_consume_token(ESCAPE_DIRECTIVE);
+      jjtree.closeNodeScope(jjtn000, true);
+      jjtc000 = false;
+        /*
+         *  churn and burn..
+         */
+        t.image = escapedDirective( t.image );
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ *  Used to catch and process escape sequences in grammatical constructs
+ *  as escapes outside of VTL are just characters.  Right now we have both
+ *  this and the EscapeDirective() construction because in the EscapeDirective()
+ *  case, we want to suck in the #&lt;directive&gt; and here we don't.  We just want
+ *  the escapes to render correctly
+ */
+  final public void Escape() throws ParseException {
+                 /*@bgen(jjtree) Escape */
+  ASTEscape jjtn000 = new ASTEscape(this, JJTESCAPE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+        Token t = null;
+        int count = 0;
+        boolean control = false;
+      label_2:
+      while (true) {
+        t = jj_consume_token(DOUBLE_ESCAPE);
+        count++;
+        if (jj_2_4(2)) {
+          ;
+        } else {
+          break label_2;
+        }
+      }
+      jjtree.closeNodeScope(jjtn000, true);
+      jjtc000 = false;
+        /*
+         * first, check to see if we have a control directive
+         */
+        switch(t.next.kind ) {
+            case IF_DIRECTIVE :
+            case ELSE :
+            case ELSEIF :
+            case END :
+                control = true;
+                break;
+        }
+
+        /*
+         * if that failed, lets lookahead to see if we matched a PD or a VM
+         */
+        String nTag = t.next.image.substring(1);
+        if (strictEscape
+            || isDirective(nTag)
+            || macroNames.containsKey(nTag)
+            || rsvc.isVelocimacro(nTag, currentTemplate))
+        {
+            control = true;
+        }
+
+        jjtn000.val = "";
+
+        for( int i = 0; i < count; i++)
+            jjtn000.val += ( control ? "\u005c\u005c" : "\u005c\u005c\u005c\u005c");
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+  final public boolean Comment() throws ParseException {
+                     /*@bgen(jjtree) Comment */
+  ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case SINGLE_LINE_COMMENT_START:
+        jj_consume_token(SINGLE_LINE_COMMENT_START);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case SINGLE_LINE_COMMENT:
+          jj_consume_token(SINGLE_LINE_COMMENT);
+          break;
+        default:
+          jj_la1[5] = jj_gen;
+          ;
+        }
+                                                                  jjtree.closeNodeScope(jjtn000, true);
+                                                                  jjtc000 = false;
+                                                                  {if (true) return true;}
+        break;
+      case MULTI_LINE_COMMENT:
+        jj_consume_token(MULTI_LINE_COMMENT);
+                           jjtree.closeNodeScope(jjtn000, true);
+                           jjtc000 = false;
+                           {if (true) return false;}
+        break;
+      case FORMAL_COMMENT:
+        jj_consume_token(FORMAL_COMMENT);
+                       jjtree.closeNodeScope(jjtn000, true);
+                       jjtc000 = false;
+                       {if (true) return false;}
+        break;
+      default:
+        jj_la1[6] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+          if (jjtc000) {
+            jjtree.closeNodeScope(jjtn000, true);
+          }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void Textblock() throws ParseException {
+                    /*@bgen(jjtree) Textblock */
+  ASTTextblock jjtn000 = new ASTTextblock(this, JJTTEXTBLOCK);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(TEXTBLOCK);
+    } finally {
+     if (jjtc000) {
+       jjtree.closeNodeScope(jjtn000, true);
+     }
+    }
+  }
+
+  final public void FloatingPointLiteral() throws ParseException {
+                               /*@bgen(jjtree) FloatingPointLiteral */
+  ASTFloatingPointLiteral jjtn000 = new ASTFloatingPointLiteral(this, JJTFLOATINGPOINTLITERAL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(FLOATING_POINT_LITERAL);
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+  final public void IntegerLiteral() throws ParseException {
+                         /*@bgen(jjtree) IntegerLiteral */
+  ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(this, JJTINTEGERLITERAL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(INTEGER_LITERAL);
+    } finally {
+       if (jjtc000) {
+         jjtree.closeNodeScope(jjtn000, true);
+       }
+    }
+  }
+
+  final public void StringLiteral() throws ParseException {
+                        /*@bgen(jjtree) StringLiteral */
+  ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(STRING_LITERAL);
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ * This method corresponds to variable
+ * references in Velocity templates.
+ * The following are examples of variable
+ * references that may be found in a
+ * template:
+ *
+ * $foo
+ * $bar
+ *
+ */
+  final public void Identifier() throws ParseException {
+                     /*@bgen(jjtree) Identifier */
+  ASTIdentifier jjtn000 = new ASTIdentifier(this, JJTIDENTIFIER);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENTIFIER:
+        jj_consume_token(IDENTIFIER);
+        break;
+      case OLD_IDENTIFIER:
+        jj_consume_token(OLD_IDENTIFIER);
+        break;
+      default:
+        jj_la1[7] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+  final public void Word() throws ParseException {
+               /*@bgen(jjtree) Word */
+  ASTWord jjtn000 = new ASTWord(this, JJTWORD);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(WORD);
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ *   Supports the arguments for the Pluggable Directives
+ */
+  final public int DirectiveArg() throws ParseException {
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case IDENTIFIER:
+    case OLD_IDENTIFIER:
+    case LCURLY:
+      Reference();
+        {if (true) return ParserTreeConstants.JJTREFERENCE;}
+      break;
+    case WORD:
+      Word();
+        {if (true) return ParserTreeConstants.JJTWORD;}
+      break;
+    case STRING_LITERAL:
+      StringLiteral();
+        {if (true) return ParserTreeConstants.JJTSTRINGLITERAL;}
+      break;
+    case INTEGER_LITERAL:
+      IntegerLiteral();
+        {if (true) return ParserTreeConstants.JJTINTEGERLITERAL;}
+      break;
+    default:
+      jj_la1[8] = jj_gen;
+      if (jj_2_5(2147483647)) {
+        IntegerRange();
+        {if (true) return ParserTreeConstants.JJTINTEGERRANGE;}
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case FLOATING_POINT_LITERAL:
+          FloatingPointLiteral();
+        {if (true) return ParserTreeConstants.JJTFLOATINGPOINTLITERAL;}
+          break;
+        case LEFT_CURLEY:
+          Map();
+        {if (true) return ParserTreeConstants.JJTMAP;}
+          break;
+        case LBRACKET:
+          ObjectArray();
+        {if (true) return ParserTreeConstants.JJTOBJECTARRAY;}
+          break;
+        case TRUE:
+          True();
+        {if (true) return ParserTreeConstants.JJTTRUE;}
+          break;
+        case FALSE:
+          False();
+        {if (true) return ParserTreeConstants.JJTFALSE;}
+          break;
+        default:
+          jj_la1[9] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public void DirectiveAssign() throws ParseException {
+                          /*@bgen(jjtree) DirectiveAssign */
+  ASTDirectiveAssign jjtn000 = new ASTDirectiveAssign(this, JJTDIRECTIVEASSIGN);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      Reference();
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ *   Supports the Pluggable Directives
+ *     #foo( arg+ )
+ * @return true if ends with a newline
+ */
+  final public boolean Directive(boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) Directive */
+    ASTDirective jjtn000 = new ASTDirective(this, JJTDIRECTIVE);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);Token id = null, t = null, u = null, end = null, _else = null;
+    int argType;
+    int argPos = 0;
+    Directive d;
+    int directiveType;
+    boolean isVM = false;
+    boolean isMacro = false;
+    ArrayList argtypes = new ArrayList(4);
+    String blockPrefix = "";
+    ASTBlock block = null, elseBlock = null;
+    boolean hasParentheses = false;
+    boolean newlineAtStart = afterNewline;
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        t = jj_consume_token(WHITESPACE);
+          // only possible if not after new line
+          jjtn000.setPrefix(t.image);
+          t = null;
+        break;
+      default:
+        jj_la1[10] = jj_gen;
+        ;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WORD:
+        id = jj_consume_token(WORD);
+        break;
+      case BRACKETED_WORD:
+        id = jj_consume_token(BRACKETED_WORD);
+        break;
+      default:
+        jj_la1[11] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+        String directiveName;
+        int p = id.image.lastIndexOf(hash);
+        if (id.kind == StandardParserConstants.BRACKETED_WORD)
+        {
+            directiveName = id.image.substring(p + 2, id.image.length() - 1);
+        }
+        else
+        {
+            directiveName = id.image.substring(p + 1);
+        }
+
+        d = getDirective(directiveName);
+
+        /*
+         *  Velocimacro support : if the directive is macro directive
+         *   then set the flag so after the block parsing, we add the VM
+         *   right then. (So available if used w/in the current template )
+         */
+
+        if (directiveName.equals("macro"))
+        {
+             isMacro = true;
+        }
+
+        /*
+         * set the directive name from here.  No reason for the thing to know
+         * about parser tokens
+         */
+
+        jjtn000.setDirectiveName(directiveName);
+
+        if ( d == null)
+        {
+            if( directiveName.charAt(0) == at )
+            {
+                // block macro call of type: #@foobar($arg1 $arg2) astBody #end
+                directiveType = Directive.BLOCK;
+            }
+            else
+            {
+                /*
+                 *  if null, then not a real directive, but maybe a Velocimacro
+                 */
+                isVM = rsvc.isVelocimacro(directiveName, currentTemplate);
+
+                directiveType = Directive.LINE;
+            }
+        }
+        else
+        {
+            directiveType = d.getType();
+        }
+
+        /*
+         *  now, switch us out of PRE_DIRECTIVE
+         */
+
+        token_source.switchTo(DIRECTIVE);
+        argPos = 0;
+      if (isLeftParenthesis()) {
+        label_3:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+          case NEWLINE:
+            ;
+            break;
+          default:
+            jj_la1[12] = jj_gen;
+            break label_3;
+          }
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+            jj_consume_token(WHITESPACE);
+            break;
+          case NEWLINE:
+            jj_consume_token(NEWLINE);
+            break;
+          default:
+            jj_la1[13] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+        jj_consume_token(LPAREN);
+        label_4:
+        while (true) {
+          if (!isRightParenthesis()) {
+            ;
+          } else {
+            break label_4;
+          }
+          label_5:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case WHITESPACE:
+            case NEWLINE:
+              ;
+              break;
+            default:
+              jj_la1[14] = jj_gen;
+              break label_5;
+            }
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case WHITESPACE:
+              jj_consume_token(WHITESPACE);
+              break;
+            case NEWLINE:
+              jj_consume_token(NEWLINE);
+              break;
+            default:
+              jj_la1[15] = jj_gen;
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+          }
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case COMMA:
+            jj_consume_token(COMMA);
+            label_6:
+            while (true) {
+              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+              case WHITESPACE:
+              case NEWLINE:
+                ;
+                break;
+              default:
+                jj_la1[16] = jj_gen;
+                break label_6;
+              }
+              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+              case WHITESPACE:
+                jj_consume_token(WHITESPACE);
+                break;
+              case NEWLINE:
+                jj_consume_token(NEWLINE);
+                break;
+              default:
+                jj_la1[17] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
+              }
+            }
+            break;
+          default:
+            jj_la1[18] = jj_gen;
+            ;
+          }
+          if (jj_2_6(1)) {
+            if (isMacro && isAssignment()) {
+              DirectiveAssign();
+              label_7:
+              while (true) {
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                case WHITESPACE:
+                case NEWLINE:
+                  ;
+                  break;
+                default:
+                  jj_la1[19] = jj_gen;
+                  break label_7;
+                }
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                case WHITESPACE:
+                  jj_consume_token(WHITESPACE);
+                  break;
+                case NEWLINE:
+                  jj_consume_token(NEWLINE);
+                  break;
+                default:
+                  jj_la1[20] = jj_gen;
+                  jj_consume_token(-1);
+                  throw new ParseException();
+                }
+              }
+              jj_consume_token(EQUALS);
+              label_8:
+              while (true) {
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                case WHITESPACE:
+                case NEWLINE:
+                  ;
+                  break;
+                default:
+                  jj_la1[21] = jj_gen;
+                  break label_8;
+                }
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                case WHITESPACE:
+                  jj_consume_token(WHITESPACE);
+                  break;
+                case NEWLINE:
+                  jj_consume_token(NEWLINE);
+                  break;
+                default:
+                  jj_la1[22] = jj_gen;
+                  jj_consume_token(-1);
+                  throw new ParseException();
+                }
+              }
+                  argtypes.add(ParserTreeConstants.JJTDIRECTIVEASSIGN);
+            } else {
+              ;
+            }
+            if (!isRightParenthesis()) {
+
+            } else {
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+            argType = DirectiveArg();
+                  argtypes.add(argType);
+                  if (d == null && argType == ParserTreeConstants.JJTWORD)
+                  {
+                      if (isVM)
+                      {
+                          {if (true) throw new MacroParseException("Invalid argument "
+                              + (argPos+1) + " in macro call " + id.image, currentTemplate.getName(), id);}
+                      }
+                  }
+                  argPos++;
+          } else {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case SINGLE_LINE_COMMENT_START:
+                if (!isMacro)
+                {
+                    // We only allow line comments in macro definitions for now
+                    {if (true) throw new MacroParseException("A Line comment is not allowed in " + id.image
+                        + " arguments", currentTemplate.getName(), id);}
+                }
+              jj_consume_token(SINGLE_LINE_COMMENT_START);
+              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+              case SINGLE_LINE_COMMENT:
+                jj_consume_token(SINGLE_LINE_COMMENT);
+                break;
+              default:
+                jj_la1[23] = jj_gen;
+                ;
+              }
+              break;
+            default:
+              jj_la1[24] = jj_gen;
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+          }
+        }
+        label_9:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+          case NEWLINE:
+            ;
+            break;
+          default:
+            jj_la1[25] = jj_gen;
+            break label_9;
+          }
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+            jj_consume_token(WHITESPACE);
+            break;
+          case NEWLINE:
+            jj_consume_token(NEWLINE);
+            break;
+          default:
+            jj_la1[26] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+        jj_consume_token(RPAREN);
+          hasParentheses = true;
+      } else {
+          token_source.stateStackPop();
+      }
+      afterNewline = false;
+      if (jj_2_7(2) && (directiveType != Directive.LINE || newlineAtStart && rsvc.getSpaceGobbling() != SpaceGobbling.BC || rsvc.getSpaceGobbling() == SpaceGobbling.BC && hasParentheses || d != null && (d instanceof Include || d instanceof Parse))) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          t = jj_consume_token(WHITESPACE);
+          break;
+        default:
+          jj_la1[27] = jj_gen;
+          ;
+        }
+        u = jj_consume_token(NEWLINE);
+          afterNewline = true;
+          if (directiveType == Directive.LINE)
+          {
+              jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+          }
+          else
+          {
+              blockPrefix = (t == null ? u.image : t.image + u.image);
+          }
+          t = u = null;
+      } else {
+        ;
+      }
+        if (d != null)
+        {
+            d.checkArgs(argtypes, id, currentTemplate.getName());
+        }
+        if (directiveType  == Directive.LINE)
+        {
+            {if (true) return afterNewline;}
+        }
+        ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+        boolean jjtc001 = true;
+        jjtree.openNodeScope(jjtn001);
+      try {
+        label_10:
+        while (true) {
+          if (getToken(1).kind != END && getToken(1).kind != ELSE && ( !afterNewline || getToken(1).kind != WHITESPACE || getToken(2).kind != END && getToken(2).kind != ELSE )) {
+            ;
+          } else {
+            break label_10;
+          }
+          afterNewline = Statement(afterNewline);
+        }
+          jjtree.closeNodeScope(jjtn001, true);
+          jjtc001 = false;
+            block = jjtn001;
+            block.setPrefix(blockPrefix);
+            blockPrefix = "";
+      } catch (Throwable jjte001) {
+        if (jjtc001) {
+          jjtree.clearNodeScope(jjtn001);
+          jjtc001 = false;
+        } else {
+          jjtree.popNode();
+        }
+        if (jjte001 instanceof RuntimeException) {
+          {if (true) throw (RuntimeException)jjte001;}
+        }
+        if (jjte001 instanceof ParseException) {
+          {if (true) throw (ParseException)jjte001;}
+        }
+        {if (true) throw (Error)jjte001;}
+      } finally {
+        if (jjtc001) {
+          jjtree.closeNodeScope(jjtn001, true);
+        }
+      }
+      if (jj_2_8(1) && (afterNewline)) {
+        t = jj_consume_token(WHITESPACE);
+          block.setPostfix(t.image);
+          t = null;
+      } else {
+        ;
+      }
+      if (d != null && (d instanceof Foreach) && getToken(1).kind == ELSE) {
+        _else = jj_consume_token(ELSE);
+            ASTBlock jjtn002 = new ASTBlock(this, JJTBLOCK);
+            boolean jjtc002 = true;
+            jjtree.openNodeScope(jjtn002);
+        try {
+          if (jj_2_9(2)) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case WHITESPACE:
+              t = jj_consume_token(WHITESPACE);
+              break;
+            default:
+              jj_la1[28] = jj_gen;
+              ;
+            }
+            u = jj_consume_token(NEWLINE);
+                  jjtn002.setPrefix(t == null ? u.image : t.image + u.image);
+                  t = u = null;
+                  afterNewline = true;
+          } else {
+            ;
+          }
+          label_11:
+          while (true) {
+            if (getToken(1).kind != END && (!afterNewline || getToken(1).kind != WHITESPACE || getToken(2).kind != END)) {
+              ;
+            } else {
+              break label_11;
+            }
+            afterNewline = Statement(afterNewline);
+          }
+              jjtree.closeNodeScope(jjtn002, true);
+              jjtc002 = false;
+                elseBlock = jjtn002;
+        } catch (Throwable jjte002) {
+            if (jjtc002) {
+              jjtree.clearNodeScope(jjtn002);
+              jjtc002 = false;
+            } else {
+              jjtree.popNode();
+            }
+            if (jjte002 instanceof RuntimeException) {
+              {if (true) throw (RuntimeException)jjte002;}
+            }
+            if (jjte002 instanceof ParseException) {
+              {if (true) throw (ParseException)jjte002;}
+            }
+            {if (true) throw (Error)jjte002;}
+        } finally {
+            if (jjtc002) {
+              jjtree.closeNodeScope(jjtn002, true);
+            }
+        }
+              int pos = _else.image.lastIndexOf(hash);
+              if (pos > 0)
+              {
+                  block.setMorePostfix(_else.image.substring(0, pos));
+              }
+              block = elseBlock;
+      } else {
+        ;
+      }
+      if (jj_2_10(1) && (afterNewline)) {
+        t = jj_consume_token(WHITESPACE);
+          block.setPostfix(t.image);
+          t = null;
+          afterNewline = false;
+      } else {
+        ;
+      }
+      end = jj_consume_token(END);
+        afterNewline = false;
+      if (jj_2_11(2) && (newlineAtStart || rsvc.getSpaceGobbling() == SpaceGobbling.BC)) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          t = jj_consume_token(WHITESPACE);
+          break;
+        default:
+          jj_la1[29] = jj_gen;
+          ;
+        }
+        u = jj_consume_token(NEWLINE);
+            jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+            t = u = null;
+            afterNewline = true;
+      } else {
+        ;
+      }
+          int pos = end.image.lastIndexOf(hash);
+          if (pos > 0)
+          {
+              block.setMorePostfix(end.image.substring(0, pos));
+          }
+      jjtree.closeNodeScope(jjtn000, true);
+      jjtc000 = false;
+        /*
+         *  VM : if we are processing a #macro directive, we need to
+         *     process the block.  In truth, I can just register the name
+         *     and do the work later when init-ing.  That would work
+         *     as long as things were always defined before use.  This way
+         *     we don't have to worry about forward references and such...
+         */
+        if (isMacro)
+        {
+            // Add the macro name so that we can peform escape processing
+            // on defined macros
+            String macroName = jjtn000.jjtGetChild(0).getFirstToken().image;
+            macroNames.put(macroName, macroName);
+        }
+        if (d != null)
+        {
+            d.checkArgs(argtypes, id, currentTemplate.getName());
+        }
+        /*
+         *  VM : end
+         */
+        {if (true) return afterNewline;}
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ * for creating a map in a #set
+ *
+ *  #set($foo = {$foo : $bar, $blargh : $thingy})
+ */
+  final public void Map() throws ParseException {
+              /*@bgen(jjtree) Map */
+  ASTMap jjtn000 = new ASTMap(this, JJTMAP);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(LEFT_CURLEY);
+      if (jj_2_12(2147483647)) {
+        Parameter();
+        jj_consume_token(COLON);
+        Parameter();
+        label_12:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case COMMA:
+            ;
+            break;
+          default:
+            jj_la1[30] = jj_gen;
+            break label_12;
+          }
+          jj_consume_token(COMMA);
+          Parameter();
+          jj_consume_token(COLON);
+          Parameter();
+        }
+      } else {
+        label_13:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+          case NEWLINE:
+            ;
+            break;
+          default:
+            jj_la1[31] = jj_gen;
+            break label_13;
+          }
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+            jj_consume_token(WHITESPACE);
+            break;
+          case NEWLINE:
+            jj_consume_token(NEWLINE);
+            break;
+          default:
+            jj_la1[32] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+        }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case RIGHT_CURLEY:
+        jj_consume_token(RIGHT_CURLEY);
+        break;
+      case RCURLY:
+        jj_consume_token(RCURLY);
+        break;
+      default:
+        jj_la1[33] = 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 RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+  final public void ObjectArray() throws ParseException {
+                      /*@bgen(jjtree) ObjectArray */
+  ASTObjectArray jjtn000 = new ASTObjectArray(this, JJTOBJECTARRAY);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(LBRACKET);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LBRACKET:
+      case LEFT_CURLEY:
+      case WHITESPACE:
+      case NEWLINE:
+      case STRING_LITERAL:
+      case TRUE:
+      case FALSE:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case IDENTIFIER:
+      case OLD_IDENTIFIER:
+      case LCURLY:
+        Parameter();
+        label_14:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case COMMA:
+            ;
+            break;
+          default:
+            jj_la1[34] = jj_gen;
+            break label_14;
+          }
+          jj_consume_token(COMMA);
+          Parameter();
+        }
+        break;
+      default:
+        jj_la1[35] = jj_gen;
+        ;
+      }
+      jj_consume_token(RBRACKET);
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ *  supports the [n..m] vector generator for use in
+ *  the #foreach() to generate measured ranges w/o
+ *  needing explicit support from the app/servlet
+ */
+  final public void IntegerRange() throws ParseException {
+                       /*@bgen(jjtree) IntegerRange */
+  ASTIntegerRange jjtn000 = new ASTIntegerRange(this, JJTINTEGERRANGE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(LBRACKET);
+      label_15:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[36] = jj_gen;
+          break label_15;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[37] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENTIFIER:
+      case OLD_IDENTIFIER:
+      case LCURLY:
+        Reference();
+        break;
+      case INTEGER_LITERAL:
+        IntegerLiteral();
+        break;
+      default:
+        jj_la1[38] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      label_16:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[39] = jj_gen;
+          break label_16;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[40] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      jj_consume_token(DOUBLEDOT);
+      label_17:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[41] = jj_gen;
+          break label_17;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[42] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENTIFIER:
+      case OLD_IDENTIFIER:
+      case LCURLY:
+        Reference();
+        break;
+      case INTEGER_LITERAL:
+        IntegerLiteral();
+        break;
+      default:
+        jj_la1[43] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      label_18:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[44] = jj_gen;
+          break label_18;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[45] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      jj_consume_token(RBRACKET);
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ * A Simplified parameter more suitable for an index position: $foo[$index]
+ */
+  final public void IndexParameter() throws ParseException {
+    label_19:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[46] = jj_gen;
+        break label_19;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[47] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    Expression();
+    label_20:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[48] = jj_gen;
+        break label_20;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[49] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+/**
+ * This method has yet to be fully implemented
+ * but will allow arbitrarily nested method
+ * calls
+ */
+  final public void Parameter() throws ParseException {
+    label_21:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[50] = jj_gen;
+        break label_21;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[51] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case STRING_LITERAL:
+      StringLiteral();
+      break;
+    case INTEGER_LITERAL:
+      IntegerLiteral();
+      break;
+    default:
+      jj_la1[52] = jj_gen;
+      if (jj_2_13(2147483647)) {
+        IntegerRange();
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case LEFT_CURLEY:
+          Map();
+          break;
+        case LBRACKET:
+          ObjectArray();
+          break;
+        case TRUE:
+          True();
+          break;
+        case FALSE:
+          False();
+          break;
+        case IDENTIFIER:
+        case OLD_IDENTIFIER:
+        case LCURLY:
+          Reference();
+          break;
+        case FLOATING_POINT_LITERAL:
+          FloatingPointLiteral();
+          break;
+        default:
+          jj_la1[53] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+    }
+    label_22:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[54] = jj_gen;
+        break label_22;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[55] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+/**
+ * This method has yet to be fully implemented
+ * but will allow arbitrarily nested method
+ * calls
+ */
+  final public void Method() throws ParseException {
+                 /*@bgen(jjtree) Method */
+  ASTMethod jjtn000 = new ASTMethod(this, JJTMETHOD);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      Identifier();
+      jj_consume_token(LPAREN);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LBRACKET:
+      case LEFT_CURLEY:
+      case LPAREN:
+      case WHITESPACE:
+      case NEWLINE:
+      case STRING_LITERAL:
+      case TRUE:
+      case FALSE:
+      case MINUS:
+      case LOGICAL_NOT:
+      case INTEGER_LITERAL:
+      case FLOATING_POINT_LITERAL:
+      case IDENTIFIER:
+      case OLD_IDENTIFIER:
+      case LCURLY:
+        Expression();
+        label_23:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case COMMA:
+            ;
+            break;
+          default:
+            jj_la1[56] = jj_gen;
+            break label_23;
+          }
+          jj_consume_token(COMMA);
+          Expression();
+        }
+        break;
+      default:
+        jj_la1[57] = jj_gen;
+        ;
+      }
+      jj_consume_token(REFMOD2_RPAREN);
+    } catch (Throwable jjte000) {
+     if (jjtc000) {
+       jjtree.clearNodeScope(jjtn000);
+       jjtc000 = false;
+     } else {
+       jjtree.popNode();
+     }
+     if (jjte000 instanceof RuntimeException) {
+       {if (true) throw (RuntimeException)jjte000;}
+     }
+     if (jjte000 instanceof ParseException) {
+       {if (true) throw (ParseException)jjte000;}
+     }
+     {if (true) throw (Error)jjte000;}
+    } finally {
+     if (jjtc000) {
+       jjtree.closeNodeScope(jjtn000, true);
+     }
+    }
+  }
+
+  final public void Index() throws ParseException {
+                /*@bgen(jjtree) Index */
+  ASTIndex jjtn000 = new ASTIndex(this, JJTINDEX);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(INDEX_LBRACKET);
+      IndexParameter();
+      jj_consume_token(INDEX_RBRACKET);
+    } catch (Throwable jjte000) {
+     if (jjtc000) {
+       jjtree.clearNodeScope(jjtn000);
+       jjtc000 = false;
+     } else {
+       jjtree.popNode();
+     }
+     if (jjte000 instanceof RuntimeException) {
+       {if (true) throw (RuntimeException)jjte000;}
+     }
+     if (jjte000 instanceof ParseException) {
+       {if (true) throw (ParseException)jjte000;}
+     }
+     {if (true) throw (Error)jjte000;}
+    } finally {
+     if (jjtc000) {
+       jjtree.closeNodeScope(jjtn000, true);
+     }
+    }
+  }
+
+  final public void Reference() throws ParseException {
+                    /*@bgen(jjtree) Reference */
+  ASTReference jjtn000 = new ASTReference(this, JJTREFERENCE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case IDENTIFIER:
+      case OLD_IDENTIFIER:
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IDENTIFIER:
+          jj_consume_token(IDENTIFIER);
+          break;
+        case OLD_IDENTIFIER:
+          jj_consume_token(OLD_IDENTIFIER);
+          break;
+        default:
+          jj_la1[58] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        label_24:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case INDEX_LBRACKET:
+            ;
+            break;
+          default:
+            jj_la1[59] = jj_gen;
+            break label_24;
+          }
+          Index();
+        }
+        label_25:
+        while (true) {
+          if (jj_2_14(2)) {
+            ;
+          } else {
+            break label_25;
+          }
+          jj_consume_token(DOT);
+          if (jj_2_15(3)) {
+            Method();
+          } else {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case IDENTIFIER:
+            case OLD_IDENTIFIER:
+              Identifier();
+              break;
+            default:
+              jj_la1[60] = jj_gen;
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+          }
+          label_26:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case INDEX_LBRACKET:
+              ;
+              break;
+            default:
+              jj_la1[61] = jj_gen;
+              break label_26;
+            }
+            Index();
+          }
+        }
+        break;
+      case LCURLY:
+        jj_consume_token(LCURLY);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case IDENTIFIER:
+          jj_consume_token(IDENTIFIER);
+          break;
+        case OLD_IDENTIFIER:
+          jj_consume_token(OLD_IDENTIFIER);
+          break;
+        default:
+          jj_la1[62] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        label_27:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case INDEX_LBRACKET:
+            ;
+            break;
+          default:
+            jj_la1[63] = jj_gen;
+            break label_27;
+          }
+          Index();
+        }
+        label_28:
+        while (true) {
+          if (jj_2_16(2)) {
+            ;
+          } else {
+            break label_28;
+          }
+          jj_consume_token(DOT);
+          if (jj_2_17(3)) {
+            Method();
+          } else {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case IDENTIFIER:
+            case OLD_IDENTIFIER:
+              Identifier();
+              break;
+            default:
+              jj_la1[64] = jj_gen;
+              jj_consume_token(-1);
+              throw new ParseException();
+            }
+          }
+          label_29:
+          while (true) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case INDEX_LBRACKET:
+              ;
+              break;
+            default:
+              jj_la1[65] = jj_gen;
+              break label_29;
+            }
+            Index();
+          }
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PIPE:
+          jj_consume_token(PIPE);
+          Expression();
+          break;
+        default:
+          jj_la1[66] = jj_gen;
+          ;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case RCURLY:
+          jj_consume_token(RCURLY);
+          break;
+        case RIGHT_CURLEY:
+          jj_consume_token(RIGHT_CURLEY);
+          break;
+        default:
+          jj_la1[67] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        break;
+      default:
+        jj_la1[68] = 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 RuntimeException) {
+          {if (true) throw (RuntimeException)jjte000;}
+        }
+        if (jjte000 instanceof ParseException) {
+          {if (true) throw (ParseException)jjte000;}
+        }
+        {if (true) throw (Error)jjte000;}
+    } finally {
+        if (jjtc000) {
+          jjtree.closeNodeScope(jjtn000, true);
+        }
+    }
+  }
+
+  final public void True() throws ParseException {
+               /*@bgen(jjtree) True */
+  ASTTrue jjtn000 = new ASTTrue(this, JJTTRUE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(TRUE);
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+  final public void False() throws ParseException {
+                /*@bgen(jjtree) False */
+  ASTFalse jjtn000 = new ASTFalse(this, JJTFALSE);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      jj_consume_token(FALSE);
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+  }
+
+/**
+ * This method is responsible for allowing
+ * all non-grammar text to pass through
+ * unscathed.
+ * @return true if last read token was a newline
+ */
+  final public boolean Text() throws ParseException {
+ /*@bgen(jjtree) Text */
+    ASTText jjtn000 = new ASTText(this, JJTTEXT);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);Token t = null;
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case TEXT:
+        jj_consume_token(TEXT);
+             jjtree.closeNodeScope(jjtn000, true);
+             jjtc000 = false;
+             {if (true) return true;}
+        break;
+      case DOT:
+        jj_consume_token(DOT);
+             jjtree.closeNodeScope(jjtn000, true);
+             jjtc000 = false;
+             {if (true) return false;}
+        break;
+      case RPAREN:
+        jj_consume_token(RPAREN);
+                jjtree.closeNodeScope(jjtn000, true);
+                jjtc000 = false;
+                {if (true) return false;}
+        break;
+      case LPAREN:
+        jj_consume_token(LPAREN);
+                jjtree.closeNodeScope(jjtn000, true);
+                jjtc000 = false;
+                {if (true) return false;}
+        break;
+      case INTEGER_LITERAL:
+        jj_consume_token(INTEGER_LITERAL);
+                         jjtree.closeNodeScope(jjtn000, true);
+                         jjtc000 = false;
+                         {if (true) return false;}
+        break;
+      case FLOATING_POINT_LITERAL:
+        jj_consume_token(FLOATING_POINT_LITERAL);
+                                jjtree.closeNodeScope(jjtn000, true);
+                                jjtc000 = false;
+                                {if (true) return false;}
+        break;
+      case STRING_LITERAL:
+        jj_consume_token(STRING_LITERAL);
+                        jjtree.closeNodeScope(jjtn000, true);
+                        jjtc000 = false;
+                        {if (true) return false;}
+        break;
+      case ESCAPE:
+        jj_consume_token(ESCAPE);
+                jjtree.closeNodeScope(jjtn000, true);
+                jjtc000 = false;
+                {if (true) return false;}
+        break;
+      case LCURLY:
+        jj_consume_token(LCURLY);
+                jjtree.closeNodeScope(jjtn000, true);
+                jjtc000 = false;
+                {if (true) return false;}
+        break;
+      case RCURLY:
+        jj_consume_token(RCURLY);
+                jjtree.closeNodeScope(jjtn000, true);
+                jjtc000 = false;
+                {if (true) return false;}
+        break;
+      case EMPTY_INDEX:
+        jj_consume_token(EMPTY_INDEX);
+                     jjtree.closeNodeScope(jjtn000, true);
+                     jjtc000 = false;
+                     {if (true) return false;}
+        break;
+      case PIPE:
+        jj_consume_token(PIPE);
+              jjtree.closeNodeScope(jjtn000, true);
+              jjtc000 = false;
+              {if (true) return false;}
+        break;
+      case LONE_SYMBOL:
+        t = jj_consume_token(LONE_SYMBOL);
+       jjtree.closeNodeScope(jjtn000, true);
+       jjtc000 = false;
+         /* Drop the ending zero-width whitespace */
+         t.image = t.image.substring(0, t.image.length() - 1); {if (true) return false;}
+        break;
+      default:
+        jj_la1[69] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/* -----------------------------------------------------------------------
+ *
+ *  Defined Directive Syntax
+ *
+ * ----------------------------------------------------------------------*/
+  final public boolean IfStatement(boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) IfStatement */
+    ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);Token t = null, u = null, end = null;
+    ASTBlock lastBlock = null;
+    boolean newlineAtStart = afterNewline;
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        t = jj_consume_token(WHITESPACE);
+            // only possible if not after new line
+            jjtn000.setPrefix(t.image);
+            t = null;
+        break;
+      default:
+        jj_la1[70] = jj_gen;
+        ;
+      }
+      jj_consume_token(IF_DIRECTIVE);
+      label_30:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[71] = jj_gen;
+          break label_30;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[72] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      jj_consume_token(LPAREN);
+      Expression();
+      jj_consume_token(RPAREN);
+      ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+      boolean jjtc001 = true;
+      jjtree.openNodeScope(jjtn001);
+      try {
+        if (jj_2_18(2)) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+            t = jj_consume_token(WHITESPACE);
+            break;
+          default:
+            jj_la1[73] = jj_gen;
+            ;
+          }
+          u = jj_consume_token(NEWLINE);
+            jjtn001.setPrefix(t == null ? u.image : t.image + u.image);
+            t = u = null;
+            afterNewline = true;
+        } else {
+          ;
+        }
+        label_31:
+        while (true) {
+          if ((getToken(1).kind != ELSEIF && getToken(1).kind != ELSE && getToken(1).kind != END) &&
+                        (!afterNewline || getToken(1).kind != WHITESPACE || (getToken(2).kind != ELSEIF && getToken(2).kind != ELSE && getToken(2).kind != END))) {
+            ;
+          } else {
+            break label_31;
+          }
+          afterNewline = Statement(afterNewline);
+        }
+          jjtree.closeNodeScope(jjtn001, true);
+          jjtc001 = false;
+            lastBlock = jjtn001;
+      } catch (Throwable jjte001) {
+      if (jjtc001) {
+        jjtree.clearNodeScope(jjtn001);
+        jjtc001 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte001 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte001;}
+      }
+      if (jjte001 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte001;}
+      }
+      {if (true) throw (Error)jjte001;}
+      } finally {
+      if (jjtc001) {
+        jjtree.closeNodeScope(jjtn001, true);
+      }
+      }
+      if (getToken(1).kind == ELSEIF || (afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == ELSEIF)) {
+        label_32:
+        while (true) {
+          lastBlock = ElseIfStatement(lastBlock, afterNewline);
+                                                                                                                                                                                              afterNewline = lastBlock.endsWithNewline;
+          if (getToken(1).kind == ELSEIF || (afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == ELSEIF)) {
+            ;
+          } else {
+            break label_32;
+          }
+        }
+      } else {
+        ;
+      }
+      if (getToken(1).kind == ELSE || (afterNewline && getToken(1).kind == WHITESPACE && getToken(2).kind == ELSE)) {
+        lastBlock = ElseStatement(lastBlock, afterNewline);
+                                                                                                                                                                                     afterNewline = lastBlock.endsWithNewline;
+      } else {
+        ;
+      }
+      if (jj_2_19(1) && (afterNewline)) {
+        t = jj_consume_token(WHITESPACE);
+            lastBlock.setPostfix(t.image);
+            t = null;
+      } else {
+        ;
+      }
+      end = jj_consume_token(END);
+      afterNewline = false;
+      if (jj_2_20(2) && (newlineAtStart || rsvc.getSpaceGobbling() == SpaceGobbling.BC)) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          t = jj_consume_token(WHITESPACE);
+          break;
+        default:
+          jj_la1[74] = jj_gen;
+          ;
+        }
+        u = jj_consume_token(NEWLINE);
+             jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+             afterNewline = true;
+      } else {
+        ;
+      }
+      jjtree.closeNodeScope(jjtn000, true);
+      jjtc000 = false;
+        int pos = end.image.lastIndexOf(hash);
+        if (pos > 0)
+        {
+            lastBlock.setMorePostfix(end.image.substring(0, pos));
+        }
+        {if (true) return afterNewline;}
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public ASTBlock ElseStatement(ASTBlock previousBlock, boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) ElseStatement */
+    ASTElseStatement jjtn000 = new ASTElseStatement(this, JJTELSESTATEMENT);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);Token t = null, u = null, _else = null;
+    ASTBlock block = null;
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        t = jj_consume_token(WHITESPACE);
+         previousBlock.setPostfix(t.image);
+         t = null;
+        break;
+      default:
+        jj_la1[75] = jj_gen;
+        ;
+      }
+      _else = jj_consume_token(ELSE);
+     ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+     boolean jjtc001 = true;
+     jjtree.openNodeScope(jjtn001);
+      try {
+        if (jj_2_21(2)) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+            t = jj_consume_token(WHITESPACE);
+            break;
+          default:
+            jj_la1[76] = jj_gen;
+            ;
+          }
+          u = jj_consume_token(NEWLINE);
+           jjtn001.setPrefix(t == null ? u.image : t.image + u.image);
+           t = u = null;
+           afterNewline = true;
+        } else {
+          ;
+        }
+        label_33:
+        while (true) {
+          if (getToken(1).kind != END && (!afterNewline || getToken(1).kind != WHITESPACE || getToken(2).kind != END)) {
+            ;
+          } else {
+            break label_33;
+          }
+          afterNewline = Statement(afterNewline);
+        }
+       jjtree.closeNodeScope(jjtn001, true);
+       jjtc001 = false;
+         block = jjtn001;
+         block.endsWithNewline = afterNewline;
+      } catch (Throwable jjte001) {
+     if (jjtc001) {
+       jjtree.clearNodeScope(jjtn001);
+       jjtc001 = false;
+     } else {
+       jjtree.popNode();
+     }
+     if (jjte001 instanceof RuntimeException) {
+       {if (true) throw (RuntimeException)jjte001;}
+     }
+     if (jjte001 instanceof ParseException) {
+       {if (true) throw (ParseException)jjte001;}
+     }
+     {if (true) throw (Error)jjte001;}
+      } finally {
+     if (jjtc001) {
+       jjtree.closeNodeScope(jjtn001, true);
+     }
+      }
+      jjtree.closeNodeScope(jjtn000, true);
+      jjtc000 = false;
+        int pos = _else.image.lastIndexOf(hash);
+        if (pos > 0)
+        {
+            previousBlock.setMorePostfix(_else.image.substring(0, pos));
+        }
+        {if (true) return block;}
+    } catch (Throwable jjte000) {
+     if (jjtc000) {
+       jjtree.clearNodeScope(jjtn000);
+       jjtc000 = false;
+     } else {
+       jjtree.popNode();
+     }
+     if (jjte000 instanceof RuntimeException) {
+       {if (true) throw (RuntimeException)jjte000;}
+     }
+     if (jjte000 instanceof ParseException) {
+       {if (true) throw (ParseException)jjte000;}
+     }
+     {if (true) throw (Error)jjte000;}
+    } finally {
+     if (jjtc000) {
+       jjtree.closeNodeScope(jjtn000, true);
+     }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+  final public ASTBlock ElseIfStatement(ASTBlock previousBlock, boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) ElseIfStatement */
+    ASTElseIfStatement jjtn000 = new ASTElseIfStatement(this, JJTELSEIFSTATEMENT);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);Token t = null, u = null, elseif = null;
+    ASTBlock block = null;
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        t = jj_consume_token(WHITESPACE);
+        previousBlock.setPostfix(t.image);
+        t = null;
+        break;
+      default:
+        jj_la1[77] = jj_gen;
+        ;
+      }
+      elseif = jj_consume_token(ELSEIF);
+      label_34:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[78] = jj_gen;
+          break label_34;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[79] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      jj_consume_token(LPAREN);
+      Expression();
+      jj_consume_token(RPAREN);
+    ASTBlock jjtn001 = new ASTBlock(this, JJTBLOCK);
+    boolean jjtc001 = true;
+    jjtree.openNodeScope(jjtn001);
+      try {
+        if (jj_2_22(2)) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case WHITESPACE:
+            t = jj_consume_token(WHITESPACE);
+            break;
+          default:
+            jj_la1[80] = jj_gen;
+            ;
+          }
+          u = jj_consume_token(NEWLINE);
+          jjtn001.setPrefix(t == null ? u.image : t.image + u.image);
+          t = u = null;
+          afterNewline = true;
+        } else {
+          ;
+        }
+        label_35:
+        while (true) {
+          if ((getToken(1).kind != ELSEIF && getToken(1).kind != ELSE && getToken(1).kind != END) && (!afterNewline || getToken(1).kind != WHITESPACE || (getToken(2).kind != ELSEIF && getToken(2).kind != ELSE && getToken(2).kind != END))) {
+            ;
+          } else {
+            break label_35;
+          }
+          afterNewline = Statement(afterNewline);
+        }
+      jjtree.closeNodeScope(jjtn001, true);
+      jjtc001 = false;
+        block = jjtn001;
+        block.endsWithNewline = afterNewline;
+      } catch (Throwable jjte001) {
+    if (jjtc001) {
+      jjtree.clearNodeScope(jjtn001);
+      jjtc001 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte001 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte001;}
+    }
+    if (jjte001 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte001;}
+    }
+    {if (true) throw (Error)jjte001;}
+      } finally {
+    if (jjtc001) {
+      jjtree.closeNodeScope(jjtn001, true);
+    }
+      }
+    jjtree.closeNodeScope(jjtn000, true);
+    jjtc000 = false;
+      int pos = elseif.image.lastIndexOf(hash);
+      if (pos > 0)
+      {
+          previousBlock.setMorePostfix(elseif.image.substring(0, pos));
+      }
+      {if (true) return block;}
+    } catch (Throwable jjte000) {
+    if (jjtc000) {
+      jjtree.clearNodeScope(jjtn000);
+      jjtc000 = false;
+    } else {
+      jjtree.popNode();
+    }
+    if (jjte000 instanceof RuntimeException) {
+      {if (true) throw (RuntimeException)jjte000;}
+    }
+    if (jjte000 instanceof ParseException) {
+      {if (true) throw (ParseException)jjte000;}
+    }
+    {if (true) throw (Error)jjte000;}
+    } finally {
+    if (jjtc000) {
+      jjtree.closeNodeScope(jjtn000, true);
+    }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/**
+ *  Currently support both types of set :
+ *   #set( expr )
+ *   #set expr
+ */
+  final public boolean SetDirective(boolean afterNewline) throws ParseException {
+ /*@bgen(jjtree) SetDirective */
+    ASTSetDirective jjtn000 = new ASTSetDirective(this, JJTSETDIRECTIVE);
+    boolean jjtc000 = true;
+    jjtree.openNodeScope(jjtn000);Token t = null, u = null;
+    boolean endsWithNewline = false;
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        t = jj_consume_token(WHITESPACE);
+            // only possible after new line
+            jjtn000.setPrefix(t.image);
+            t = null;
+        break;
+      default:
+        jj_la1[81] = jj_gen;
+        ;
+      }
+      jj_consume_token(SET_DIRECTIVE);
+      label_36:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[82] = jj_gen;
+          break label_36;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[83] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      Reference();
+      label_37:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+        case NEWLINE:
+          ;
+          break;
+        default:
+          jj_la1[84] = jj_gen;
+          break label_37;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          jj_consume_token(WHITESPACE);
+          break;
+        case NEWLINE:
+          jj_consume_token(NEWLINE);
+          break;
+        default:
+          jj_la1[85] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+      jj_consume_token(EQUALS);
+      Expression();
+      jj_consume_token(RPAREN);
+        /*
+         * ensure that inSet is false.  Leads to some amusing bugs...
+         */
+
+        token_source.setInSet(false);
+      if (jj_2_23(2) && (afterNewline || rsvc.getSpaceGobbling() == SpaceGobbling.BC)) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WHITESPACE:
+          t = jj_consume_token(WHITESPACE);
+          break;
+        default:
+          jj_la1[86] = jj_gen;
+          ;
+        }
+        u = jj_consume_token(NEWLINE);
+             jjtn000.setPostfix(t == null ? u.image : t.image + u.image);
+             endsWithNewline = true;
+      } else {
+        ;
+      }
+      jjtree.closeNodeScope(jjtn000, true);
+      jjtc000 = false;
+        {if (true) return endsWithNewline;}
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000, true);
+      }
+    }
+    throw new Error("Missing return statement in function");
+  }
+
+/* -----------------------------------------------------------------------
+ *
+ *  Expression Syntax
+ *
+ * ----------------------------------------------------------------------*/
+  final public void Expression() throws ParseException {
+                     /*@bgen(jjtree) Expression */
+  ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      ConditionalOrExpression();
+    } catch (Throwable jjte000) {
+  if (jjtc000) {
+    jjtree.clearNodeScope(jjtn000);
+    jjtc000 = false;
+  } else {
+    jjtree.popNode();
+  }
+  if (jjte000 instanceof RuntimeException) {
+    {if (true) throw (RuntimeException)jjte000;}
+  }
+  if (jjte000 instanceof ParseException) {
+    {if (true) throw (ParseException)jjte000;}
+  }
+  {if (true) throw (Error)jjte000;}
+    } finally {
+  if (jjtc000) {
+    jjtree.closeNodeScope(jjtn000, true);
+  }
+    }
+  }
+
+  final public void Assignment() throws ParseException {
+                                    /*@bgen(jjtree) #Assignment( 2) */
+  ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
+  boolean jjtc000 = true;
+  jjtree.openNodeScope(jjtn000);
+    try {
+      PrimaryExpression();
+      jj_consume_token(EQUALS);
+      Expression();
+    } catch (Throwable jjte000) {
+      if (jjtc000) {
+        jjtree.clearNodeScope(jjtn000);
+        jjtc000 = false;
+      } else {
+        jjtree.popNode();
+      }
+      if (jjte000 instanceof RuntimeException) {
+        {if (true) throw (RuntimeException)jjte000;}
+      }
+      if (jjte000 instanceof ParseException) {
+        {if (true) throw (ParseException)jjte000;}
+      }
+      {if (true) throw (Error)jjte000;}
+    } finally {
+      if (jjtc000) {
+        jjtree.closeNodeScope(jjtn000,  2);
+      }
+    }
+  }
+
+  final public void ConditionalOrExpression() throws ParseException {
+    ConditionalAndExpression();
+    label_38:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_OR_2:
+      case LOGICAL_OR:
+        ;
+        break;
+      default:
+        jj_la1[87] = jj_gen;
+        break label_38;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_OR:
+        jj_consume_token(LOGICAL_OR);
+        break;
+      case LOGICAL_OR_2:
+        jj_consume_token(LOGICAL_OR_2);
+        break;
+      default:
+        jj_la1[88] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+                                         ASTOrNode jjtn001 = new ASTOrNode(this, JJTORNODE);
+                                         boolean jjtc001 = true;
+                                         jjtree.openNodeScope(jjtn001);
+      try {
+        ConditionalAndExpression();
+      } catch (Throwable jjte001) {
+                                         if (jjtc001) {
+                                           jjtree.clearNodeScope(jjtn001);
+                                           jjtc001 = false;
+                                         } else {
+                                           jjtree.popNode();
+                                         }
+                                         if (jjte001 instanceof RuntimeException) {
+                                           {if (true) throw (RuntimeException)jjte001;}
+                                         }
+                                         if (jjte001 instanceof ParseException) {
+                                           {if (true) throw (ParseException)jjte001;}
+                                         }
+                                         {if (true) throw (Error)jjte001;}
+      } finally {
+                                         if (jjtc001) {
+                                           jjtree.closeNodeScope(jjtn001,  2);
+                                         }
+      }
+    }
+  }
+
+  final public void ConditionalAndExpression() throws ParseException {
+    EqualityExpression();
+    label_39:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_AND:
+        ;
+        break;
+      default:
+        jj_la1[89] = jj_gen;
+        break label_39;
+      }
+      jj_consume_token(LOGICAL_AND);
+                    ASTAndNode jjtn001 = new ASTAndNode(this, JJTANDNODE);
+                    boolean jjtc001 = true;
+                    jjtree.openNodeScope(jjtn001);
+      try {
+        EqualityExpression();
+      } catch (Throwable jjte001) {
+                    if (jjtc001) {
+                      jjtree.clearNodeScope(jjtn001);
+                      jjtc001 = false;
+                    } else {
+                      jjtree.popNode();
+                    }
+                    if (jjte001 instanceof RuntimeException) {
+                      {if (true) throw (RuntimeException)jjte001;}
+                    }
+                    if (jjte001 instanceof ParseException) {
+                      {if (true) throw (ParseException)jjte001;}
+                    }
+                    {if (true) throw (Error)jjte001;}
+      } finally {
+                    if (jjtc001) {
+                      jjtree.closeNodeScope(jjtn001,  2);
+                    }
+      }
+    }
+  }
+
+  final public void EqualityExpression() throws ParseException {
+    RelationalExpression();
+    label_40:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_EQUALS:
+      case LOGICAL_NOT_EQUALS:
+        ;
+        break;
+      default:
+        jj_la1[90] = jj_gen;
+        break label_40;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_EQUALS:
+        jj_consume_token(LOGICAL_EQUALS);
+                          ASTEQNode jjtn001 = new ASTEQNode(this, JJTEQNODE);
+                          boolean jjtc001 = true;
+                          jjtree.openNodeScope(jjtn001);
+        try {
+          RelationalExpression();
+        } catch (Throwable jjte001) {
+                          if (jjtc001) {
+                            jjtree.clearNodeScope(jjtn001);
+                            jjtc001 = false;
+                          } else {
+                            jjtree.popNode();
+                          }
+                          if (jjte001 instanceof RuntimeException) {
+                            {if (true) throw (RuntimeException)jjte001;}
+                          }
+                          if (jjte001 instanceof ParseException) {
+                            {if (true) throw (ParseException)jjte001;}
+                          }
+                          {if (true) throw (Error)jjte001;}
+        } finally {
+                          if (jjtc001) {
+                            jjtree.closeNodeScope(jjtn001,  2);
+                          }
+        }
+        break;
+      case LOGICAL_NOT_EQUALS:
+        jj_consume_token(LOGICAL_NOT_EQUALS);
+                              ASTNENode jjtn002 = new ASTNENode(this, JJTNENODE);
+                              boolean jjtc002 = true;
+                              jjtree.openNodeScope(jjtn002);
+        try {
+          RelationalExpression();
+        } catch (Throwable jjte002) {
+                              if (jjtc002) {
+                                jjtree.clearNodeScope(jjtn002);
+                                jjtc002 = false;
+                              } else {
+                                jjtree.popNode();
+                              }
+                              if (jjte002 instanceof RuntimeException) {
+                                {if (true) throw (RuntimeException)jjte002;}
+                              }
+                              if (jjte002 instanceof ParseException) {
+                                {if (true) throw (ParseException)jjte002;}
+                              }
+                              {if (true) throw (Error)jjte002;}
+        } finally {
+                              if (jjtc002) {
+                                jjtree.closeNodeScope(jjtn002,  2);
+                              }
+        }
+        break;
+      default:
+        jj_la1[91] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+  final public void RelationalExpression() throws ParseException {
+    AdditiveExpression();
+    label_41:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_LT:
+      case LOGICAL_LE:
+      case LOGICAL_GT:
+      case LOGICAL_GE:
+        ;
+        break;
+      default:
+        jj_la1[92] = jj_gen;
+        break label_41;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case LOGICAL_LT:
+        jj_consume_token(LOGICAL_LT);
+                        ASTLTNode jjtn001 = new ASTLTNode(this, JJTLTNODE);
+                        boolean jjtc001 = true;
+                        jjtree.openNodeScope(jjtn001);
+        try {
+          AdditiveExpression();
+        } catch (Throwable jjte001) {
+                        if (jjtc001) {
+                          jjtree.clearNodeScope(jjtn001);
+                          jjtc001 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte001 instanceof RuntimeException) {
+                          {if (true) throw (RuntimeException)jjte001;}
+                        }
+                        if (jjte001 instanceof ParseException) {
+                          {if (true) throw (ParseException)jjte001;}
+                        }
+                        {if (true) throw (Error)jjte001;}
+        } finally {
+                        if (jjtc001) {
+                          jjtree.closeNodeScope(jjtn001,  2);
+                        }
+        }
+        break;
+      case LOGICAL_GT:
+        jj_consume_token(LOGICAL_GT);
+                        ASTGTNode jjtn002 = new ASTGTNode(this, JJTGTNODE);
+                        boolean jjtc002 = true;
+                        jjtree.openNodeScope(jjtn002);
+        try {
+          AdditiveExpression();
+        } catch (Throwable jjte002) {
+                        if (jjtc002) {
+                          jjtree.clearNodeScope(jjtn002);
+                          jjtc002 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte002 instanceof RuntimeException) {
+                          {if (true) throw (RuntimeException)jjte002;}
+                        }
+                        if (jjte002 instanceof ParseException) {
+                          {if (true) throw (ParseException)jjte002;}
+                        }
+                        {if (true) throw (Error)jjte002;}
+        } finally {
+                        if (jjtc002) {
+                          jjtree.closeNodeScope(jjtn002,  2);
+                        }
+        }
+        break;
+      case LOGICAL_LE:
+        jj_consume_token(LOGICAL_LE);
+                        ASTLENode jjtn003 = new ASTLENode(this, JJTLENODE);
+                        boolean jjtc003 = true;
+                        jjtree.openNodeScope(jjtn003);
+        try {
+          AdditiveExpression();
+        } catch (Throwable jjte003) {
+                        if (jjtc003) {
+                          jjtree.clearNodeScope(jjtn003);
+                          jjtc003 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte003 instanceof RuntimeException) {
+                          {if (true) throw (RuntimeException)jjte003;}
+                        }
+                        if (jjte003 instanceof ParseException) {
+                          {if (true) throw (ParseException)jjte003;}
+                        }
+                        {if (true) throw (Error)jjte003;}
+        } finally {
+                        if (jjtc003) {
+                          jjtree.closeNodeScope(jjtn003,  2);
+                        }
+        }
+        break;
+      case LOGICAL_GE:
+        jj_consume_token(LOGICAL_GE);
+                        ASTGENode jjtn004 = new ASTGENode(this, JJTGENODE);
+                        boolean jjtc004 = true;
+                        jjtree.openNodeScope(jjtn004);
+        try {
+          AdditiveExpression();
+        } catch (Throwable jjte004) {
+                        if (jjtc004) {
+                          jjtree.clearNodeScope(jjtn004);
+                          jjtc004 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte004 instanceof RuntimeException) {
+                          {if (true) throw (RuntimeException)jjte004;}
+                        }
+                        if (jjte004 instanceof ParseException) {
+                          {if (true) throw (ParseException)jjte004;}
+                        }
+                        {if (true) throw (Error)jjte004;}
+        } finally {
+                        if (jjtc004) {
+                          jjtree.closeNodeScope(jjtn004,  2);
+                        }
+        }
+        break;
+      default:
+        jj_la1[93] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+  final public void AdditiveExpression() throws ParseException {
+    MultiplicativeExpression();
+    label_42:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case MINUS:
+      case PLUS:
+        ;
+        break;
+      default:
+        jj_la1[94] = jj_gen;
+        break label_42;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case PLUS:
+        jj_consume_token(PLUS);
+                  ASTAddNode jjtn001 = new ASTAddNode(this, JJTADDNODE);
+                  boolean jjtc001 = true;
+                  jjtree.openNodeScope(jjtn001);
+        try {
+          MultiplicativeExpression();
+        } catch (Throwable jjte001) {
+                  if (jjtc001) {
+                    jjtree.clearNodeScope(jjtn001);
+                    jjtc001 = false;
+                  } else {
+                    jjtree.popNode();
+                  }
+                  if (jjte001 instanceof RuntimeException) {
+                    {if (true) throw (RuntimeException)jjte001;}
+                  }
+                  if (jjte001 instanceof ParseException) {
+                    {if (true) throw (ParseException)jjte001;}
+                  }
+                  {if (true) throw (Error)jjte001;}
+        } finally {
+                  if (jjtc001) {
+                    jjtree.closeNodeScope(jjtn001,  2);
+                  }
+        }
+        break;
+      case MINUS:
+        jj_consume_token(MINUS);
+                  ASTSubtractNode jjtn002 = new ASTSubtractNode(this, JJTSUBTRACTNODE);
+                  boolean jjtc002 = true;
+                  jjtree.openNodeScope(jjtn002);
+        try {
+          MultiplicativeExpression();
+        } catch (Throwable jjte002) {
+                  if (jjtc002) {
+                    jjtree.clearNodeScope(jjtn002);
+                    jjtc002 = false;
+                  } else {
+                    jjtree.popNode();
+                  }
+                  if (jjte002 instanceof RuntimeException) {
+                    {if (true) throw (RuntimeException)jjte002;}
+                  }
+                  if (jjte002 instanceof ParseException) {
+                    {if (true) throw (ParseException)jjte002;}
+                  }
+                  {if (true) throw (Error)jjte002;}
+        } finally {
+                  if (jjtc002) {
+                    jjtree.closeNodeScope(jjtn002,  2);
+                  }
+        }
+        break;
+      default:
+        jj_la1[95] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+  final public void MultiplicativeExpression() throws ParseException {
+    UnaryExpression();
+    label_43:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case MULTIPLY:
+      case DIVIDE:
+      case MODULUS:
+        ;
+        break;
+      default:
+        jj_la1[96] = jj_gen;
+        break label_43;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case MULTIPLY:
+        jj_consume_token(MULTIPLY);
+                          ASTMulNode jjtn001 = new ASTMulNode(this, JJTMULNODE);
+                          boolean jjtc001 = true;
+                          jjtree.openNodeScope(jjtn001);
+        try {
+          UnaryExpression();
+        } catch (Throwable jjte001) {
+                          if (jjtc001) {
+                            jjtree.clearNodeScope(jjtn001);
+                            jjtc001 = false;
+                          } else {
+                            jjtree.popNode();
+                          }
+                          if (jjte001 instanceof RuntimeException) {
+                            {if (true) throw (RuntimeException)jjte001;}
+                          }
+                          if (jjte001 instanceof ParseException) {
+                            {if (true) throw (ParseException)jjte001;}
+                          }
+                          {if (true) throw (Error)jjte001;}
+        } finally {
+                          if (jjtc001) {
+                            jjtree.closeNodeScope(jjtn001,  2);
+                          }
+        }
+        break;
+      case DIVIDE:
+        jj_consume_token(DIVIDE);
+                        ASTDivNode jjtn002 = new ASTDivNode(this, JJTDIVNODE);
+                        boolean jjtc002 = true;
+                        jjtree.openNodeScope(jjtn002);
+        try {
+          UnaryExpression();
+        } catch (Throwable jjte002) {
+                        if (jjtc002) {
+                          jjtree.clearNodeScope(jjtn002);
+                          jjtc002 = false;
+                        } else {
+                          jjtree.popNode();
+                        }
+                        if (jjte002 instanceof RuntimeException) {
+                          {if (true) throw (RuntimeException)jjte002;}
+                        }
+                        if (jjte002 instanceof ParseException) {
+                          {if (true) throw (ParseException)jjte002;}
+                        }
+                        {if (true) throw (Error)jjte002;}
+        } finally {
+                        if (jjtc002) {
+                          jjtree.closeNodeScope(jjtn002,  2);
+                        }
+        }
+        break;
+      case MODULUS:
+        jj_consume_token(MODULUS);
+                         ASTModNode jjtn003 = new ASTModNode(this, JJTMODNODE);
+                         boolean jjtc003 = true;
+                         jjtree.openNodeScope(jjtn003);
+        try {
+          UnaryExpression();
+        } catch (Throwable jjte003) {
+                         if (jjtc003) {
+                           jjtree.clearNodeScope(jjtn003);
+                           jjtc003 = false;
+                         } else {
+                           jjtree.popNode();
+                         }
+                         if (jjte003 instanceof RuntimeException) {
+                           {if (true) throw (RuntimeException)jjte003;}
+                         }
+                         if (jjte003 instanceof ParseException) {
+                           {if (true) throw (ParseException)jjte003;}
+                         }
+                         {if (true) throw (Error)jjte003;}
+        } finally {
+                         if (jjtc003) {
+                           jjtree.closeNodeScope(jjtn003,  2);
+                         }
+        }
+        break;
+      default:
+        jj_la1[97] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+  final public void UnaryExpression() throws ParseException {
+    label_44:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[98] = jj_gen;
+        break label_44;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[99] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case LOGICAL_NOT:
+      jj_consume_token(LOGICAL_NOT);
+                           ASTNotNode jjtn001 = new ASTNotNode(this, JJTNOTNODE);
+                           boolean jjtc001 = true;
+                           jjtree.openNodeScope(jjtn001);
+      try {
+        UnaryExpression();
+      } catch (Throwable jjte001) {
+                           if (jjtc001) {
+                             jjtree.clearNodeScope(jjtn001);
+                             jjtc001 = false;
+                           } else {
+                             jjtree.popNode();
+                           }
+                           if (jjte001 instanceof RuntimeException) {
+                             {if (true) throw (RuntimeException)jjte001;}
+                           }
+                           if (jjte001 instanceof ParseException) {
+                             {if (true) throw (ParseException)jjte001;}
+                           }
+                           {if (true) throw (Error)jjte001;}
+      } finally {
+                           if (jjtc001) {
+                             jjtree.closeNodeScope(jjtn001,  1);
+                           }
+      }
+      break;
+    case MINUS:
+      jj_consume_token(MINUS);
+                   ASTNegateNode jjtn002 = new ASTNegateNode(this, JJTNEGATENODE);
+                   boolean jjtc002 = true;
+                   jjtree.openNodeScope(jjtn002);
+      try {
+        PrimaryExpression();
+      } catch (Throwable jjte002) {
+                   if (jjtc002) {
+                     jjtree.clearNodeScope(jjtn002);
+                     jjtc002 = false;
+                   } else {
+                     jjtree.popNode();
+                   }
+                   if (jjte002 instanceof RuntimeException) {
+                     {if (true) throw (RuntimeException)jjte002;}
+                   }
+                   if (jjte002 instanceof ParseException) {
+                     {if (true) throw (ParseException)jjte002;}
+                   }
+                   {if (true) throw (Error)jjte002;}
+      } finally {
+                   if (jjtc002) {
+                     jjtree.closeNodeScope(jjtn002,  1);
+                   }
+      }
+      break;
+    case LBRACKET:
+    case LEFT_CURLEY:
+    case LPAREN:
+    case WHITESPACE:
+    case NEWLINE:
+    case STRING_LITERAL:
+    case TRUE:
+    case FALSE:
+    case INTEGER_LITERAL:
+    case FLOATING_POINT_LITERAL:
+    case IDENTIFIER:
+    case OLD_IDENTIFIER:
+    case LCURLY:
+      PrimaryExpression();
+      break;
+    default:
+      jj_la1[100] = jj_gen;
+      jj_consume_token(-1);
+      throw new ParseException();
+    }
+  }
+
+  final public void PrimaryExpression() throws ParseException {
+    label_45:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[101] = jj_gen;
+        break label_45;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[102] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+    case STRING_LITERAL:
+      StringLiteral();
+      break;
+    case IDENTIFIER:
+    case OLD_IDENTIFIER:
+    case LCURLY:
+      Reference();
+      break;
+    case INTEGER_LITERAL:
+      IntegerLiteral();
+      break;
+    default:
+      jj_la1[103] = jj_gen;
+      if (jj_2_24(2147483647)) {
+        IntegerRange();
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case FLOATING_POINT_LITERAL:
+          FloatingPointLiteral();
+          break;
+        case LEFT_CURLEY:
+          Map();
+          break;
+        case LBRACKET:
+          ObjectArray();
+          break;
+        case TRUE:
+          True();
+          break;
+        case FALSE:
+          False();
+          break;
+        case LPAREN:
+          jj_consume_token(LPAREN);
+          Expression();
+          jj_consume_token(RPAREN);
+          break;
+        default:
+          jj_la1[104] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+      }
+    }
+    label_46:
+    while (true) {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+      case NEWLINE:
+        ;
+        break;
+      default:
+        jj_la1[105] = jj_gen;
+        break label_46;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case WHITESPACE:
+        jj_consume_token(WHITESPACE);
+        break;
+      case NEWLINE:
+        jj_consume_token(NEWLINE);
+        break;
+      default:
+        jj_la1[106] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    }
+  }
+
+  private boolean jj_2_1(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_1(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(0, xla); }
+  }
+
+  private boolean jj_2_2(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_2(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(1, xla); }
+  }
+
+  private boolean jj_2_3(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_3(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(2, xla); }
+  }
+
+  private boolean jj_2_4(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_4(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(3, xla); }
+  }
+
+  private boolean jj_2_5(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_5(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(4, xla); }
+  }
+
+  private boolean jj_2_6(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_6(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(5, xla); }
+  }
+
+  private boolean jj_2_7(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_7(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(6, xla); }
+  }
+
+  private boolean jj_2_8(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_8(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(7, xla); }
+  }
+
+  private boolean jj_2_9(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_9(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(8, xla); }
+  }
+
+  private boolean jj_2_10(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_10(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(9, xla); }
+  }
+
+  private boolean jj_2_11(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_11(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(10, xla); }
+  }
+
+  private boolean jj_2_12(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_12(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(11, xla); }
+  }
+
+  private boolean jj_2_13(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_13(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(12, xla); }
+  }
+
+  private boolean jj_2_14(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_14(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(13, xla); }
+  }
+
+  private boolean jj_2_15(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_15(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(14, xla); }
+  }
+
+  private boolean jj_2_16(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_16(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(15, xla); }
+  }
+
+  private boolean jj_2_17(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_17(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(16, xla); }
+  }
+
+  private boolean jj_2_18(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_18(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(17, xla); }
+  }
+
+  private boolean jj_2_19(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_19(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(18, xla); }
+  }
+
+  private boolean jj_2_20(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_20(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(19, xla); }
+  }
+
+  private boolean jj_2_21(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_21(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(20, xla); }
+  }
+
+  private boolean jj_2_22(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_22(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(21, xla); }
+  }
+
+  private boolean jj_2_23(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_23(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(22, xla); }
+  }
+
+  private boolean jj_2_24(int xla) {
+    jj_la = xla; jj_lastpos = jj_scanpos = token;
+    try { return !jj_3_24(); }
+    catch(LookaheadSuccess ls) { return true; }
+    finally { jj_save(23, xla); }
+  }
+
+  private boolean jj_3_20() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_19() {
+    if (jj_scan_token(WHITESPACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_55() {
+    return false;
+  }
+
+  private boolean jj_3R_54() {
+    if (jj_3R_76()) return true;
+    return false;
+  }
+
+  private boolean jj_3_6() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_54()) jj_scanpos = xsp;
+    jj_lookingAhead = true;
+    jj_semLA = !isRightParenthesis();
+    jj_lookingAhead = false;
+    if (!jj_semLA || jj_3R_55()) return true;
+    if (jj_3R_56()) return true;
+    return false;
+  }
+
+  private boolean jj_3_18() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_126() {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_62() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_125() {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_65() {
+    if (jj_3R_98()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_69() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_63() {
+    if (jj_3R_98()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_111() {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_53() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_61() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_100() {
+    if (jj_3R_110()) return true;
+    return false;
+  }
+
+  private boolean jj_3_17() {
+    if (jj_3R_64()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_68() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_60() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3_15() {
+    if (jj_3R_64()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_137() {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_109()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_52() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_108() {
+    if (jj_scan_token(FALSE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_67() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_107() {
+    if (jj_scan_token(TRUE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_112() {
+    if (jj_scan_token(PIPE)) return true;
+    if (jj_3R_109()) return true;
+    return false;
+  }
+
+  private boolean jj_3_16() {
+    if (jj_scan_token(DOT)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_17()) {
+    jj_scanpos = xsp;
+    if (jj_3R_65()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_126()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_127() {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_58()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_51() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3_14() {
+    if (jj_scan_token(DOT)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3_15()) {
+    jj_scanpos = xsp;
+    if (jj_3R_63()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_125()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_99() {
+    if (jj_3R_109()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_137()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_71() {
+    if (jj_scan_token(LCURLY)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(67)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(70)) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_111()) { jj_scanpos = xsp; break; }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_16()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_112()) jj_scanpos = xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(73)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(13)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_70() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(67)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(70)) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_100()) { jj_scanpos = xsp; break; }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3_14()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_59() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_47() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_70()) {
+    jj_scanpos = xsp;
+    if (jj_3R_71()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_110() {
+    if (jj_scan_token(INDEX_LBRACKET)) return true;
+    if (jj_3R_131()) return true;
+    if (jj_scan_token(INDEX_RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_66() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3_13() {
+    if (jj_scan_token(LBRACKET)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_59()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_60()) {
+    jj_scanpos = xsp;
+    if (jj_3R_61()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_62()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(DOUBLEDOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_64() {
+    if (jj_3R_98()) return true;
+    if (jj_scan_token(LPAREN)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_99()) jj_scanpos = xsp;
+    if (jj_scan_token(REFMOD2_RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_76() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_50() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_96() {
+    if (jj_3R_104()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_95() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_94() {
+    if (jj_3R_108()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_93() {
+    if (jj_3R_107()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_97() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_117() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_86() {
+    if (jj_3R_108()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_92() {
+    if (jj_3R_106()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_91() {
+    if (jj_3R_105()) return true;
+    return false;
+  }
+
+  private boolean jj_3_24() {
+    if (jj_scan_token(LBRACKET)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_66()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_67()) {
+    jj_scanpos = xsp;
+    if (jj_3R_68()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_69()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(DOUBLEDOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_90() {
+    if (jj_3R_103()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_89() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_85() {
+    if (jj_3R_107()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_173() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_88() {
+    if (jj_3R_102()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_172() {
+    if (jj_scan_token(LPAREN)) return true;
+    if (jj_3R_109()) return true;
+    if (jj_scan_token(RPAREN)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_171() {
+    if (jj_3R_108()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_84() {
+    if (jj_3R_106()) return true;
+    return false;
+  }
+
+  private boolean jj_3_5() {
+    if (jj_scan_token(LBRACKET)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_50()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_51()) {
+    jj_scanpos = xsp;
+    if (jj_3R_52()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_53()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(DOUBLEDOT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_170() {
+    if (jj_3R_107()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_169() {
+    if (jj_3R_106()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_168() {
+    if (jj_3R_105()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_87() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_167() {
+    if (jj_3R_104()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_83() {
+    if (jj_3R_105()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_58() {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_87()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_88()) {
+    jj_scanpos = xsp;
+    if (jj_3R_89()) {
+    jj_scanpos = xsp;
+    if (jj_3R_90()) {
+    jj_scanpos = xsp;
+    if (jj_3R_91()) {
+    jj_scanpos = xsp;
+    if (jj_3R_92()) {
+    jj_scanpos = xsp;
+    if (jj_3R_93()) {
+    jj_scanpos = xsp;
+    if (jj_3R_94()) {
+    jj_scanpos = xsp;
+    if (jj_3R_95()) {
+    jj_scanpos = xsp;
+    if (jj_3R_96()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_97()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_166() {
+    if (jj_3R_103()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_165() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_164() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_82() {
+    if (jj_3R_104()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_163() {
+    if (jj_3R_102()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_162() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_158() {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_162()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_163()) {
+    jj_scanpos = xsp;
+    if (jj_3R_164()) {
+    jj_scanpos = xsp;
+    if (jj_3R_165()) {
+    jj_scanpos = xsp;
+    if (jj_3R_166()) {
+    jj_scanpos = xsp;
+    if (jj_3R_167()) {
+    jj_scanpos = xsp;
+    if (jj_3R_168()) {
+    jj_scanpos = xsp;
+    if (jj_3R_169()) {
+    jj_scanpos = xsp;
+    if (jj_3R_170()) {
+    jj_scanpos = xsp;
+    if (jj_3R_171()) {
+    jj_scanpos = xsp;
+    if (jj_3R_172()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_173()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_154() {
+    if (jj_3R_158()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_81() {
+    if (jj_3R_103()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_153() {
+    if (jj_scan_token(MINUS)) return true;
+    if (jj_3R_158()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_152() {
+    if (jj_scan_token(LOGICAL_NOT)) return true;
+    if (jj_3R_145()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_119() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_134() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_115() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_129() {
+    if (jj_scan_token(COMMA)) return true;
+    if (jj_3R_58()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_133() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_80() {
+    if (jj_3R_75()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_131() {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_133()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_3R_109()) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_134()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_161() {
+    if (jj_scan_token(MODULUS)) return true;
+    if (jj_3R_145()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_113() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_151() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_160() {
+    if (jj_scan_token(DIVIDE)) return true;
+    if (jj_3R_145()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_159() {
+    if (jj_scan_token(MULTIPLY)) return true;
+    if (jj_3R_145()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_155() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_159()) {
+    jj_scanpos = xsp;
+    if (jj_3R_160()) {
+    jj_scanpos = xsp;
+    if (jj_3R_161()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_145() {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_151()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_152()) {
+    jj_scanpos = xsp;
+    if (jj_3R_153()) {
+    jj_scanpos = xsp;
+    if (jj_3R_154()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_79() {
+    if (jj_3R_102()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_120() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_78() {
+    if (jj_3R_101()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_118() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_114() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_116() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_123() {
+    if (jj_3R_58()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_129()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_77() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_56() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_77()) {
+    jj_scanpos = xsp;
+    if (jj_3R_78()) {
+    jj_scanpos = xsp;
+    if (jj_3R_79()) {
+    jj_scanpos = xsp;
+    if (jj_3R_80()) {
+    jj_scanpos = xsp;
+    if (jj_3R_81()) {
+    jj_scanpos = xsp;
+    if (jj_3R_82()) {
+    jj_scanpos = xsp;
+    if (jj_3R_83()) {
+    jj_scanpos = xsp;
+    if (jj_3R_84()) {
+    jj_scanpos = xsp;
+    if (jj_3R_85()) {
+    jj_scanpos = xsp;
+    if (jj_3R_86()) return true;
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_103() {
+    if (jj_scan_token(LBRACKET)) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_113()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_114()) {
+    jj_scanpos = xsp;
+    if (jj_3R_115()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_116()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(DOUBLEDOT)) return true;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_117()) { jj_scanpos = xsp; break; }
+    }
+    xsp = jj_scanpos;
+    if (jj_3R_118()) {
+    jj_scanpos = xsp;
+    if (jj_3R_119()) return true;
+    }
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_120()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_141() {
+    if (jj_3R_145()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_155()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_157() {
+    if (jj_scan_token(MINUS)) return true;
+    if (jj_3R_141()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_156() {
+    if (jj_scan_token(PLUS)) return true;
+    if (jj_3R_141()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_146() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_156()) {
+    jj_scanpos = xsp;
+    if (jj_3R_157()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_101() {
+    if (jj_scan_token(WORD)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_57() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_139() {
+    if (jj_3R_141()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_146()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3_12() {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_57()) { jj_scanpos = xsp; break; }
+    }
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(COLON)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_106() {
+    if (jj_scan_token(LBRACKET)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_123()) jj_scanpos = xsp;
+    if (jj_scan_token(RBRACKET)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_150() {
+    if (jj_scan_token(LOGICAL_GE)) return true;
+    if (jj_3R_139()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_149() {
+    if (jj_scan_token(LOGICAL_LE)) return true;
+    if (jj_3R_139()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_98() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(67)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(70)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_148() {
+    if (jj_scan_token(LOGICAL_GT)) return true;
+    if (jj_3R_139()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_142() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_147()) {
+    jj_scanpos = xsp;
+    if (jj_3R_148()) {
+    jj_scanpos = xsp;
+    if (jj_3R_149()) {
+    jj_scanpos = xsp;
+    if (jj_3R_150()) return true;
+    }
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_147() {
+    if (jj_scan_token(LOGICAL_LT)) return true;
+    if (jj_3R_139()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_128() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(33)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_122() {
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_128()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_121() {
+    if (jj_3R_58()) return true;
+    if (jj_scan_token(COLON)) return true;
+    if (jj_3R_58()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_127()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_136() {
+    if (jj_3R_139()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_142()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_144() {
+    if (jj_scan_token(LOGICAL_NOT_EQUALS)) return true;
+    if (jj_3R_136()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_105() {
+    if (jj_scan_token(LEFT_CURLEY)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_121()) {
+    jj_scanpos = xsp;
+    if (jj_3R_122()) return true;
+    }
+    xsp = jj_scanpos;
+    if (jj_scan_token(13)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(73)) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_140() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_143()) {
+    jj_scanpos = xsp;
+    if (jj_3R_144()) return true;
+    }
+    return false;
+  }
+
+  private boolean jj_3R_143() {
+    if (jj_scan_token(LOGICAL_EQUALS)) return true;
+    if (jj_3R_136()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_102() {
+    if (jj_scan_token(STRING_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_132() {
+    if (jj_3R_136()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_140()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_75() {
+    if (jj_scan_token(INTEGER_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_138() {
+    if (jj_scan_token(LOGICAL_AND)) return true;
+    if (jj_3R_132()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_130() {
+    if (jj_3R_132()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_138()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_104() {
+    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_135() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(44)) {
+    jj_scanpos = xsp;
+    if (jj_scan_token(4)) return true;
+    }
+    if (jj_3R_130()) return true;
+    return false;
+  }
+
+  private boolean jj_3R_124() {
+    if (jj_3R_130()) return true;
+    Token xsp;
+    while (true) {
+      xsp = jj_scanpos;
+      if (jj_3R_135()) { jj_scanpos = xsp; break; }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_72() {
+    if (jj_scan_token(SINGLE_LINE_COMMENT_START)) return true;
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(26)) jj_scanpos = xsp;
+    return false;
+  }
+
+  private boolean jj_3R_48() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_3R_72()) {
+    jj_scanpos = xsp;
+    if (jj_3R_73()) {
+    jj_scanpos = xsp;
+    if (jj_3R_74()) return true;
+    }
+    }
+    return false;
+  }
+
+  private boolean jj_3R_74() {
+    if (jj_scan_token(FORMAL_COMMENT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_73() {
+    if (jj_scan_token(MULTI_LINE_COMMENT)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_109() {
+    if (jj_3R_124()) return true;
+    return false;
+  }
+
+  private boolean jj_3_11() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_23() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_10() {
+    if (jj_scan_token(WHITESPACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_4() {
+    if (jj_scan_token(DOUBLE_ESCAPE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_9() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_22() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_8() {
+    if (jj_scan_token(WHITESPACE)) return true;
+    return false;
+  }
+
+  private boolean jj_3R_49() {
+    if (jj_scan_token(ZERO_WIDTH_WHITESPACE)) return true;
+    if (jj_scan_token(0)) return true;
+    return false;
+  }
+
+  private boolean jj_3_3() {
+    if (jj_3R_49()) return true;
+    return false;
+  }
+
+  private boolean jj_3_2() {
+    if (jj_3R_48()) return true;
+    return false;
+  }
+
+  private boolean jj_3_1() {
+    if (jj_3R_47()) return true;
+    return false;
+  }
+
+  private boolean jj_3_21() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  private boolean jj_3_7() {
+    Token xsp;
+    xsp = jj_scanpos;
+    if (jj_scan_token(32)) jj_scanpos = xsp;
+    if (jj_scan_token(NEWLINE)) return true;
+    return false;
+  }
+
+  /** Generated Token Manager. */
+  public StandardParserTokenManager token_source;
+  /** Current token. */
+  public Token token;
+  /** Next token. */
+  public Token jj_nt;
+  private int jj_ntk;
+  private Token jj_scanpos, jj_lastpos;
+  private int jj_la;
+  /** Whether we are looking ahead. */
+  private boolean jj_lookingAhead = false;
+  private boolean jj_semLA;
+  private int jj_gen;
+  final private int[] jj_la1 = new int[107];
+  static private int[] jj_la1_0;
+  static private int[] jj_la1_1;
+  static private int[] jj_la1_2;
+  static {
+      jj_la1_init_0();
+      jj_la1_init_1();
+      jj_la1_init_2();
+   }
+   private static void jj_la1_init_0() {
+      jj_la1_0 = new int[] {0x0,0x20000000,0x20000,0xc022,0x14,0x4000000,0x1a000000,0x0,0x0,0x1080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x4000000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x2000,0x200,0x1080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1080,0x0,0x0,0x200,0x5080,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x20,0x2000,0x0,0xc022,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5080,0x0,0x0,0x0,0x5080,0x0,0x0,};
+   }
+   private static void jj_la1_init_1() {
+      jj_la1_1 = new int[] {0x0,0x0,0x0,0xc00000f,0x0,0x0,0x0,0x0,0x84000008,0x8000030,0x1,0x80000000,0x3,0x3,0x3,0x3,0x3,0x3,0x0,0x3,0x3,0x3,0x3,0x0,0x0,0x3,0x3,0x1,0x1,0x1,0x0,0x3,0x3,0x0,0x0,0xc00003b,0x3,0x3,0x4000000,0x3,0x3,0x3,0x3,0x4000000,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4000008,0x8000030,0x3,0x3,0x0,0xc08007b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000008,0x1,0x3,0x3,0x1,0x1,0x1,0x1,0x1,0x3,0x3,0x1,0x1,0x3,0x3,0x3,0x3,0x1,0x1000,0x1000,0x800,0x60000,0x60000,0x1e000,0x1e000,0xc0,0xc0,0x700,0x700,0x3,0x3,0xc08007b,0x3,0x3,0x4000008,0x8000030,0x3,0x3,};
+   }
+   private static void jj_la1_init_2() {
+      jj_la1_2 = new int[] {0x4000,0x0,0x1000,0x1e380,0x0,0x0,0x0,0x48,0x148,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x148,0x0,0x0,0x148,0x0,0x0,0x0,0x0,0x148,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x148,0x0,0x0,0x0,0x148,0x48,0x0,0x48,0x0,0x48,0x0,0x48,0x0,0x0,0x200,0x148,0x16380,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x148,0x0,0x0,0x148,0x0,0x0,0x0,};
+   }
+  final private JJCalls[] jj_2_rtns = new JJCalls[24];
+  private boolean jj_rescan = false;
+  private int jj_gc = 0;
+
+  /** Constructor with user supplied CharStream. */
+  public StandardParser(CharStream stream) {
+    token_source = new StandardParserTokenManager(this, stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 107; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Reinitialise. */
+  public void ReInit(CharStream stream) {
+    token_source.ReInit(stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_lookingAhead = false;
+    jjtree.reset();
+    jj_gen = 0;
+    for (int i = 0; i < 107; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Constructor with generated Token Manager. */
+  public StandardParser(StandardParserTokenManager tm) {
+    token_source = tm;
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 107; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  /** Reinitialise. */
+  public void ReInit(StandardParserTokenManager tm) {
+    token_source = tm;
+    token = new Token();
+    jj_ntk = -1;
+    jjtree.reset();
+    jj_gen = 0;
+    for (int i = 0; i < 107; i++) jj_la1[i] = -1;
+    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+  }
+
+  private Token jj_consume_token(int kind) throws ParseException {
+    Token oldToken;
+    if ((oldToken = token).next != null) token = token.next;
+    else token = token.next = token_source.getNextToken();
+    jj_ntk = -1;
+    if (token.kind == kind) {
+      jj_gen++;
+      if (++jj_gc > 100) {
+        jj_gc = 0;
+        for (int i = 0; i < jj_2_rtns.length; i++) {
+          JJCalls c = jj_2_rtns[i];
+          while (c != null) {
+            if (c.gen < jj_gen) c.first = null;
+            c = c.next;
+          }
+        }
+      }
+      return token;
+    }
+    token = oldToken;
+    jj_kind = kind;
+    throw generateParseException();
+  }
+
+  static private final class LookaheadSuccess extends java.lang.Error { }
+  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
+  private boolean jj_scan_token(int kind) {
+    if (jj_scanpos == jj_lastpos) {
+      jj_la--;
+      if (jj_scanpos.next == null) {
+        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
+      } else {
+        jj_lastpos = jj_scanpos = jj_scanpos.next;
+      }
+    } else {
+      jj_scanpos = jj_scanpos.next;
+    }
+    if (jj_rescan) {
+      int i = 0; Token tok = token;
+      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
+      if (tok != null) jj_add_error_token(kind, i);
+    }
+    if (jj_scanpos.kind != kind) return true;
+    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+    return false;
+  }
+
+
+/** Get the next Token. */
+  final public Token getNextToken() {
+    if (token.next != null) token = token.next;
+    else token = token.next = token_source.getNextToken();
+    jj_ntk = -1;
+    jj_gen++;
+    return token;
+  }
+
+/** Get the specific Token. */
+  final public Token getToken(int index) {
+    Token t = jj_lookingAhead ? jj_scanpos : token;
+    for (int i = 0; i < index; i++) {
+      if (t.next != null) t = t.next;
+      else t = t.next = token_source.getNextToken();
+    }
+    return t;
+  }
+
+  private int jj_ntk() {
+    if ((jj_nt=token.next) == null)
+      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
+    else
+      return (jj_ntk = jj_nt.kind);
+  }
+
+  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+  private int[] jj_expentry;
+  private int jj_kind = -1;
+  private int[] jj_lasttokens = new int[100];
+  private int jj_endpos;
+
+  private void jj_add_error_token(int kind, int pos) {
+    if (pos >= 100) return;
+    if (pos == jj_endpos + 1) {
+      jj_lasttokens[jj_endpos++] = kind;
+    } else if (jj_endpos != 0) {
+      jj_expentry = new int[jj_endpos];
+      for (int i = 0; i < jj_endpos; i++) {
+        jj_expentry[i] = jj_lasttokens[i];
+      }
+      jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
+        int[] oldentry = (int[])(it.next());
+        if (oldentry.length == jj_expentry.length) {
+          for (int i = 0; i < jj_expentry.length; i++) {
+            if (oldentry[i] != jj_expentry[i]) {
+              continue jj_entries_loop;
+            }
+          }
+          jj_expentries.add(jj_expentry);
+          break jj_entries_loop;
+        }
+      }
+      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+    }
+  }
+
+  /** Generate ParseException. */
+  public ParseException generateParseException() {
+    jj_expentries.clear();
+    boolean[] la1tokens = new boolean[81];
+    if (jj_kind >= 0) {
+      la1tokens[jj_kind] = true;
+      jj_kind = -1;
+    }
+    for (int i = 0; i < 107; i++) {
+      if (jj_la1[i] == jj_gen) {
+        for (int j = 0; j < 32; j++) {
+          if ((jj_la1_0[i] & (1<<j)) != 0) {
+            la1tokens[j] = true;
+          }
+          if ((jj_la1_1[i] & (1<<j)) != 0) {
+            la1tokens[32+j] = true;
+          }
+          if ((jj_la1_2[i] & (1<<j)) != 0) {
+            la1tokens[64+j] = true;
+          }
+        }
+      }
+    }
+    for (int i = 0; i < 81; i++) {
+      if (la1tokens[i]) {
+        jj_expentry = new int[1];
+        jj_expentry[0] = i;
+        jj_expentries.add(jj_expentry);
+      }
+    }
+    jj_endpos = 0;
+    jj_rescan_token();
+    jj_add_error_token(0, 0);
+    int[][] exptokseq = new int[jj_expentries.size()][];
+    for (int i = 0; i < jj_expentries.size(); i++) {
+      exptokseq[i] = jj_expentries.get(i);
+    }
+    return new ParseException(token, exptokseq, tokenImage);
+  }
+
+  /** Enable tracing. */
+  final public void enable_tracing() {
+  }
+
+  /** Disable tracing. */
+  final public void disable_tracing() {
+  }
+
+  private void jj_rescan_token() {
+    jj_rescan = true;
+    for (int i = 0; i < 24; i++) {
+    try {
+      JJCalls p = jj_2_rtns[i];
+      do {
+        if (p.gen > jj_gen) {
+          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
+          switch (i) {
+            case 0: jj_3_1(); break;
+            case 1: jj_3_2(); break;
+            case 2: jj_3_3(); break;
+            case 3: jj_3_4(); break;
+            case 4: jj_3_5(); break;
+            case 5: jj_3_6(); break;
+            case 6: jj_3_7(); break;
+            case 7: jj_3_8(); break;
+            case 8: jj_3_9(); break;
+            case 9: jj_3_10(); break;
+            case 10: jj_3_11(); break;
+            case 11: jj_3_12(); break;
+            case 12: jj_3_13(); break;
+            case 13: jj_3_14(); break;
+            case 14: jj_3_15(); break;
+            case 15: jj_3_16(); break;
+            case 16: jj_3_17(); break;
+            case 17: jj_3_18(); break;
+            case 18: jj_3_19(); break;
+            case 19: jj_3_20(); break;
+            case 20: jj_3_21(); break;
+            case 21: jj_3_22(); break;
+            case 22: jj_3_23(); break;
+            case 23: jj_3_24(); break;
+          }
+        }
+        p = p.next;
+      } while (p != null);
+      } catch(LookaheadSuccess ls) { }
+    }
+    jj_rescan = false;
+  }
+
+  private void jj_save(int index, int xla) {
+    JJCalls p = jj_2_rtns[index];
+    while (p.gen > jj_gen) {
+      if (p.next == null) { p = p.next = new JJCalls(); break; }
+      p = p.next;
+    }
+    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
+  }
+
+  static final class JJCalls {
+    int gen;
+    Token first;
+    int arg;
+    JJCalls next;
+  }
+
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserConstants.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserConstants.java
new file mode 100644
index 00000000..32e97712
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserConstants.java
@@ -0,0 +1,286 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. StandardParserConstants.java */
+package org.apache.velocity.runtime.parser;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface StandardParserConstants {
+
+  /** End of File. */
+  int EOF = 0;
+  /** RegularExpression Id. */
+  int LONE_SYMBOL = 1;
+  /** RegularExpression Id. */
+  int ZERO_WIDTH_WHITESPACE = 2;
+  /** RegularExpression Id. */
+  int INDEX_LBRACKET = 3;
+  /** RegularExpression Id. */
+  int LOGICAL_OR_2 = 4;
+  /** RegularExpression Id. */
+  int PIPE = 5;
+  /** RegularExpression Id. */
+  int INDEX_RBRACKET = 6;
+  /** RegularExpression Id. */
+  int LBRACKET = 7;
+  /** RegularExpression Id. */
+  int RBRACKET = 8;
+  /** RegularExpression Id. */
+  int COMMA = 9;
+  /** RegularExpression Id. */
+  int DOUBLEDOT = 10;
+  /** RegularExpression Id. */
+  int COLON = 11;
+  /** RegularExpression Id. */
+  int LEFT_CURLEY = 12;
+  /** RegularExpression Id. */
+  int RIGHT_CURLEY = 13;
+  /** RegularExpression Id. */
+  int LPAREN = 14;
+  /** RegularExpression Id. */
+  int RPAREN = 15;
+  /** RegularExpression Id. */
+  int REFMOD2_RPAREN = 16;
+  /** RegularExpression Id. */
+  int ESCAPE_DIRECTIVE = 17;
+  /** RegularExpression Id. */
+  int SET_DIRECTIVE = 18;
+  /** RegularExpression Id. */
+  int DOLLAR = 19;
+  /** RegularExpression Id. */
+  int DOLLARBANG = 20;
+  /** RegularExpression Id. */
+  int HASH = 24;
+  /** RegularExpression Id. */
+  int SINGLE_LINE_COMMENT_START = 25;
+  /** RegularExpression Id. */
+  int SINGLE_LINE_COMMENT = 26;
+  /** RegularExpression Id. */
+  int FORMAL_COMMENT = 27;
+  /** RegularExpression Id. */
+  int MULTI_LINE_COMMENT = 28;
+  /** RegularExpression Id. */
+  int TEXTBLOCK = 29;
+  /** RegularExpression Id. */
+  int WHITESPACE = 32;
+  /** RegularExpression Id. */
+  int NEWLINE = 33;
+  /** RegularExpression Id. */
+  int SUFFIX = 34;
+  /** RegularExpression Id. */
+  int STRING_LITERAL = 35;
+  /** RegularExpression Id. */
+  int TRUE = 36;
+  /** RegularExpression Id. */
+  int FALSE = 37;
+  /** RegularExpression Id. */
+  int MINUS = 38;
+  /** RegularExpression Id. */
+  int PLUS = 39;
+  /** RegularExpression Id. */
+  int MULTIPLY = 40;
+  /** RegularExpression Id. */
+  int DIVIDE = 41;
+  /** RegularExpression Id. */
+  int MODULUS = 42;
+  /** RegularExpression Id. */
+  int LOGICAL_AND = 43;
+  /** RegularExpression Id. */
+  int LOGICAL_OR = 44;
+  /** RegularExpression Id. */
+  int LOGICAL_LT = 45;
+  /** RegularExpression Id. */
+  int LOGICAL_LE = 46;
+  /** RegularExpression Id. */
+  int LOGICAL_GT = 47;
+  /** RegularExpression Id. */
+  int LOGICAL_GE = 48;
+  /** RegularExpression Id. */
+  int LOGICAL_EQUALS = 49;
+  /** RegularExpression Id. */
+  int LOGICAL_NOT_EQUALS = 50;
+  /** RegularExpression Id. */
+  int LOGICAL_NOT = 51;
+  /** RegularExpression Id. */
+  int EQUALS = 52;
+  /** RegularExpression Id. */
+  int END = 53;
+  /** RegularExpression Id. */
+  int IF_DIRECTIVE = 54;
+  /** RegularExpression Id. */
+  int ELSEIF = 55;
+  /** RegularExpression Id. */
+  int ELSE = 56;
+  /** RegularExpression Id. */
+  int DIGIT = 57;
+  /** RegularExpression Id. */
+  int INTEGER_LITERAL = 58;
+  /** RegularExpression Id. */
+  int FLOATING_POINT_LITERAL = 59;
+  /** RegularExpression Id. */
+  int EXPONENT = 60;
+  /** RegularExpression Id. */
+  int LETTER = 61;
+  /** RegularExpression Id. */
+  int DIRECTIVE_CHAR = 62;
+  /** RegularExpression Id. */
+  int WORD = 63;
+  /** RegularExpression Id. */
+  int BRACKETED_WORD = 64;
+  /** RegularExpression Id. */
+  int ALPHA_CHAR = 65;
+  /** RegularExpression Id. */
+  int IDENTIFIER_CHAR = 66;
+  /** RegularExpression Id. */
+  int IDENTIFIER = 67;
+  /** RegularExpression Id. */
+  int OLD_ALPHA_CHAR = 68;
+  /** RegularExpression Id. */
+  int OLD_IDENTIFIER_CHAR = 69;
+  /** RegularExpression Id. */
+  int OLD_IDENTIFIER = 70;
+  /** RegularExpression Id. */
+  int DOT = 71;
+  /** RegularExpression Id. */
+  int LCURLY = 72;
+  /** RegularExpression Id. */
+  int RCURLY = 73;
+  /** RegularExpression Id. */
+  int REFERENCE_TERMINATOR = 74;
+  /** RegularExpression Id. */
+  int DIRECTIVE_TERMINATOR = 75;
+  /** RegularExpression Id. */
+  int DOUBLE_ESCAPE = 76;
+  /** RegularExpression Id. */
+  int ESCAPE = 77;
+  /** RegularExpression Id. */
+  int TEXT = 78;
+  /** RegularExpression Id. */
+  int INLINE_TEXT = 79;
+  /** RegularExpression Id. */
+  int EMPTY_INDEX = 80;
+
+  /** Lexical state. */
+  int PRE_DIRECTIVE = 0;
+  /** Lexical state. */
+  int PRE_REFERENCE = 1;
+  /** Lexical state. */
+  int PRE_OLD_REFERENCE = 2;
+  /** Lexical state. */
+  int REFERENCE = 3;
+  /** Lexical state. */
+  int REFMODIFIER = 4;
+  /** Lexical state. */
+  int OLD_REFMODIFIER = 5;
+  /** Lexical state. */
+  int REFMOD3 = 6;
+  /** Lexical state. */
+  int REFINDEX = 7;
+  /** Lexical state. */
+  int DIRECTIVE = 8;
+  /** Lexical state. */
+  int REFMOD2 = 9;
+  /** Lexical state. */
+  int DEFAULT = 10;
+  /** Lexical state. */
+  int REFMOD = 11;
+  /** Lexical state. */
+  int IN_TEXTBLOCK = 12;
+  /** Lexical state. */
+  int IN_MULTILINE_COMMENT = 13;
+  /** Lexical state. */
+  int IN_FORMAL_COMMENT = 14;
+  /** Lexical state. */
+  int IN_SINGLE_LINE_COMMENT = 15;
+  /** Lexical state. */
+  int ALT_VAL = 16;
+  /** Lexical state. */
+  int IN_MULTI_LINE_COMMENT = 17;
+
+  /** Literal token values. */
+  String[] tokenImage = {
+    "<EOF>",
+    "\"\\u001c\"",
+    "\"\\u001c\"",
+    "\"[\"",
+    "\"||\"",
+    "\"|\"",
+    "\"]\"",
+    "\"[\"",
+    "\"]\"",
+    "\",\"",
+    "\"..\"",
+    "\":\"",
+    "\"{\"",
+    "\"}\"",
+    "\"(\"",
+    "\")\"",
+    "\")\"",
+    "<ESCAPE_DIRECTIVE>",
+    "<SET_DIRECTIVE>",
+    "<DOLLAR>",
+    "<DOLLARBANG>",
+    "\"#[[\"",
+    "<token of kind 22>",
+    "\"#*\"",
+    "\"#\"",
+    "\"##\"",
+    "<SINGLE_LINE_COMMENT>",
+    "\"*#\"",
+    "\"*#\"",
+    "\"]]#\"",
+    "<token of kind 30>",
+    "<token of kind 31>",
+    "<WHITESPACE>",
+    "<NEWLINE>",
+    "<SUFFIX>",
+    "<STRING_LITERAL>",
+    "\"true\"",
+    "\"false\"",
+    "\"-\"",
+    "\"+\"",
+    "\"*\"",
+    "\"/\"",
+    "\"%\"",
+    "<LOGICAL_AND>",
+    "<LOGICAL_OR>",
+    "<LOGICAL_LT>",
+    "<LOGICAL_LE>",
+    "<LOGICAL_GT>",
+    "<LOGICAL_GE>",
+    "<LOGICAL_EQUALS>",
+    "<LOGICAL_NOT_EQUALS>",
+    "<LOGICAL_NOT>",
+    "\"=\"",
+    "<END>",
+    "<IF_DIRECTIVE>",
+    "<ELSEIF>",
+    "<ELSE>",
+    "<DIGIT>",
+    "<INTEGER_LITERAL>",
+    "<FLOATING_POINT_LITERAL>",
+    "<EXPONENT>",
+    "<LETTER>",
+    "<DIRECTIVE_CHAR>",
+    "<WORD>",
+    "<BRACKETED_WORD>",
+    "<ALPHA_CHAR>",
+    "<IDENTIFIER_CHAR>",
+    "<IDENTIFIER>",
+    "<OLD_ALPHA_CHAR>",
+    "<OLD_IDENTIFIER_CHAR>",
+    "<OLD_IDENTIFIER>",
+    "<DOT>",
+    "\"{\"",
+    "\"}\"",
+    "<REFERENCE_TERMINATOR>",
+    "<DIRECTIVE_TERMINATOR>",
+    "\"\\\\\\\\\"",
+    "\"\\\\\"",
+    "<TEXT>",
+    "<INLINE_TEXT>",
+    "<EMPTY_INDEX>",
+  };
+
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserTokenManager.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserTokenManager.java
new file mode 100644
index 00000000..82761fef
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/StandardParserTokenManager.java
@@ -0,0 +1,8749 @@
+/* Generated By:JJTree&JavaCC: Do not edit this line. StandardParserTokenManager.java */
+package org.apache.velocity.runtime.parser;
+import org.apache.velocity.runtime.parser.node.*;
+import java.io.*;
+import java.util.*;
+import org.apache.velocity.Template;
+import org.apache.velocity.exception.VelocityException;
+import org.apache.velocity.runtime.RuntimeServices;
+import org.apache.velocity.runtime.parser.*;
+import org.apache.velocity.runtime.parser.node.*;
+import org.apache.velocity.runtime.directive.*;
+import org.apache.velocity.runtime.directive.MacroParseException;
+import org.apache.velocity.runtime.RuntimeConstants;
+import static org.apache.velocity.runtime.RuntimeConstants.SpaceGobbling;
+import org.slf4j.Logger;
+
+/** Token Manager. */
+public class StandardParserTokenManager implements StandardParserConstants
+{
+    private int fileDepth = 0;
+
+    private int lparen = 0;
+    private int rparen = 0;
+    private int curlyLevel = 0;
+    List stateStack = new ArrayList(50);
+
+    private boolean inComment;
+    private boolean inSet;
+
+    /**
+     * Our own trace method. Use sparsingly in production, since each
+     * and every call will introduce an execution branch and slow down parsing.
+     */
+    public static void trace(String message)
+    {
+        StandardParser.trace(message);
+    }
+
+    /**
+     * Switches to a new state (add some log to the default method)
+     */
+     public void switchTo(int lexState)
+     {
+        trace(" switch to " + lexStateNames[lexState]);
+        SwitchTo(lexState);
+     }
+
+    public int getCurrentLexicalState()
+    {
+        return curLexState;
+    }
+
+    /**
+     *  pops a state off the stack, and restores paren counts
+     *
+     *  @return boolean : success of operation
+     */
+    public boolean stateStackPop()
+    {
+        ParserState s;
+        try
+        {
+            s = (ParserState) stateStack.remove(stateStack.size() - 1); // stack.pop
+        }
+        catch(IndexOutOfBoundsException e)
+        {
+            // empty stack
+            lparen=0;
+            switchTo(DEFAULT);
+            return false;
+        }
+
+        trace(" stack pop (" + stateStack.size() + ")");
+        lparen = s.lparen;
+        rparen = s.rparen;
+        curlyLevel = s.curlyLevel;
+
+        switchTo(s.lexstate);
+
+        return true;
+    }
+
+    /**
+     *  pushes the current state onto the 'state stack',
+     *  and maintains the parens counts
+     *  public because we need it in PD &amp; VM handling
+     *
+     *  @return boolean : success.  It can fail if the state machine
+     *     gets messed up (do don't mess it up :)
+     */
+    public boolean stateStackPush()
+    {
+        trace(" (" + stateStack.size() + ") pushing cur state : " + lexStateNames[curLexState] );
+
+        ParserState s = new ParserState();
+        s.lparen = lparen;
+        s.rparen = rparen;
+        s.curlyLevel = curlyLevel;
+        s.lexstate = curLexState;
+
+        stateStack.add(s); // stack.push
+
+        lparen = 0;
+        curlyLevel = 0;
+
+        return true;
+    }
+
+    /**
+     *  Clears all state variables, resets to
+     *  start values, clears stateStack.  Call
+     *  before parsing.
+     */
+    public void clearStateVars()
+    {
+        stateStack.clear();
+
+        lparen = 0;
+        rparen = 0;
+        curlyLevel = 0;
+        inComment = false;
+        inSet = false;
+
+        return;
+    }
+
+    public void setInSet(boolean value)
+    {
+        inSet = value;
+    }
+
+    public boolean isInSet()
+    {
+        return inSet;
+    }
+
+    /**
+     * Holds the state of the parsing process.
+     */
+    private static class ParserState
+    {
+        int lparen;
+        int rparen;
+        int curlyLevel;
+        int lexstate;
+    }
+
+    /**
+     *  handles the dropdown logic when encountering a RPAREN
+     */
+    private void RPARENHandler()
+    {
+        /*
+         *  Ultimately, we want to drop down to the state below
+         *  the one that has an open (if we hit bottom (DEFAULT),
+         *  that's fine. It's just text schmoo.
+         */
+
+        boolean closed = false;
+
+        if (inComment)
+            closed = true;
+
+        while( !closed )
+        {
+            /*
+             * look at current state.  If we haven't seen a lparen
+             * in this state then we drop a state, because this
+             * lparen clearly closes our state
+             */
+
+            if( lparen > 0)
+            {
+                /*
+                 *  if rparen + 1 == lparen, then this state is closed.
+                 * Otherwise, increment and keep parsing
+                 */
+
+                 if( lparen == rparen + 1)
+                 {
+                       stateStackPop();
+                 }
+                else
+                {
+                    rparen++;
+                }
+
+                 closed = true;
+            }
+            else
+            {
+                /*
+                 * now, drop a state
+                 */
+
+                if(!stateStackPop())
+                    break;
+            }
+        }
+    }
+
+  /** Debug output. */
+  public  java.io.PrintStream debugStream = System.out;
+  /** Set debug output. */
+  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+
+  /** The parser. */
+  public StandardParser parser = null;
+private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 15;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 21;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_3(int pos, long active0, long active1)
+{
+   return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1), pos + 1);
+}
+private int jjStopAtPos(int pos, int kind)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   return pos + 1;
+}
+private int jjMoveStringLiteralDfa0_3()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_3(0x2a00000L);
+      case 91:
+         return jjStopAtPos(0, 3);
+      case 102:
+         return jjMoveStringLiteralDfa1_3(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_3(0x1000000000L);
+      case 123:
+         return jjStopAtPos(0, 72);
+      case 124:
+         jjmatchedKind = 5;
+         return jjMoveStringLiteralDfa1_3(0x10L);
+      case 125:
+         return jjStopAtPos(0, 73);
+      default :
+         return jjMoveNfa_3(0, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_3(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_3(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_3(1, 23, 21);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_3(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_3(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_3(active0, 0x1000000000L);
+      case 124:
+         if ((active0 & 0x10L) != 0L)
+            return jjStopAtPos(1, 4);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_3(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_3(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_3(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_3(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_3(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_3(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_3(1, active0, 0L);
+}
+private int jjMoveStringLiteralDfa3_3(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_3(1, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_3(2, active0, 0L);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStopAtPos(3, 36);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_3(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_3(2, active0, 0L);
+}
+private int jjMoveStringLiteralDfa4_3(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_3(2, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_3(3, active0, 0L);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStopAtPos(4, 37);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_3(3, active0, 0L);
+}
+private int jjStartNfaWithStates_3(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_3(state, pos + 1);
+}
+static final long[] jjbitVec0 = {
+   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+static final long[] jjbitVec2 = {
+   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private int jjMoveNfa_3(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 24;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if (curChar == 35)
+                     jjAddStates(0, 2);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(7, 8);
+                  }
+                  else if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 15:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 4:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 6:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 8:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 9:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 10:
+                  if (curChar == 35)
+                     jjAddStates(0, 2);
+                  break;
+               case 12:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(3, 4);
+                  break;
+               case 13:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 21:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if (curChar == 92)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 15:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 14;
+                  break;
+               case 1:
+                  if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+                     kind = 71;
+                  break;
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(3, 4);
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjAddStates(9, 10);
+                  break;
+               case 11:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 14:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 11;
+                  break;
+               case 16:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 17:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 16;
+                  break;
+               case 18:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 17;
+                  break;
+               case 19:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 20:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  break;
+               case 22:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 22:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_0(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 2;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_0(int pos, long active0)
+{
+   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_0()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 1);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_0(0x2a00000L);
+      default :
+         return jjMoveNfa_0(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_0(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_0(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_0(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_0(0, active0);
+}
+private int jjMoveStringLiteralDfa2_0(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_0(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_0(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_0(1, active0);
+}
+private int jjStartNfaWithStates_0(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_0(state, pos + 1);
+}
+private int jjMoveNfa_0(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 75;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddStates(11, 16);
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 34)
+                        kind = 34;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                     jjCheckNAddStates(17, 19);
+                  else if (curChar == 45)
+                     jjCheckNAddStates(20, 23);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(26, 27);
+                  }
+                  else if (curChar == 46)
+                     jjCheckNAdd(11);
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 4:
+                  if ((0x100000200L & l) != 0L)
+                     jjCheckNAddStates(17, 19);
+                  break;
+               case 5:
+                  if ((0x2400L & l) != 0L && kind > 34)
+                     kind = 34;
+                  break;
+               case 6:
+                  if (curChar == 10 && kind > 34)
+                     kind = 34;
+                  break;
+               case 7:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 10:
+                  if (curChar == 46)
+                     jjCheckNAdd(11);
+                  break;
+               case 11:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(11, 12);
+                  break;
+               case 13:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(14);
+                  break;
+               case 14:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(14);
+                  break;
+               case 16:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 63)
+                     kind = 63;
+                  jjstateSet[jjnewStateCnt++] = 16;
+                  break;
+               case 19:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjAddStates(24, 25);
+                  break;
+               case 23:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 25:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(26, 27);
+                  break;
+               case 27:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 28:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(26, 27);
+                  break;
+               case 60:
+                  if (curChar == 45)
+                     jjCheckNAddStates(20, 23);
+                  break;
+               case 61:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddTwoStates(61, 63);
+                  break;
+               case 62:
+                  if (curChar == 46 && kind > 58)
+                     kind = 58;
+                  break;
+               case 63:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 62;
+                  break;
+               case 64:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(64, 65);
+                  break;
+               case 65:
+                  if (curChar != 46)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 66:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 68:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(69);
+                  break;
+               case 69:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(69);
+                  break;
+               case 70:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(70, 71);
+                  break;
+               case 72:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(73);
+                  break;
+               case 73:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(73);
+                  break;
+               case 74:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddStates(11, 16);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if ((0x7fffffe87ffffffL & l) != 0L)
+                  {
+                     if (kind > 63)
+                        kind = 63;
+                     jjCheckNAdd(16);
+                  }
+                  else if (curChar == 123)
+                     jjAddStates(26, 29);
+                  else if (curChar == 92)
+                     jjCheckNAddStates(30, 33);
+                  if (curChar == 101)
+                     jjAddStates(34, 36);
+                  else if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  else if (curChar == 105)
+                     jjstateSet[jjnewStateCnt++] = 8;
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 8:
+                  if (curChar == 102 && kind > 54)
+                     kind = 54;
+                  break;
+               case 9:
+                  if (curChar == 105)
+                     jjstateSet[jjnewStateCnt++] = 8;
+                  break;
+               case 12:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(37, 38);
+                  break;
+               case 15:
+                  if ((0x7fffffe87ffffffL & l) == 0L)
+                     break;
+                  if (kind > 63)
+                     kind = 63;
+                  jjCheckNAdd(16);
+                  break;
+               case 16:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 63)
+                     kind = 63;
+                  jjCheckNAdd(16);
+                  break;
+               case 17:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 18:
+                  if ((0x7fffffe87ffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(19, 20);
+                  break;
+               case 19:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                     jjCheckNAddTwoStates(19, 20);
+                  break;
+               case 20:
+                  if (curChar == 125 && kind > 64)
+                     kind = 64;
+                  break;
+               case 21:
+                  if (curChar == 92)
+                     jjCheckNAddStates(30, 33);
+                  break;
+               case 22:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(22, 23);
+                  break;
+               case 24:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(24, 25);
+                  break;
+               case 26:
+                  if (curChar == 92)
+                     jjAddStates(39, 40);
+                  break;
+               case 29:
+                  if (curChar == 101)
+                     jjAddStates(34, 36);
+                  break;
+               case 30:
+                  if (curChar == 100 && kind > 53)
+                     kind = 53;
+                  break;
+               case 31:
+                  if (curChar == 110)
+                     jjstateSet[jjnewStateCnt++] = 30;
+                  break;
+               case 32:
+                  if (curChar == 102 && kind > 55)
+                     kind = 55;
+                  break;
+               case 33:
+                  if (curChar == 105)
+                     jjstateSet[jjnewStateCnt++] = 32;
+                  break;
+               case 34:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 33;
+                  break;
+               case 35:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  break;
+               case 36:
+                  if (curChar == 108)
+                     jjstateSet[jjnewStateCnt++] = 35;
+                  break;
+               case 37:
+                  if (curChar == 101 && kind > 56)
+                     kind = 56;
+                  break;
+               case 38:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 39:
+                  if (curChar == 108)
+                     jjstateSet[jjnewStateCnt++] = 38;
+                  break;
+               case 40:
+                  if (curChar == 123)
+                     jjAddStates(26, 29);
+                  break;
+               case 41:
+                  if (curChar == 125 && kind > 53)
+                     kind = 53;
+                  break;
+               case 42:
+                  if (curChar == 100)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  break;
+               case 43:
+                  if (curChar == 110)
+                     jjstateSet[jjnewStateCnt++] = 42;
+                  break;
+               case 44:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 43;
+                  break;
+               case 45:
+                  if (curChar == 125 && kind > 54)
+                     kind = 54;
+                  break;
+               case 46:
+                  if (curChar == 102)
+                     jjstateSet[jjnewStateCnt++] = 45;
+                  break;
+               case 47:
+                  if (curChar == 105)
+                     jjstateSet[jjnewStateCnt++] = 46;
+                  break;
+               case 48:
+                  if (curChar == 125 && kind > 55)
+                     kind = 55;
+                  break;
+               case 49:
+                  if (curChar == 102)
+                     jjstateSet[jjnewStateCnt++] = 48;
+                  break;
+               case 50:
+                  if (curChar == 105)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  break;
+               case 51:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 50;
+                  break;
+               case 52:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  break;
+               case 53:
+                  if (curChar == 108)
+                     jjstateSet[jjnewStateCnt++] = 52;
+                  break;
+               case 54:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 55:
+                  if (curChar == 125 && kind > 56)
+                     kind = 56;
+                  break;
+               case 56:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 55;
+                  break;
+               case 57:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 56;
+                  break;
+               case 58:
+                  if (curChar == 108)
+                     jjstateSet[jjnewStateCnt++] = 57;
+                  break;
+               case 59:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 58;
+                  break;
+               case 67:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(41, 42);
+                  break;
+               case 71:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(43, 44);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_16(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x4000000000L) != 0L)
+            return 94;
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         if ((active0 & 0x400L) != 0L)
+            return 57;
+         if ((active0 & 0x10000000000000L) != 0L)
+            return 49;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_16(int pos, long active0)
+{
+   return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_16()
+{
+   switch(curChar)
+   {
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_16(0xa00000L);
+      case 37:
+         return jjStopAtPos(0, 42);
+      case 42:
+         return jjStopAtPos(0, 40);
+      case 43:
+         return jjStopAtPos(0, 39);
+      case 44:
+         return jjStopAtPos(0, 9);
+      case 45:
+         return jjStartNfaWithStates_16(0, 38, 94);
+      case 46:
+         return jjMoveStringLiteralDfa1_16(0x400L);
+      case 47:
+         return jjStopAtPos(0, 41);
+      case 58:
+         return jjStopAtPos(0, 11);
+      case 61:
+         return jjStartNfaWithStates_16(0, 52, 49);
+      case 91:
+         return jjStopAtPos(0, 7);
+      case 93:
+         return jjStopAtPos(0, 8);
+      case 102:
+         return jjMoveStringLiteralDfa1_16(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_16(0x1000000000L);
+      case 123:
+         return jjStopAtPos(0, 12);
+      case 125:
+         return jjStopAtPos(0, 13);
+      default :
+         return jjMoveNfa_16(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_16(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_16(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_16(1, 23, 0);
+         break;
+      case 46:
+         if ((active0 & 0x400L) != 0L)
+            return jjStopAtPos(1, 10);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_16(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_16(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_16(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_16(0, active0);
+}
+private int jjMoveStringLiteralDfa2_16(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_16(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_16(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_16(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_16(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_16(1, active0);
+}
+private int jjMoveStringLiteralDfa3_16(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_16(1, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_16(2, active0);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStopAtPos(3, 36);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_16(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_16(2, active0);
+}
+private int jjMoveStringLiteralDfa4_16(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_16(2, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_16(3, active0);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStopAtPos(4, 37);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_16(3, active0);
+}
+private int jjStartNfaWithStates_16(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_16(state, pos + 1);
+}
+private int jjMoveNfa_16(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 94;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 94:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(89, 90);
+                  else if (curChar == 46)
+                     jjCheckNAdd(57);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(83, 84);
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddTwoStates(80, 82);
+                  }
+                  break;
+               case 3:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddStates(45, 50);
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 33)
+                        kind = 33;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                  {
+                     if (kind > 32)
+                        kind = 32;
+                     jjCheckNAdd(4);
+                  }
+                  else if (curChar == 45)
+                     jjCheckNAddStates(51, 54);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(66, 67);
+                  }
+                  else if (curChar == 46)
+                     jjCheckNAdd(57);
+                  else if (curChar == 33)
+                  {
+                     if (kind > 51)
+                        kind = 51;
+                  }
+                  else if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  else if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  else if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  else if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  else if (curChar == 39)
+                     jjCheckNAddStates(55, 58);
+                  else if (curChar == 34)
+                     jjCheckNAddStates(59, 62);
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  else if (curChar == 62)
+                  {
+                     if (kind > 47)
+                        kind = 47;
+                  }
+                  else if (curChar == 60)
+                  {
+                     if (kind > 45)
+                        kind = 45;
+                  }
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 4:
+                  if ((0x100000200L & l) == 0L)
+                     break;
+                  if (kind > 32)
+                     kind = 32;
+                  jjCheckNAdd(4);
+                  break;
+               case 5:
+                  if ((0x2400L & l) != 0L && kind > 33)
+                     kind = 33;
+                  break;
+               case 6:
+                  if (curChar == 10 && kind > 33)
+                     kind = 33;
+                  break;
+               case 7:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 8:
+               case 10:
+                  if (curChar == 34)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 9:
+                  if ((0xfffffffbefffffffL & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 11:
+                  if (curChar == 34)
+                     jjstateSet[jjnewStateCnt++] = 10;
+                  break;
+               case 12:
+                  if (curChar == 34 && kind > 35)
+                     kind = 35;
+                  break;
+               case 15:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(63, 67);
+                  break;
+               case 16:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 17:
+                  if ((0xf000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 18:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAdd(16);
+                  break;
+               case 20:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 21:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 24:
+                  if (curChar == 32)
+                     jjAddStates(68, 69);
+                  break;
+               case 25:
+                  if (curChar == 10)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 26:
+               case 28:
+                  if (curChar == 39)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 27:
+                  if ((0xffffff7fefffffffL & l) != 0L)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 29:
+                  if (curChar == 39)
+                     jjstateSet[jjnewStateCnt++] = 28;
+                  break;
+               case 31:
+                  if (curChar == 32)
+                     jjAddStates(70, 71);
+                  break;
+               case 32:
+                  if (curChar == 10)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 33:
+                  if (curChar == 39 && kind > 35)
+                     kind = 35;
+                  break;
+               case 34:
+                  if (curChar == 38 && kind > 43)
+                     kind = 43;
+                  break;
+               case 35:
+                  if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  break;
+               case 43:
+                  if (curChar == 60 && kind > 45)
+                     kind = 45;
+                  break;
+               case 44:
+                  if (curChar == 61 && kind > 46)
+                     kind = 46;
+                  break;
+               case 45:
+                  if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  break;
+               case 46:
+                  if (curChar == 62 && kind > 47)
+                     kind = 47;
+                  break;
+               case 47:
+                  if (curChar == 61 && kind > 48)
+                     kind = 48;
+                  break;
+               case 48:
+                  if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  break;
+               case 49:
+                  if (curChar == 61 && kind > 49)
+                     kind = 49;
+                  break;
+               case 50:
+                  if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  break;
+               case 53:
+                  if (curChar == 61 && kind > 50)
+                     kind = 50;
+                  break;
+               case 54:
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 55:
+                  if (curChar == 33 && kind > 51)
+                     kind = 51;
+                  break;
+               case 56:
+                  if (curChar == 46)
+                     jjCheckNAdd(57);
+                  break;
+               case 57:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(57, 58);
+                  break;
+               case 59:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(60);
+                  break;
+               case 60:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(60);
+                  break;
+               case 63:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 65:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 67:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 68:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 79:
+                  if (curChar == 45)
+                     jjCheckNAddStates(51, 54);
+                  break;
+               case 80:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddTwoStates(80, 82);
+                  break;
+               case 81:
+                  if (curChar == 46 && kind > 58)
+                     kind = 58;
+                  break;
+               case 82:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 81;
+                  break;
+               case 83:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(83, 84);
+                  break;
+               case 84:
+                  if (curChar != 46)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 85:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 87:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(88);
+                  break;
+               case 88:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(88);
+                  break;
+               case 89:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(89, 90);
+                  break;
+               case 91:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(92);
+                  break;
+               case 92:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(92);
+                  break;
+               case 93:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddStates(45, 50);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 110)
+                     jjAddStates(72, 73);
+                  else if (curChar == 103)
+                     jjAddStates(74, 75);
+                  else if (curChar == 108)
+                     jjAddStates(76, 77);
+                  else if (curChar == 92)
+                     jjCheckNAddStates(78, 81);
+                  else if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  else if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  else if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 39;
+                  else if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 9:
+                  jjCheckNAddStates(59, 62);
+                  break;
+               case 13:
+                  if (curChar == 92)
+                     jjAddStates(82, 87);
+                  break;
+               case 14:
+                  if ((0x14404400000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 19:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 20:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 21:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 27:
+                  jjAddStates(55, 58);
+                  break;
+               case 30:
+                  if (curChar == 92)
+                     jjAddStates(70, 71);
+                  break;
+               case 36:
+                  if (curChar == 100 && kind > 43)
+                     kind = 43;
+                  break;
+               case 37:
+                  if (curChar == 110)
+                     jjstateSet[jjnewStateCnt++] = 36;
+                  break;
+               case 38:
+                  if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 39:
+                  if (curChar == 124 && kind > 44)
+                     kind = 44;
+                  break;
+               case 40:
+                  if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 39;
+                  break;
+               case 41:
+                  if (curChar == 114 && kind > 44)
+                     kind = 44;
+                  break;
+               case 42:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  break;
+               case 51:
+                  if (curChar == 113 && kind > 49)
+                     kind = 49;
+                  break;
+               case 52:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  break;
+               case 58:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(88, 89);
+                  break;
+               case 61:
+                  if (curChar == 92)
+                     jjCheckNAddStates(78, 81);
+                  break;
+               case 62:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(62, 63);
+                  break;
+               case 64:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(64, 65);
+                  break;
+               case 66:
+                  if (curChar == 92)
+                     jjAddStates(90, 91);
+                  break;
+               case 69:
+                  if (curChar == 108)
+                     jjAddStates(76, 77);
+                  break;
+               case 70:
+                  if (curChar == 116 && kind > 45)
+                     kind = 45;
+                  break;
+               case 71:
+                  if (curChar == 101 && kind > 46)
+                     kind = 46;
+                  break;
+               case 72:
+                  if (curChar == 103)
+                     jjAddStates(74, 75);
+                  break;
+               case 73:
+                  if (curChar == 116 && kind > 47)
+                     kind = 47;
+                  break;
+               case 74:
+                  if (curChar == 101 && kind > 48)
+                     kind = 48;
+                  break;
+               case 75:
+                  if (curChar == 110)
+                     jjAddStates(72, 73);
+                  break;
+               case 76:
+                  if (curChar == 101 && kind > 50)
+                     kind = 50;
+                  break;
+               case 77:
+                  if (curChar == 116 && kind > 51)
+                     kind = 51;
+                  break;
+               case 78:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 77;
+                  break;
+               case 86:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(92, 93);
+                  break;
+               case 90:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(94, 95);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               case 9:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(59, 62);
+                  break;
+               case 27:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(55, 58);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_12(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         if ((active0 & 0x20000000L) != 0L)
+         {
+            jjmatchedKind = 31;
+            return -1;
+         }
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         if ((active0 & 0x20000000L) != 0L)
+         {
+            if (jjmatchedPos == 0)
+            {
+               jjmatchedKind = 31;
+               jjmatchedPos = 0;
+            }
+            return -1;
+         }
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_12(int pos, long active0)
+{
+   return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_12()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_12(0xa00000L);
+      case 93:
+         return jjMoveStringLiteralDfa1_12(0x20000000L);
+      default :
+         return jjMoveNfa_12(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_12(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_12(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_12(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_12(active0, 0x200000L);
+      case 93:
+         return jjMoveStringLiteralDfa2_12(active0, 0x20000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_12(0, active0);
+}
+private int jjMoveStringLiteralDfa2_12(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_12(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_12(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x20000000L) != 0L)
+            return jjStopAtPos(2, 29);
+         break;
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_12(1, active0);
+}
+private int jjStartNfaWithStates_12(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_12(state, pos + 1);
+}
+private int jjMoveNfa_12(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 13;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                  {
+                     if (kind > 31)
+                        kind = 31;
+                  }
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(10, 11);
+                  }
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 4:
+                  if ((0xffffffffefffffffL & l) != 0L && kind > 31)
+                     kind = 31;
+                  break;
+               case 7:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 9:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(10, 11);
+                  break;
+               case 11:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 12:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(10, 11);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (kind > 31)
+                     kind = 31;
+                  if (curChar == 92)
+                     jjCheckNAddStates(96, 99);
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 4:
+                  if (kind > 31)
+                     kind = 31;
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddStates(96, 99);
+                  break;
+               case 6:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(6, 7);
+                  break;
+               case 8:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(8, 9);
+                  break;
+               case 10:
+                  if (curChar == 92)
+                     jjAddStates(100, 101);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 31)
+                     kind = 31;
+                  break;
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_15(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_15(int pos, long active0)
+{
+   return jjMoveNfa_15(jjStopStringLiteralDfa_15(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_15()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_15(0xa00000L);
+      default :
+         return jjMoveNfa_15(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_15(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_15(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_15(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_15(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_15(0, active0);
+}
+private int jjMoveStringLiteralDfa2_15(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_15(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_15(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_15(1, active0);
+}
+private int jjStartNfaWithStates_15(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_15(state, pos + 1);
+}
+private int jjMoveNfa_15(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 15;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 26)
+                        kind = 26;
+                  }
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(12, 13);
+                  }
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 5;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 4:
+                  if ((0x2400L & l) != 0L && kind > 26)
+                     kind = 26;
+                  break;
+               case 5:
+                  if (curChar == 10 && kind > 26)
+                     kind = 26;
+                  break;
+               case 6:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 5;
+                  break;
+               case 9:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 11:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 13:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 14:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(12, 13);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddStates(102, 105);
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 8:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(8, 9);
+                  break;
+               case 10:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(10, 11);
+                  break;
+               case 12:
+                  if (curChar == 92)
+                     jjAddStates(3, 4);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 70;
+            return 1;
+         }
+         if ((active0 & 0x3a00000L) != 0L)
+            return 17;
+         return -1;
+      case 1:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 70;
+            jjmatchedPos = 1;
+            return 1;
+         }
+         if ((active0 & 0x800000L) != 0L)
+            return 23;
+         return -1;
+      case 2:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 70;
+            jjmatchedPos = 2;
+            return 1;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x2000000000L) != 0L)
+         {
+            jjmatchedKind = 70;
+            jjmatchedPos = 3;
+            return 1;
+         }
+         if ((active0 & 0x1000000000L) != 0L)
+            return 1;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_5(int pos, long active0, long active1)
+{
+   return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_5()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_5(0x2a00000L);
+      case 40:
+         return jjStopAtPos(0, 14);
+      case 91:
+         return jjStopAtPos(0, 3);
+      case 102:
+         return jjMoveStringLiteralDfa1_5(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_5(0x1000000000L);
+      case 123:
+         return jjStopAtPos(0, 72);
+      case 124:
+         jjmatchedKind = 5;
+         return jjMoveStringLiteralDfa1_5(0x10L);
+      case 125:
+         return jjStopAtPos(0, 73);
+      default :
+         return jjMoveNfa_5(0, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_5(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_5(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_5(1, 23, 23);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_5(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_5(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_5(active0, 0x1000000000L);
+      case 124:
+         if ((active0 & 0x10L) != 0L)
+            return jjStopAtPos(1, 4);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_5(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_5(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_5(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_5(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_5(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_5(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_5(1, active0, 0L);
+}
+private int jjMoveStringLiteralDfa3_5(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_5(1, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_5(2, active0, 0L);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStartNfaWithStates_5(3, 36, 1);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_5(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_5(2, active0, 0L);
+}
+private int jjMoveStringLiteralDfa4_5(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_5(2, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_5(3, active0, 0L);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStartNfaWithStates_5(4, 37, 1);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_5(3, active0, 0L);
+}
+private int jjStartNfaWithStates_5(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_5(state, pos + 1);
+}
+private int jjMoveNfa_5(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 26;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if (curChar == 35)
+                     jjAddStates(106, 108);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(9, 10);
+                  }
+                  else if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 3;
+                  break;
+               case 17:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 1:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 70)
+                     kind = 70;
+                  jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 2:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 3;
+                  break;
+               case 6:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 8:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 11:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 12:
+                  if (curChar == 35)
+                     jjAddStates(106, 108);
+                  break;
+               case 14:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(109, 110);
+                  break;
+               case 15:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 23:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 24:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 70)
+                        kind = 70;
+                     jjCheckNAdd(1);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 17:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 16;
+                  break;
+               case 1:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 70)
+                     kind = 70;
+                  jjCheckNAdd(1);
+                  break;
+               case 3:
+                  if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+                     kind = 71;
+                  break;
+               case 4:
+                  if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(115, 116);
+                  break;
+               case 13:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(14, 15);
+                  break;
+               case 16:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 13;
+                  break;
+               case 18:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(14, 15);
+                  break;
+               case 19:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 20:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  break;
+               case 21:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 22:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 24:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 24:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_8(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 2;
+         if ((active0 & 0x400L) != 0L)
+            return 57;
+         if ((active0 & 0x4000000000L) != 0L)
+            return 100;
+         if ((active0 & 0x10000000000000L) != 0L)
+            return 49;
+         if ((active0 & 0x1000L) != 0L)
+            return 64;
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 63;
+            return 62;
+         }
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 63;
+            jjmatchedPos = 1;
+            return 62;
+         }
+         return -1;
+      case 2:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 63;
+            jjmatchedPos = 2;
+            return 62;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x1000000000L) != 0L)
+            return 62;
+         if ((active0 & 0x2000000000L) != 0L)
+         {
+            jjmatchedKind = 63;
+            jjmatchedPos = 3;
+            return 62;
+         }
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_8(int pos, long active0)
+{
+   return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_8()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_8(0x2a00000L);
+      case 37:
+         return jjStopAtPos(0, 42);
+      case 40:
+         return jjStopAtPos(0, 14);
+      case 41:
+         return jjStopAtPos(0, 15);
+      case 42:
+         return jjStopAtPos(0, 40);
+      case 43:
+         return jjStopAtPos(0, 39);
+      case 44:
+         return jjStopAtPos(0, 9);
+      case 45:
+         return jjStartNfaWithStates_8(0, 38, 100);
+      case 46:
+         return jjMoveStringLiteralDfa1_8(0x400L);
+      case 47:
+         return jjStopAtPos(0, 41);
+      case 58:
+         return jjStopAtPos(0, 11);
+      case 61:
+         return jjStartNfaWithStates_8(0, 52, 49);
+      case 91:
+         return jjStopAtPos(0, 7);
+      case 93:
+         return jjStopAtPos(0, 8);
+      case 102:
+         return jjMoveStringLiteralDfa1_8(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_8(0x1000000000L);
+      case 123:
+         return jjStartNfaWithStates_8(0, 12, 64);
+      case 125:
+         return jjStopAtPos(0, 13);
+      default :
+         return jjMoveNfa_8(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_8(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_8(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_8(1, 23, 0);
+         break;
+      case 46:
+         if ((active0 & 0x400L) != 0L)
+            return jjStopAtPos(1, 10);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_8(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_8(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_8(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_8(0, active0);
+}
+private int jjMoveStringLiteralDfa2_8(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_8(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_8(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_8(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_8(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_8(1, active0);
+}
+private int jjMoveStringLiteralDfa3_8(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_8(1, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_8(2, active0);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStartNfaWithStates_8(3, 36, 62);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_8(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_8(2, active0);
+}
+private int jjMoveStringLiteralDfa4_8(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_8(2, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_8(3, active0);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStartNfaWithStates_8(4, 37, 62);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_8(3, active0);
+}
+private int jjStartNfaWithStates_8(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_8(state, pos + 1);
+}
+private int jjMoveNfa_8(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 100;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddStates(117, 122);
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 33)
+                        kind = 33;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                  {
+                     if (kind > 32)
+                        kind = 32;
+                     jjCheckNAdd(4);
+                  }
+                  else if (curChar == 45)
+                     jjCheckNAddStates(123, 126);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(72, 73);
+                  }
+                  else if (curChar == 46)
+                     jjCheckNAdd(57);
+                  else if (curChar == 33)
+                  {
+                     if (kind > 51)
+                        kind = 51;
+                  }
+                  else if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  else if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  else if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  else if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  else if (curChar == 39)
+                     jjCheckNAddStates(55, 58);
+                  else if (curChar == 34)
+                     jjCheckNAddStates(59, 62);
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  else if (curChar == 62)
+                  {
+                     if (kind > 47)
+                        kind = 47;
+                  }
+                  else if (curChar == 60)
+                  {
+                     if (kind > 45)
+                        kind = 45;
+                  }
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 100:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(95, 96);
+                  else if (curChar == 46)
+                     jjCheckNAdd(57);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(89, 90);
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddTwoStates(86, 88);
+                  }
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 4:
+                  if ((0x100000200L & l) == 0L)
+                     break;
+                  if (kind > 32)
+                     kind = 32;
+                  jjCheckNAdd(4);
+                  break;
+               case 5:
+                  if ((0x2400L & l) != 0L && kind > 33)
+                     kind = 33;
+                  break;
+               case 6:
+                  if (curChar == 10 && kind > 33)
+                     kind = 33;
+                  break;
+               case 7:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 8:
+               case 10:
+                  if (curChar == 34)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 9:
+                  if ((0xfffffffbefffffffL & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 11:
+                  if (curChar == 34)
+                     jjstateSet[jjnewStateCnt++] = 10;
+                  break;
+               case 12:
+                  if (curChar == 34 && kind > 35)
+                     kind = 35;
+                  break;
+               case 15:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(63, 67);
+                  break;
+               case 16:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 17:
+                  if ((0xf000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 18:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAdd(16);
+                  break;
+               case 20:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 21:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 24:
+                  if (curChar == 32)
+                     jjAddStates(68, 69);
+                  break;
+               case 25:
+                  if (curChar == 10)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 26:
+               case 28:
+                  if (curChar == 39)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 27:
+                  if ((0xffffff7fefffffffL & l) != 0L)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 29:
+                  if (curChar == 39)
+                     jjstateSet[jjnewStateCnt++] = 28;
+                  break;
+               case 31:
+                  if (curChar == 32)
+                     jjAddStates(70, 71);
+                  break;
+               case 32:
+                  if (curChar == 10)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 33:
+                  if (curChar == 39 && kind > 35)
+                     kind = 35;
+                  break;
+               case 34:
+                  if (curChar == 38 && kind > 43)
+                     kind = 43;
+                  break;
+               case 35:
+                  if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  break;
+               case 43:
+                  if (curChar == 60 && kind > 45)
+                     kind = 45;
+                  break;
+               case 44:
+                  if (curChar == 61 && kind > 46)
+                     kind = 46;
+                  break;
+               case 45:
+                  if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  break;
+               case 46:
+                  if (curChar == 62 && kind > 47)
+                     kind = 47;
+                  break;
+               case 47:
+                  if (curChar == 61 && kind > 48)
+                     kind = 48;
+                  break;
+               case 48:
+                  if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  break;
+               case 49:
+                  if (curChar == 61 && kind > 49)
+                     kind = 49;
+                  break;
+               case 50:
+                  if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  break;
+               case 53:
+                  if (curChar == 61 && kind > 50)
+                     kind = 50;
+                  break;
+               case 54:
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 55:
+                  if (curChar == 33 && kind > 51)
+                     kind = 51;
+                  break;
+               case 56:
+                  if (curChar == 46)
+                     jjCheckNAdd(57);
+                  break;
+               case 57:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(57, 58);
+                  break;
+               case 59:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(60);
+                  break;
+               case 60:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(60);
+                  break;
+               case 62:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 63)
+                     kind = 63;
+                  jjstateSet[jjnewStateCnt++] = 62;
+                  break;
+               case 65:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjAddStates(127, 128);
+                  break;
+               case 69:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 71:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(72, 73);
+                  break;
+               case 73:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 74:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(72, 73);
+                  break;
+               case 85:
+                  if (curChar == 45)
+                     jjCheckNAddStates(123, 126);
+                  break;
+               case 86:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddTwoStates(86, 88);
+                  break;
+               case 87:
+                  if (curChar == 46 && kind > 58)
+                     kind = 58;
+                  break;
+               case 88:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 87;
+                  break;
+               case 89:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(89, 90);
+                  break;
+               case 90:
+                  if (curChar != 46)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(91, 92);
+                  break;
+               case 91:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(91, 92);
+                  break;
+               case 93:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(94);
+                  break;
+               case 94:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(94);
+                  break;
+               case 95:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(95, 96);
+                  break;
+               case 97:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(98);
+                  break;
+               case 98:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(98);
+                  break;
+               case 99:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddStates(117, 122);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if ((0x7fffffe87ffffffL & l) != 0L)
+                  {
+                     if (kind > 63)
+                        kind = 63;
+                     jjCheckNAdd(62);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(129, 132);
+                  else if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 64;
+                  else if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 39;
+                  if (curChar == 110)
+                     jjAddStates(133, 134);
+                  else if (curChar == 103)
+                     jjAddStates(135, 136);
+                  else if (curChar == 108)
+                     jjAddStates(137, 138);
+                  else if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  else if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  else if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 9:
+                  jjCheckNAddStates(59, 62);
+                  break;
+               case 13:
+                  if (curChar == 92)
+                     jjAddStates(82, 87);
+                  break;
+               case 14:
+                  if ((0x14404400000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 19:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 20:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 21:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 27:
+                  jjAddStates(55, 58);
+                  break;
+               case 30:
+                  if (curChar == 92)
+                     jjAddStates(70, 71);
+                  break;
+               case 36:
+                  if (curChar == 100 && kind > 43)
+                     kind = 43;
+                  break;
+               case 37:
+                  if (curChar == 110)
+                     jjstateSet[jjnewStateCnt++] = 36;
+                  break;
+               case 38:
+                  if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 39:
+                  if (curChar == 124 && kind > 44)
+                     kind = 44;
+                  break;
+               case 40:
+                  if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 39;
+                  break;
+               case 41:
+                  if (curChar == 114 && kind > 44)
+                     kind = 44;
+                  break;
+               case 42:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  break;
+               case 51:
+                  if (curChar == 113 && kind > 49)
+                     kind = 49;
+                  break;
+               case 52:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  break;
+               case 58:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(88, 89);
+                  break;
+               case 61:
+                  if ((0x7fffffe87ffffffL & l) == 0L)
+                     break;
+                  if (kind > 63)
+                     kind = 63;
+                  jjCheckNAdd(62);
+                  break;
+               case 62:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 63)
+                     kind = 63;
+                  jjCheckNAdd(62);
+                  break;
+               case 63:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 64;
+                  break;
+               case 64:
+                  if ((0x7fffffe87ffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(65, 66);
+                  break;
+               case 65:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                     jjCheckNAddTwoStates(65, 66);
+                  break;
+               case 66:
+                  if (curChar == 125 && kind > 64)
+                     kind = 64;
+                  break;
+               case 67:
+                  if (curChar == 92)
+                     jjCheckNAddStates(129, 132);
+                  break;
+               case 68:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(68, 69);
+                  break;
+               case 70:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(70, 71);
+                  break;
+               case 72:
+                  if (curChar == 92)
+                     jjAddStates(43, 44);
+                  break;
+               case 75:
+                  if (curChar == 108)
+                     jjAddStates(137, 138);
+                  break;
+               case 76:
+                  if (curChar == 116 && kind > 45)
+                     kind = 45;
+                  break;
+               case 77:
+                  if (curChar == 101 && kind > 46)
+                     kind = 46;
+                  break;
+               case 78:
+                  if (curChar == 103)
+                     jjAddStates(135, 136);
+                  break;
+               case 79:
+                  if (curChar == 116 && kind > 47)
+                     kind = 47;
+                  break;
+               case 80:
+                  if (curChar == 101 && kind > 48)
+                     kind = 48;
+                  break;
+               case 81:
+                  if (curChar == 110)
+                     jjAddStates(133, 134);
+                  break;
+               case 82:
+                  if (curChar == 101 && kind > 50)
+                     kind = 50;
+                  break;
+               case 83:
+                  if (curChar == 116 && kind > 51)
+                     kind = 51;
+                  break;
+               case 84:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 83;
+                  break;
+               case 92:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(139, 140);
+                  break;
+               case 96:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(141, 142);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               case 9:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(59, 62);
+                  break;
+               case 27:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(55, 58);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 100 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_17(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_17(int pos, long active0)
+{
+   return jjMoveNfa_17(jjStopStringLiteralDfa_17(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_17()
+{
+   switch(curChar)
+   {
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_17(0xa00000L);
+      case 42:
+         return jjMoveStringLiteralDfa1_17(0x10000000L);
+      default :
+         return jjMoveNfa_17(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_17(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_17(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x10000000L) != 0L)
+            return jjStopAtPos(1, 28);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_17(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_17(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_17(0, active0);
+}
+private int jjMoveStringLiteralDfa2_17(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_17(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_17(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_17(1, active0);
+}
+private int jjStartNfaWithStates_17(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_17(state, pos + 1);
+}
+private int jjMoveNfa_17(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 12;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(9, 10);
+                  }
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 6:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 8:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 11:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(9, 10);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(115, 116);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_7(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x4000000000L) != 0L)
+            return 94;
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         if ((active0 & 0x10000000000000L) != 0L)
+            return 49;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_7(int pos, long active0)
+{
+   return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_7()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_7(0xa00000L);
+      case 37:
+         return jjStopAtPos(0, 42);
+      case 42:
+         return jjStopAtPos(0, 40);
+      case 43:
+         return jjStopAtPos(0, 39);
+      case 45:
+         return jjStartNfaWithStates_7(0, 38, 94);
+      case 47:
+         return jjStopAtPos(0, 41);
+      case 61:
+         return jjStartNfaWithStates_7(0, 52, 49);
+      case 93:
+         return jjStopAtPos(0, 6);
+      case 102:
+         return jjMoveStringLiteralDfa1_7(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_7(0x1000000000L);
+      default :
+         return jjMoveNfa_7(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_7(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_7(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_7(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_7(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_7(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_7(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_7(0, active0);
+}
+private int jjMoveStringLiteralDfa2_7(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_7(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_7(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_7(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_7(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_7(1, active0);
+}
+private int jjMoveStringLiteralDfa3_7(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_7(1, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_7(2, active0);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStopAtPos(3, 36);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_7(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_7(2, active0);
+}
+private int jjMoveStringLiteralDfa4_7(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_7(2, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_7(3, active0);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStopAtPos(4, 37);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_7(3, active0);
+}
+private int jjStartNfaWithStates_7(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_7(state, pos + 1);
+}
+private int jjMoveNfa_7(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 94;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 94:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(89, 90);
+                  else if (curChar == 46)
+                     jjCheckNAdd(57);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(83, 84);
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddTwoStates(80, 82);
+                  }
+                  break;
+               case 3:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddStates(45, 50);
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 33)
+                        kind = 33;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                  {
+                     if (kind > 32)
+                        kind = 32;
+                     jjCheckNAdd(4);
+                  }
+                  else if (curChar == 45)
+                     jjCheckNAddStates(51, 54);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(66, 67);
+                  }
+                  else if (curChar == 46)
+                     jjCheckNAdd(57);
+                  else if (curChar == 33)
+                  {
+                     if (kind > 51)
+                        kind = 51;
+                  }
+                  else if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  else if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  else if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  else if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  else if (curChar == 39)
+                     jjCheckNAddStates(55, 58);
+                  else if (curChar == 34)
+                     jjCheckNAddStates(59, 62);
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  else if (curChar == 62)
+                  {
+                     if (kind > 47)
+                        kind = 47;
+                  }
+                  else if (curChar == 60)
+                  {
+                     if (kind > 45)
+                        kind = 45;
+                  }
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 4:
+                  if ((0x100000200L & l) == 0L)
+                     break;
+                  if (kind > 32)
+                     kind = 32;
+                  jjCheckNAdd(4);
+                  break;
+               case 5:
+                  if ((0x2400L & l) != 0L && kind > 33)
+                     kind = 33;
+                  break;
+               case 6:
+                  if (curChar == 10 && kind > 33)
+                     kind = 33;
+                  break;
+               case 7:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 8:
+               case 10:
+                  if (curChar == 34)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 9:
+                  if ((0xfffffffbefffffffL & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 11:
+                  if (curChar == 34)
+                     jjstateSet[jjnewStateCnt++] = 10;
+                  break;
+               case 12:
+                  if (curChar == 34 && kind > 35)
+                     kind = 35;
+                  break;
+               case 15:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(63, 67);
+                  break;
+               case 16:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 17:
+                  if ((0xf000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 18:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAdd(16);
+                  break;
+               case 20:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 21:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 24:
+                  if (curChar == 32)
+                     jjAddStates(68, 69);
+                  break;
+               case 25:
+                  if (curChar == 10)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 26:
+               case 28:
+                  if (curChar == 39)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 27:
+                  if ((0xffffff7fefffffffL & l) != 0L)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 29:
+                  if (curChar == 39)
+                     jjstateSet[jjnewStateCnt++] = 28;
+                  break;
+               case 31:
+                  if (curChar == 32)
+                     jjAddStates(70, 71);
+                  break;
+               case 32:
+                  if (curChar == 10)
+                     jjCheckNAddStates(55, 58);
+                  break;
+               case 33:
+                  if (curChar == 39 && kind > 35)
+                     kind = 35;
+                  break;
+               case 34:
+                  if (curChar == 38 && kind > 43)
+                     kind = 43;
+                  break;
+               case 35:
+                  if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 34;
+                  break;
+               case 43:
+                  if (curChar == 60 && kind > 45)
+                     kind = 45;
+                  break;
+               case 44:
+                  if (curChar == 61 && kind > 46)
+                     kind = 46;
+                  break;
+               case 45:
+                  if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 44;
+                  break;
+               case 46:
+                  if (curChar == 62 && kind > 47)
+                     kind = 47;
+                  break;
+               case 47:
+                  if (curChar == 61 && kind > 48)
+                     kind = 48;
+                  break;
+               case 48:
+                  if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  break;
+               case 49:
+                  if (curChar == 61 && kind > 49)
+                     kind = 49;
+                  break;
+               case 50:
+                  if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  break;
+               case 53:
+                  if (curChar == 61 && kind > 50)
+                     kind = 50;
+                  break;
+               case 54:
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 55:
+                  if (curChar == 33 && kind > 51)
+                     kind = 51;
+                  break;
+               case 56:
+                  if (curChar == 46)
+                     jjCheckNAdd(57);
+                  break;
+               case 57:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(57, 58);
+                  break;
+               case 59:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(60);
+                  break;
+               case 60:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(60);
+                  break;
+               case 63:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 65:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 67:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 68:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(66, 67);
+                  break;
+               case 79:
+                  if (curChar == 45)
+                     jjCheckNAddStates(51, 54);
+                  break;
+               case 80:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddTwoStates(80, 82);
+                  break;
+               case 81:
+                  if (curChar == 46 && kind > 58)
+                     kind = 58;
+                  break;
+               case 82:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 81;
+                  break;
+               case 83:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(83, 84);
+                  break;
+               case 84:
+                  if (curChar != 46)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 85:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(85, 86);
+                  break;
+               case 87:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(88);
+                  break;
+               case 88:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(88);
+                  break;
+               case 89:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(89, 90);
+                  break;
+               case 91:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(92);
+                  break;
+               case 92:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(92);
+                  break;
+               case 93:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddStates(45, 50);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 110)
+                     jjAddStates(72, 73);
+                  else if (curChar == 103)
+                     jjAddStates(74, 75);
+                  else if (curChar == 108)
+                     jjAddStates(76, 77);
+                  else if (curChar == 92)
+                     jjCheckNAddStates(78, 81);
+                  else if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  else if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  else if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 39;
+                  else if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 9:
+                  jjCheckNAddStates(59, 62);
+                  break;
+               case 13:
+                  if (curChar == 92)
+                     jjAddStates(82, 87);
+                  break;
+               case 14:
+                  if ((0x14404400000000L & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 19:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 20:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 21:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(59, 62);
+                  break;
+               case 27:
+                  jjAddStates(55, 58);
+                  break;
+               case 30:
+                  if (curChar == 92)
+                     jjAddStates(70, 71);
+                  break;
+               case 36:
+                  if (curChar == 100 && kind > 43)
+                     kind = 43;
+                  break;
+               case 37:
+                  if (curChar == 110)
+                     jjstateSet[jjnewStateCnt++] = 36;
+                  break;
+               case 38:
+                  if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 39:
+                  if (curChar == 124 && kind > 44)
+                     kind = 44;
+                  break;
+               case 40:
+                  if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 39;
+                  break;
+               case 41:
+                  if (curChar == 114 && kind > 44)
+                     kind = 44;
+                  break;
+               case 42:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  break;
+               case 51:
+                  if (curChar == 113 && kind > 49)
+                     kind = 49;
+                  break;
+               case 52:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 51;
+                  break;
+               case 58:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(88, 89);
+                  break;
+               case 61:
+                  if (curChar == 92)
+                     jjCheckNAddStates(78, 81);
+                  break;
+               case 62:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(62, 63);
+                  break;
+               case 64:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(64, 65);
+                  break;
+               case 66:
+                  if (curChar == 92)
+                     jjAddStates(90, 91);
+                  break;
+               case 69:
+                  if (curChar == 108)
+                     jjAddStates(76, 77);
+                  break;
+               case 70:
+                  if (curChar == 116 && kind > 45)
+                     kind = 45;
+                  break;
+               case 71:
+                  if (curChar == 101 && kind > 46)
+                     kind = 46;
+                  break;
+               case 72:
+                  if (curChar == 103)
+                     jjAddStates(74, 75);
+                  break;
+               case 73:
+                  if (curChar == 116 && kind > 47)
+                     kind = 47;
+                  break;
+               case 74:
+                  if (curChar == 101 && kind > 48)
+                     kind = 48;
+                  break;
+               case 75:
+                  if (curChar == 110)
+                     jjAddStates(72, 73);
+                  break;
+               case 76:
+                  if (curChar == 101 && kind > 50)
+                     kind = 50;
+                  break;
+               case 77:
+                  if (curChar == 116 && kind > 51)
+                     kind = 51;
+                  break;
+               case 78:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 77;
+                  break;
+               case 86:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(92, 93);
+                  break;
+               case 90:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(94, 95);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               case 9:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(59, 62);
+                  break;
+               case 27:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(55, 58);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 94 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_13(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_13(int pos, long active0)
+{
+   return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_13()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_13(0xa00000L);
+      default :
+         return jjMoveNfa_13(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_13(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_13(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_13(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_13(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_13(0, active0);
+}
+private int jjMoveStringLiteralDfa2_13(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_13(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_13(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_13(1, active0);
+}
+private int jjStartNfaWithStates_13(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_13(state, pos + 1);
+}
+private int jjMoveNfa_13(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 12;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(9, 10);
+                  }
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 6:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 8:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 11:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(9, 10);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(115, 116);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_14(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_14(int pos, long active0)
+{
+   return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_14()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_14(0xa00000L);
+      case 42:
+         return jjMoveStringLiteralDfa1_14(0x8000000L);
+      default :
+         return jjMoveNfa_14(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_14(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_14(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x8000000L) != 0L)
+            return jjStopAtPos(1, 27);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_14(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_14(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_14(0, active0);
+}
+private int jjMoveStringLiteralDfa2_14(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_14(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_14(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_14(1, active0);
+}
+private int jjStartNfaWithStates_14(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_14(state, pos + 1);
+}
+private int jjMoveNfa_14(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 12;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(9, 10);
+                  }
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 6:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 8:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 11:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(9, 10);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(115, 116);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 25;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 31;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_2(int pos, long active0, long active1)
+{
+   return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_2()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 1);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_2(0x2a00000L);
+      case 123:
+         return jjStopAtPos(0, 72);
+      case 125:
+         return jjStopAtPos(0, 73);
+      default :
+         return jjMoveNfa_2(4, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_2(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_2(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_2(1, 23, 31);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_2(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_2(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_2(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_2(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_2(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_2(1, active0, 0L);
+}
+private int jjStartNfaWithStates_2(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_2(state, pos + 1);
+}
+private int jjMoveNfa_2(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 34;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 25:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 31;
+                  break;
+               case 4:
+                  if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 34)
+                        kind = 34;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                     jjCheckNAddStates(143, 145);
+                  else if (curChar == 35)
+                     jjAddStates(146, 148);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(17, 18);
+                  }
+                  if (curChar == 36)
+                     jjCheckNAddStates(149, 152);
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if ((0x100000200L & l) != 0L)
+                     jjCheckNAddStates(143, 145);
+                  break;
+               case 1:
+                  if ((0x2400L & l) != 0L && kind > 34)
+                     kind = 34;
+                  break;
+               case 2:
+                  if (curChar == 10 && kind > 34)
+                     kind = 34;
+                  break;
+               case 3:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 5:
+                  if ((0x3ff200000000000L & l) == 0L)
+                     break;
+                  if (kind > 70)
+                     kind = 70;
+                  jjstateSet[jjnewStateCnt++] = 5;
+                  break;
+               case 6:
+                  if (curChar == 36)
+                     jjCheckNAddStates(149, 152);
+                  break;
+               case 8:
+               case 9:
+                  if (curChar == 33)
+                     jjCheckNAdd(7);
+                  break;
+               case 11:
+                  if (curChar == 46 && kind > 80)
+                     kind = 80;
+                  break;
+               case 14:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 16:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(17, 18);
+                  break;
+               case 18:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 19:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(17, 18);
+                  break;
+               case 20:
+                  if (curChar == 35)
+                     jjAddStates(146, 148);
+                  break;
+               case 22:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(153, 154);
+                  break;
+               case 23:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 31:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 32;
+                  break;
+               case 32:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 25:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 29;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 4:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 70)
+                        kind = 70;
+                     jjCheckNAdd(5);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(155, 158);
+                  break;
+               case 5:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 70)
+                     kind = 70;
+                  jjCheckNAdd(5);
+                  break;
+               case 7:
+                  if (curChar == 91 && kind > 80)
+                     kind = 80;
+                  break;
+               case 10:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 9;
+                  break;
+               case 12:
+                  if (curChar == 92)
+                     jjCheckNAddStates(155, 158);
+                  break;
+               case 13:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(13, 14);
+                  break;
+               case 15:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(15, 16);
+                  break;
+               case 17:
+                  if (curChar == 92)
+                     jjAddStates(159, 160);
+                  break;
+               case 21:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(22, 23);
+                  break;
+               case 24:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 26:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(22, 23);
+                  break;
+               case 27:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 26;
+                  break;
+               case 28:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 27;
+                  break;
+               case 29:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 28;
+                  break;
+               case 30:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 29;
+                  break;
+               case 32:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 32:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_10(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 39;
+         if ((active1 & 0x3000L) != 0L)
+            return 18;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 45;
+         if ((active1 & 0x1000L) != 0L)
+            return 51;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_10(int pos, long active0, long active1)
+{
+   return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_10()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_10(0x2a00000L, 0x0L);
+      case 92:
+         jjmatchedKind = 77;
+         return jjMoveStringLiteralDfa1_10(0x0L, 0x1000L);
+      default :
+         return jjMoveNfa_10(1, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_10(long active0, long active1)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_10(0, active0, active1);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_10(1, 23, 45);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_10(active0, 0x200000L, active1, 0L);
+      case 92:
+         if ((active1 & 0x1000L) != 0L)
+            return jjStartNfaWithStates_10(1, 76, 51);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_10(0, active0, active1);
+}
+private int jjMoveStringLiteralDfa2_10(long old0, long active0, long old1, long active1)
+{
+   if (((active0 &= old0) | (active1 &= old1)) == 0L)
+      return jjStartNfa_10(0, old0, old1);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_10(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_10(1, active0, 0L);
+}
+private int jjStartNfaWithStates_10(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_10(state, pos + 1);
+}
+private int jjMoveNfa_10(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 51;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 39:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 45;
+                  break;
+               case 18:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(31, 32);
+                  else if (curChar == 35)
+                     jjAddStates(161, 162);
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                  }
+                  break;
+               case 51:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(31, 32);
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                  }
+                  break;
+               case 1:
+                  if ((0xffffffe7efffdbffL & l) != 0L)
+                  {
+                     if (kind > 79)
+                        kind = 79;
+                     jjCheckNAddStates(163, 165);
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 33)
+                        kind = 33;
+                  }
+                  else if (curChar == 35)
+                     jjAddStates(166, 168);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(31, 32);
+                  }
+                  if ((0xffffffe6efffd9ffL & l) != 0L)
+                     jjCheckNAddStates(169, 172);
+                  else if ((0x100000200L & l) != 0L)
+                  {
+                     if (kind > 32)
+                        kind = 32;
+                     jjCheckNAdd(0);
+                  }
+                  else if (curChar == 36)
+                     jjCheckNAddStates(173, 176);
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if ((0x100000200L & l) == 0L)
+                     break;
+                  if (kind > 32)
+                     kind = 32;
+                  jjCheckNAdd(0);
+                  break;
+               case 2:
+                  if (curChar == 10 && kind > 33)
+                     kind = 33;
+                  break;
+               case 3:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 4:
+                  if ((0xffffffe6efffd9ffL & l) != 0L)
+                     jjCheckNAddStates(169, 172);
+                  break;
+               case 5:
+                  if ((0xffffffe7efffdbffL & l) != 0L)
+                     jjCheckNAddStates(177, 179);
+                  break;
+               case 6:
+                  if ((0x2400L & l) == 0L)
+                     break;
+                  if (kind > 78)
+                     kind = 78;
+                  jjCheckNAddStates(180, 182);
+                  break;
+               case 7:
+                  if ((0xffffffe7efffdbffL & l) != 0L)
+                     jjCheckNAddStates(180, 182);
+                  break;
+               case 8:
+                  if (curChar != 10)
+                     break;
+                  if (kind > 78)
+                     kind = 78;
+                  jjCheckNAddStates(180, 182);
+                  break;
+               case 9:
+               case 10:
+                  if (curChar == 13)
+                     jjCheckNAdd(8);
+                  break;
+               case 11:
+                  if (curChar == 36)
+                     jjCheckNAddStates(173, 176);
+                  break;
+               case 13:
+               case 14:
+                  if (curChar == 33)
+                     jjCheckNAdd(12);
+                  break;
+               case 16:
+                  if (curChar == 46 && kind > 80)
+                     kind = 80;
+                  break;
+               case 19:
+                  if (curChar == 35)
+                     jjAddStates(161, 162);
+                  break;
+               case 21:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 17)
+                     kind = 17;
+                  jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 24:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjAddStates(68, 69);
+                  break;
+               case 28:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 30:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(31, 32);
+                  break;
+               case 32:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 33:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(31, 32);
+                  break;
+               case 34:
+                  if (curChar == 35)
+                     jjAddStates(166, 168);
+                  break;
+               case 36:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(183, 184);
+                  break;
+               case 37:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 45:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 46;
+                  break;
+               case 46:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 48:
+                  if ((0xffffffe7efffdbffL & l) == 0L)
+                     break;
+                  if (kind > 79)
+                     kind = 79;
+                  jjCheckNAddStates(163, 165);
+                  break;
+               case 49:
+                  if ((0xffffffe7efffdbffL & l) != 0L)
+                     jjCheckNAddTwoStates(49, 4);
+                  break;
+               case 50:
+                  if ((0xffffffe7efffdbffL & l) == 0L)
+                     break;
+                  if (kind > 79)
+                     kind = 79;
+                  jjCheckNAdd(50);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 39:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 43;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 38;
+                  break;
+               case 18:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(29, 30);
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(27, 28);
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 17;
+                  break;
+               case 51:
+                  if (curChar == 92)
+                     jjAddStates(185, 186);
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(29, 30);
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(27, 28);
+                  break;
+               case 1:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                  {
+                     if (kind > 79)
+                        kind = 79;
+                     jjCheckNAddStates(163, 165);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(187, 190);
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     jjCheckNAddStates(169, 172);
+                  else if (curChar == 92)
+                     jjAddStates(185, 186);
+                  break;
+               case 4:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     jjCheckNAddStates(169, 172);
+                  break;
+               case 5:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     jjCheckNAddStates(177, 179);
+                  break;
+               case 7:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     jjCheckNAddStates(180, 182);
+                  break;
+               case 12:
+                  if (curChar == 91 && kind > 80)
+                     kind = 80;
+                  break;
+               case 15:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 14;
+                  break;
+               case 17:
+                  if (curChar == 92)
+                     jjAddStates(185, 186);
+                  break;
+               case 20:
+                  if ((0x7fffffe87ffffffL & l) == 0L)
+                     break;
+                  if (kind > 17)
+                     kind = 17;
+                  jjCheckNAdd(21);
+                  break;
+               case 21:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 17)
+                     kind = 17;
+                  jjCheckNAdd(21);
+                  break;
+               case 22:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 23:
+                  if ((0x7fffffe87ffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(24, 25);
+                  break;
+               case 24:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                     jjCheckNAddTwoStates(24, 25);
+                  break;
+               case 25:
+                  if (curChar == 125 && kind > 17)
+                     kind = 17;
+                  break;
+               case 26:
+                  if (curChar == 92)
+                     jjCheckNAddStates(187, 190);
+                  break;
+               case 27:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(27, 28);
+                  break;
+               case 29:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(29, 30);
+                  break;
+               case 31:
+                  if (curChar == 92)
+                     jjAddStates(70, 71);
+                  break;
+               case 35:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(36, 37);
+                  break;
+               case 38:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 35;
+                  break;
+               case 40:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(36, 37);
+                  break;
+               case 41:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 40;
+                  break;
+               case 42:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 41;
+                  break;
+               case 43:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 42;
+                  break;
+               case 44:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 43;
+                  break;
+               case 46:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 48:
+                  if ((0xffffffffefffffffL & l) == 0L)
+                     break;
+                  if (kind > 79)
+                     kind = 79;
+                  jjCheckNAddStates(163, 165);
+                  break;
+               case 49:
+                  if ((0xffffffffefffffffL & l) != 0L)
+                     jjCheckNAddTwoStates(49, 4);
+                  break;
+               case 50:
+                  if ((0xffffffffefffffffL & l) == 0L)
+                     break;
+                  if (kind > 79)
+                     kind = 79;
+                  jjCheckNAdd(50);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjCheckNAddStates(169, 172);
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                  {
+                     if (kind > 79)
+                        kind = 79;
+                     jjCheckNAddStates(163, 165);
+                  }
+                  break;
+               case 4:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjCheckNAddStates(169, 172);
+                  break;
+               case 5:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjCheckNAddStates(177, 179);
+                  break;
+               case 7:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjCheckNAddStates(180, 182);
+                  break;
+               case 46:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               case 48:
+                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     break;
+                  if (kind > 79)
+                     kind = 79;
+                  jjCheckNAddStates(163, 165);
+                  break;
+               case 49:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjCheckNAddTwoStates(49, 4);
+                  break;
+               case 50:
+                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     break;
+                  if (kind > 79)
+                     kind = 79;
+                  jjCheckNAdd(50);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 51 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 25;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 31;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_1(int pos, long active0, long active1)
+{
+   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_1()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 1);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_1(0x2a00000L);
+      case 123:
+         return jjStopAtPos(0, 72);
+      case 125:
+         return jjStopAtPos(0, 73);
+      default :
+         return jjMoveNfa_1(4, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_1(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_1(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_1(1, 23, 31);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_1(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_1(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_1(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_1(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_1(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_1(1, active0, 0L);
+}
+private int jjStartNfaWithStates_1(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_1(state, pos + 1);
+}
+private int jjMoveNfa_1(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 34;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 25:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 31;
+                  break;
+               case 4:
+                  if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 34)
+                        kind = 34;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                     jjCheckNAddStates(143, 145);
+                  else if (curChar == 35)
+                     jjAddStates(146, 148);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(17, 18);
+                  }
+                  if (curChar == 36)
+                     jjCheckNAddStates(149, 152);
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if ((0x100000200L & l) != 0L)
+                     jjCheckNAddStates(143, 145);
+                  break;
+               case 1:
+                  if ((0x2400L & l) != 0L && kind > 34)
+                     kind = 34;
+                  break;
+               case 2:
+                  if (curChar == 10 && kind > 34)
+                     kind = 34;
+                  break;
+               case 3:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 5:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  jjstateSet[jjnewStateCnt++] = 5;
+                  break;
+               case 6:
+                  if (curChar == 36)
+                     jjCheckNAddStates(149, 152);
+                  break;
+               case 8:
+               case 9:
+                  if (curChar == 33)
+                     jjCheckNAdd(7);
+                  break;
+               case 11:
+                  if (curChar == 46 && kind > 80)
+                     kind = 80;
+                  break;
+               case 14:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 16:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(17, 18);
+                  break;
+               case 18:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 19:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(17, 18);
+                  break;
+               case 20:
+                  if (curChar == 35)
+                     jjAddStates(146, 148);
+                  break;
+               case 22:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(153, 154);
+                  break;
+               case 23:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 31:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 32;
+                  break;
+               case 32:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 25:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 29;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 4:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 67)
+                        kind = 67;
+                     jjCheckNAdd(5);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(155, 158);
+                  break;
+               case 5:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  jjCheckNAdd(5);
+                  break;
+               case 7:
+                  if (curChar == 91 && kind > 80)
+                     kind = 80;
+                  break;
+               case 10:
+                  if (curChar == 92)
+                     jjstateSet[jjnewStateCnt++] = 9;
+                  break;
+               case 12:
+                  if (curChar == 92)
+                     jjCheckNAddStates(155, 158);
+                  break;
+               case 13:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(13, 14);
+                  break;
+               case 15:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(15, 16);
+                  break;
+               case 17:
+                  if (curChar == 92)
+                     jjAddStates(159, 160);
+                  break;
+               case 21:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(22, 23);
+                  break;
+               case 24:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 26:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(22, 23);
+                  break;
+               case 27:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 26;
+                  break;
+               case 28:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 27;
+                  break;
+               case 29:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 28;
+                  break;
+               case 30:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 29;
+                  break;
+               case 32:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 32:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3a00000L) != 0L)
+            return 15;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 21;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_6(int pos, long active0, long active1)
+{
+   return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_6()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_6(0x2a00000L);
+      case 91:
+         return jjStopAtPos(0, 3);
+      case 123:
+         return jjStopAtPos(0, 72);
+      case 124:
+         jjmatchedKind = 5;
+         return jjMoveStringLiteralDfa1_6(0x10L);
+      case 125:
+         return jjStopAtPos(0, 73);
+      default :
+         return jjMoveNfa_6(0, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_6(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_6(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_6(1, 23, 21);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_6(active0, 0x200000L);
+      case 124:
+         if ((active0 & 0x10L) != 0L)
+            return jjStopAtPos(1, 4);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_6(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_6(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_6(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_6(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_6(1, active0, 0L);
+}
+private int jjStartNfaWithStates_6(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_6(state, pos + 1);
+}
+private int jjMoveNfa_6(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 24;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if (curChar == 35)
+                     jjAddStates(0, 2);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(7, 8);
+                  }
+                  else if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 15:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 4:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 6:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 8:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 9:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 10:
+                  if (curChar == 35)
+                     jjAddStates(0, 2);
+                  break;
+               case 12:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(3, 4);
+                  break;
+               case 13:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 21:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 22;
+                  break;
+               case 22:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if (curChar == 92)
+                     jjCheckNAddStates(5, 8);
+                  break;
+               case 15:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 14;
+                  break;
+               case 1:
+                  if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+                     kind = 71;
+                  break;
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(3, 4);
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjAddStates(9, 10);
+                  break;
+               case 11:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 14:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 11;
+                  break;
+               case 16:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(12, 13);
+                  break;
+               case 17:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 16;
+                  break;
+               case 18:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 17;
+                  break;
+               case 19:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 20:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  break;
+               case 22:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 22:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 24 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_9(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x4000000000L) != 0L)
+            return 96;
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            return 53;
+         }
+         if ((active0 & 0x10000000000000L) != 0L)
+            return 45;
+         if ((active0 & 0x400L) != 0L)
+            return 107;
+         if ((active0 & 0x3a00000L) != 0L)
+            return 67;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 73;
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 1;
+            return 53;
+         }
+         return -1;
+      case 2:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 2;
+            return 53;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x1000000000L) != 0L)
+            return 53;
+         if ((active0 & 0x2000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 3;
+            return 53;
+         }
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_9(int pos, long active0)
+{
+   return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_9()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_9(0x2a00000L);
+      case 37:
+         return jjStopAtPos(0, 42);
+      case 41:
+         return jjStopAtPos(0, 16);
+      case 42:
+         return jjStopAtPos(0, 40);
+      case 43:
+         return jjStopAtPos(0, 39);
+      case 44:
+         return jjStopAtPos(0, 9);
+      case 45:
+         return jjStartNfaWithStates_9(0, 38, 96);
+      case 46:
+         return jjMoveStringLiteralDfa1_9(0x400L);
+      case 47:
+         return jjStopAtPos(0, 41);
+      case 58:
+         return jjStopAtPos(0, 11);
+      case 61:
+         return jjStartNfaWithStates_9(0, 52, 45);
+      case 91:
+         return jjStopAtPos(0, 7);
+      case 93:
+         return jjStopAtPos(0, 8);
+      case 102:
+         return jjMoveStringLiteralDfa1_9(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_9(0x1000000000L);
+      case 123:
+         return jjStopAtPos(0, 12);
+      case 125:
+         return jjStopAtPos(0, 13);
+      default :
+         return jjMoveNfa_9(1, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_9(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_9(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_9(1, 23, 73);
+         break;
+      case 46:
+         if ((active0 & 0x400L) != 0L)
+            return jjStopAtPos(1, 10);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_9(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_9(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_9(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_9(0, active0);
+}
+private int jjMoveStringLiteralDfa2_9(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_9(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_9(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_9(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_9(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_9(1, active0);
+}
+private int jjMoveStringLiteralDfa3_9(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_9(1, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_9(2, active0);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStartNfaWithStates_9(3, 36, 53);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_9(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_9(2, active0);
+}
+private int jjMoveStringLiteralDfa4_9(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_9(2, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_9(3, active0);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStartNfaWithStates_9(4, 37, 53);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_9(3, active0);
+}
+private int jjStartNfaWithStates_9(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_9(state, pos + 1);
+}
+private int jjMoveNfa_9(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 108;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 96:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(101, 102);
+                  else if (curChar == 46)
+                     jjCheckNAdd(97);
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(90, 91);
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddTwoStates(87, 89);
+                  }
+                  break;
+               case 1:
+                  if ((0x3ff000000000000L & l) != 0L)
+                  {
+                     if (kind > 58)
+                        kind = 58;
+                     jjCheckNAddStates(191, 196);
+                  }
+                  else if ((0x2400L & l) != 0L)
+                  {
+                     if (kind > 33)
+                        kind = 33;
+                  }
+                  else if ((0x100000200L & l) != 0L)
+                  {
+                     if (kind > 32)
+                        kind = 32;
+                     jjCheckNAdd(0);
+                  }
+                  else if (curChar == 46)
+                     jjCheckNAddTwoStates(97, 107);
+                  else if (curChar == 45)
+                     jjCheckNAddStates(197, 200);
+                  else if (curChar == 35)
+                     jjAddStates(201, 203);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(59, 60);
+                  }
+                  else if (curChar == 33)
+                  {
+                     if (kind > 51)
+                        kind = 51;
+                  }
+                  else if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 45;
+                  else if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 43;
+                  else if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 40;
+                  else if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 30;
+                  else if (curChar == 39)
+                     jjCheckNAddStates(204, 207);
+                  else if (curChar == 34)
+                     jjCheckNAddStates(208, 211);
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  else if (curChar == 62)
+                  {
+                     if (kind > 47)
+                        kind = 47;
+                  }
+                  else if (curChar == 60)
+                  {
+                     if (kind > 45)
+                        kind = 45;
+                  }
+                  else if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 107:
+               case 97:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(97, 98);
+                  break;
+               case 67:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 73;
+                  break;
+               case 0:
+                  if ((0x100000200L & l) == 0L)
+                     break;
+                  if (kind > 32)
+                     kind = 32;
+                  jjCheckNAdd(0);
+                  break;
+               case 2:
+                  if (curChar == 10 && kind > 33)
+                     kind = 33;
+                  break;
+               case 3:
+                  if (curChar == 13)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 4:
+               case 6:
+                  if (curChar == 34)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 5:
+                  if ((0xfffffffbefffffffL & l) != 0L)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 7:
+                  if (curChar == 34)
+                     jjstateSet[jjnewStateCnt++] = 6;
+                  break;
+               case 8:
+                  if (curChar == 34 && kind > 35)
+                     kind = 35;
+                  break;
+               case 11:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(212, 216);
+                  break;
+               case 12:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 13:
+                  if ((0xf000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 14;
+                  break;
+               case 14:
+                  if ((0xff000000000000L & l) != 0L)
+                     jjCheckNAdd(12);
+                  break;
+               case 16:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 17;
+                  break;
+               case 17:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 18:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  break;
+               case 19:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 20:
+                  if (curChar == 32)
+                     jjAddStates(217, 218);
+                  break;
+               case 21:
+                  if (curChar == 10)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 22:
+               case 24:
+                  if (curChar == 39)
+                     jjCheckNAddStates(204, 207);
+                  break;
+               case 23:
+                  if ((0xffffff7fefffffffL & l) != 0L)
+                     jjCheckNAddStates(204, 207);
+                  break;
+               case 25:
+                  if (curChar == 39)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 27:
+                  if (curChar == 32)
+                     jjAddStates(219, 220);
+                  break;
+               case 28:
+                  if (curChar == 10)
+                     jjCheckNAddStates(204, 207);
+                  break;
+               case 29:
+                  if (curChar == 39 && kind > 35)
+                     kind = 35;
+                  break;
+               case 30:
+                  if (curChar == 38 && kind > 43)
+                     kind = 43;
+                  break;
+               case 31:
+                  if (curChar == 38)
+                     jjstateSet[jjnewStateCnt++] = 30;
+                  break;
+               case 39:
+                  if (curChar == 60 && kind > 45)
+                     kind = 45;
+                  break;
+               case 40:
+                  if (curChar == 61 && kind > 46)
+                     kind = 46;
+                  break;
+               case 41:
+                  if (curChar == 60)
+                     jjstateSet[jjnewStateCnt++] = 40;
+                  break;
+               case 42:
+                  if (curChar == 62 && kind > 47)
+                     kind = 47;
+                  break;
+               case 43:
+                  if (curChar == 61 && kind > 48)
+                     kind = 48;
+                  break;
+               case 44:
+                  if (curChar == 62)
+                     jjstateSet[jjnewStateCnt++] = 43;
+                  break;
+               case 45:
+                  if (curChar == 61 && kind > 49)
+                     kind = 49;
+                  break;
+               case 46:
+                  if (curChar == 61)
+                     jjstateSet[jjnewStateCnt++] = 45;
+                  break;
+               case 49:
+                  if (curChar == 61 && kind > 50)
+                     kind = 50;
+                  break;
+               case 50:
+                  if (curChar == 33)
+                     jjstateSet[jjnewStateCnt++] = 49;
+                  break;
+               case 51:
+                  if (curChar == 33 && kind > 51)
+                     kind = 51;
+                  break;
+               case 53:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  jjstateSet[jjnewStateCnt++] = 53;
+                  break;
+               case 56:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 58:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(59, 60);
+                  break;
+               case 60:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 61:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(59, 60);
+                  break;
+               case 62:
+                  if (curChar == 35)
+                     jjAddStates(201, 203);
+                  break;
+               case 64:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(221, 222);
+                  break;
+               case 65:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 73:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 74;
+                  break;
+               case 74:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 86:
+                  if (curChar == 45)
+                     jjCheckNAddStates(197, 200);
+                  break;
+               case 87:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddTwoStates(87, 89);
+                  break;
+               case 88:
+                  if (curChar == 46 && kind > 58)
+                     kind = 58;
+                  break;
+               case 89:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 88;
+                  break;
+               case 90:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(90, 91);
+                  break;
+               case 91:
+                  if (curChar != 46)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(92, 93);
+                  break;
+               case 92:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAddTwoStates(92, 93);
+                  break;
+               case 94:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(95);
+                  break;
+               case 95:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(95);
+                  break;
+               case 99:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(100);
+                  break;
+               case 100:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(100);
+                  break;
+               case 101:
+                  if ((0x3ff000000000000L & l) != 0L)
+                     jjCheckNAddTwoStates(101, 102);
+                  break;
+               case 103:
+                  if ((0x280000000000L & l) != 0L)
+                     jjCheckNAdd(104);
+                  break;
+               case 104:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 59)
+                     kind = 59;
+                  jjCheckNAdd(104);
+                  break;
+               case 105:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 58)
+                     kind = 58;
+                  jjCheckNAddStates(191, 196);
+                  break;
+               case 106:
+                  if (curChar == 46)
+                     jjCheckNAddTwoStates(97, 107);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 67)
+                        kind = 67;
+                     jjCheckNAdd(53);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(223, 226);
+                  else if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 35;
+                  if (curChar == 110)
+                     jjAddStates(227, 228);
+                  else if (curChar == 103)
+                     jjAddStates(229, 230);
+                  else if (curChar == 108)
+                     jjAddStates(231, 232);
+                  else if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  else if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  else if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 33;
+                  break;
+               case 107:
+                  if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+                     kind = 71;
+                  break;
+               case 67:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 71;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 66;
+                  break;
+               case 5:
+                  jjCheckNAddStates(208, 211);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(233, 238);
+                  break;
+               case 10:
+                  if ((0x14404400000000L & l) != 0L)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 15:
+                  if (curChar == 117)
+                     jjstateSet[jjnewStateCnt++] = 16;
+                  break;
+               case 16:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 17;
+                  break;
+               case 17:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 18:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  break;
+               case 19:
+                  if ((0x7e0000007eL & l) != 0L)
+                     jjCheckNAddStates(208, 211);
+                  break;
+               case 23:
+                  jjAddStates(204, 207);
+                  break;
+               case 26:
+                  if (curChar == 92)
+                     jjAddStates(219, 220);
+                  break;
+               case 32:
+                  if (curChar == 100 && kind > 43)
+                     kind = 43;
+                  break;
+               case 33:
+                  if (curChar == 110)
+                     jjstateSet[jjnewStateCnt++] = 32;
+                  break;
+               case 34:
+                  if (curChar == 97)
+                     jjstateSet[jjnewStateCnt++] = 33;
+                  break;
+               case 35:
+                  if (curChar == 124 && kind > 44)
+                     kind = 44;
+                  break;
+               case 36:
+                  if (curChar == 124)
+                     jjstateSet[jjnewStateCnt++] = 35;
+                  break;
+               case 37:
+                  if (curChar == 114 && kind > 44)
+                     kind = 44;
+                  break;
+               case 38:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 37;
+                  break;
+               case 47:
+                  if (curChar == 113 && kind > 49)
+                     kind = 49;
+                  break;
+               case 48:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 47;
+                  break;
+               case 52:
+               case 53:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  jjCheckNAdd(53);
+                  break;
+               case 54:
+                  if (curChar == 92)
+                     jjCheckNAddStates(223, 226);
+                  break;
+               case 55:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(55, 56);
+                  break;
+               case 57:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(57, 58);
+                  break;
+               case 59:
+                  if (curChar == 92)
+                     jjAddStates(88, 89);
+                  break;
+               case 63:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(64, 65);
+                  break;
+               case 66:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 63;
+                  break;
+               case 68:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(64, 65);
+                  break;
+               case 69:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 68;
+                  break;
+               case 70:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 69;
+                  break;
+               case 71:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 70;
+                  break;
+               case 72:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 71;
+                  break;
+               case 74:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 76:
+                  if (curChar == 108)
+                     jjAddStates(231, 232);
+                  break;
+               case 77:
+                  if (curChar == 116 && kind > 45)
+                     kind = 45;
+                  break;
+               case 78:
+                  if (curChar == 101 && kind > 46)
+                     kind = 46;
+                  break;
+               case 79:
+                  if (curChar == 103)
+                     jjAddStates(229, 230);
+                  break;
+               case 80:
+                  if (curChar == 116 && kind > 47)
+                     kind = 47;
+                  break;
+               case 81:
+                  if (curChar == 101 && kind > 48)
+                     kind = 48;
+                  break;
+               case 82:
+                  if (curChar == 110)
+                     jjAddStates(227, 228);
+                  break;
+               case 83:
+                  if (curChar == 101 && kind > 50)
+                     kind = 50;
+                  break;
+               case 84:
+                  if (curChar == 116 && kind > 51)
+                     kind = 51;
+                  break;
+               case 85:
+                  if (curChar == 111)
+                     jjstateSet[jjnewStateCnt++] = 84;
+                  break;
+               case 93:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(239, 240);
+                  break;
+               case 98:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(241, 242);
+                  break;
+               case 102:
+                  if ((0x2000000020L & l) != 0L)
+                     jjAddStates(243, 244);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 5:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(208, 211);
+                  break;
+               case 23:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     jjAddStates(204, 207);
+                  break;
+               case 74:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 108 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_11(int pos, long active0)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x1a00000L) != 0L)
+            return 2;
+         return -1;
+      case 1:
+         if ((active0 & 0x800000L) != 0L)
+            return 0;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_11(int pos, long active0)
+{
+   return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_11()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_11(0xa00000L);
+      default :
+         return jjMoveNfa_11(3, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_11(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_11(0, active0);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_11(1, 23, 0);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_11(active0, 0x200000L);
+      default :
+         break;
+   }
+   return jjStartNfa_11(0, active0);
+}
+private int jjMoveStringLiteralDfa2_11(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_11(0, old0);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_11(1, active0);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_11(1, active0);
+}
+private int jjStartNfaWithStates_11(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_11(state, pos + 1);
+}
+private int jjMoveNfa_11(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 12;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(9, 10);
+                  }
+                  else if (curChar == 35)
+                     jjstateSet[jjnewStateCnt++] = 2;
+                  break;
+               case 0:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 1:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               case 2:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 6:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 8:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 11:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(9, 10);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 3:
+                  if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 1:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(115, 116);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+private final int jjStopStringLiteralDfa_4(int pos, long active0, long active1)
+{
+   switch (pos)
+   {
+      case 0:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            return 1;
+         }
+         if ((active0 & 0x3a00000L) != 0L)
+            return 17;
+         return -1;
+      case 1:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 1;
+            return 1;
+         }
+         if ((active0 & 0x800000L) != 0L)
+            return 23;
+         return -1;
+      case 2:
+         if ((active0 & 0x3000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 2;
+            return 1;
+         }
+         return -1;
+      case 3:
+         if ((active0 & 0x2000000000L) != 0L)
+         {
+            jjmatchedKind = 67;
+            jjmatchedPos = 3;
+            return 1;
+         }
+         if ((active0 & 0x1000000000L) != 0L)
+            return 1;
+         return -1;
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_4(int pos, long active0, long active1)
+{
+   return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0, active1), pos + 1);
+}
+private int jjMoveStringLiteralDfa0_4()
+{
+   switch(curChar)
+   {
+      case 28:
+         return jjStopAtPos(0, 2);
+      case 35:
+         jjmatchedKind = 24;
+         return jjMoveStringLiteralDfa1_4(0x2a00000L);
+      case 40:
+         return jjStopAtPos(0, 14);
+      case 91:
+         return jjStopAtPos(0, 3);
+      case 102:
+         return jjMoveStringLiteralDfa1_4(0x2000000000L);
+      case 116:
+         return jjMoveStringLiteralDfa1_4(0x1000000000L);
+      case 123:
+         return jjStopAtPos(0, 72);
+      case 124:
+         jjmatchedKind = 5;
+         return jjMoveStringLiteralDfa1_4(0x10L);
+      case 125:
+         return jjStopAtPos(0, 73);
+      default :
+         return jjMoveNfa_4(0, 0);
+   }
+}
+private int jjMoveStringLiteralDfa1_4(long active0)
+{
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_4(0, active0, 0L);
+      return 1;
+   }
+   switch(curChar)
+   {
+      case 35:
+         if ((active0 & 0x2000000L) != 0L)
+            return jjStopAtPos(1, 25);
+         break;
+      case 42:
+         if ((active0 & 0x800000L) != 0L)
+            return jjStartNfaWithStates_4(1, 23, 23);
+         break;
+      case 91:
+         return jjMoveStringLiteralDfa2_4(active0, 0x200000L);
+      case 97:
+         return jjMoveStringLiteralDfa2_4(active0, 0x2000000000L);
+      case 114:
+         return jjMoveStringLiteralDfa2_4(active0, 0x1000000000L);
+      case 124:
+         if ((active0 & 0x10L) != 0L)
+            return jjStopAtPos(1, 4);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_4(0, active0, 0L);
+}
+private int jjMoveStringLiteralDfa2_4(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_4(0, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_4(1, active0, 0L);
+      return 2;
+   }
+   switch(curChar)
+   {
+      case 91:
+         if ((active0 & 0x200000L) != 0L)
+            return jjStopAtPos(2, 21);
+         break;
+      case 108:
+         return jjMoveStringLiteralDfa3_4(active0, 0x2000000000L);
+      case 117:
+         return jjMoveStringLiteralDfa3_4(active0, 0x1000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_4(1, active0, 0L);
+}
+private int jjMoveStringLiteralDfa3_4(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_4(1, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_4(2, active0, 0L);
+      return 3;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x1000000000L) != 0L)
+            return jjStartNfaWithStates_4(3, 36, 1);
+         break;
+      case 115:
+         return jjMoveStringLiteralDfa4_4(active0, 0x2000000000L);
+      default :
+         break;
+   }
+   return jjStartNfa_4(2, active0, 0L);
+}
+private int jjMoveStringLiteralDfa4_4(long old0, long active0)
+{
+   if (((active0 &= old0)) == 0L)
+      return jjStartNfa_4(2, old0, 0L);
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) {
+      jjStopStringLiteralDfa_4(3, active0, 0L);
+      return 4;
+   }
+   switch(curChar)
+   {
+      case 101:
+         if ((active0 & 0x2000000000L) != 0L)
+            return jjStartNfaWithStates_4(4, 37, 1);
+         break;
+      default :
+         break;
+   }
+   return jjStartNfa_4(3, active0, 0L);
+}
+private int jjStartNfaWithStates_4(int pos, int kind, int state)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   try { curChar = input_stream.readChar(); }
+   catch(java.io.IOException e) { return pos + 1; }
+   return jjMoveNfa_4(state, pos + 1);
+}
+private int jjMoveNfa_4(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 26;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if (curChar == 35)
+                     jjAddStates(106, 108);
+                  else if (curChar == 36)
+                  {
+                     if (kind > 19)
+                        kind = 19;
+                     jjCheckNAddTwoStates(9, 10);
+                  }
+                  else if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 3;
+                  break;
+               case 17:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 23;
+                  break;
+               case 1:
+                  if ((0x3ff000000000000L & l) == 0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 2:
+                  if (curChar == 46)
+                     jjstateSet[jjnewStateCnt++] = 3;
+                  break;
+               case 6:
+                  if (curChar == 36 && kind > 19)
+                     kind = 19;
+                  break;
+               case 8:
+                  if (curChar == 36)
+                     jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 10:
+                  if (curChar == 33 && kind > 20)
+                     kind = 20;
+                  break;
+               case 11:
+                  if (curChar != 36)
+                     break;
+                  if (kind > 19)
+                     kind = 19;
+                  jjCheckNAddTwoStates(9, 10);
+                  break;
+               case 12:
+                  if (curChar == 35)
+                     jjAddStates(106, 108);
+                  break;
+               case 14:
+                  if ((0x100000200L & l) != 0L)
+                     jjAddStates(109, 110);
+                  break;
+               case 15:
+                  if (curChar == 40 && kind > 18)
+                     kind = 18;
+                  break;
+               case 23:
+                  if (curChar == 42)
+                     jjstateSet[jjnewStateCnt++] = 24;
+                  break;
+               case 24:
+                  if ((0xfffffff7efffffffL & l) != 0L && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 0:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 67)
+                        kind = 67;
+                     jjCheckNAdd(1);
+                  }
+                  else if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 17:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  else if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 16;
+                  break;
+               case 1:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 67)
+                     kind = 67;
+                  jjCheckNAdd(1);
+                  break;
+               case 3:
+                  if ((0x7fffffe87fffffeL & l) != 0L && kind > 71)
+                     kind = 71;
+                  break;
+               case 4:
+                  if (curChar == 92)
+                     jjCheckNAddStates(111, 114);
+                  break;
+               case 5:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(5, 6);
+                  break;
+               case 7:
+                  if (curChar == 92)
+                     jjCheckNAddTwoStates(7, 8);
+                  break;
+               case 9:
+                  if (curChar == 92)
+                     jjAddStates(115, 116);
+                  break;
+               case 13:
+                  if (curChar == 116)
+                     jjCheckNAddTwoStates(14, 15);
+                  break;
+               case 16:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 13;
+                  break;
+               case 18:
+                  if (curChar == 125)
+                     jjCheckNAddTwoStates(14, 15);
+                  break;
+               case 19:
+                  if (curChar == 116)
+                     jjstateSet[jjnewStateCnt++] = 18;
+                  break;
+               case 20:
+                  if (curChar == 101)
+                     jjstateSet[jjnewStateCnt++] = 19;
+                  break;
+               case 21:
+                  if (curChar == 115)
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  break;
+               case 22:
+                  if (curChar == 123)
+                     jjstateSet[jjnewStateCnt++] = 21;
+                  break;
+               case 24:
+                  if (kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int hiByte = (int)(curChar >> 8);
+         int i1 = hiByte >> 6;
+         long l1 = 1L << (hiByte & 077);
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 24:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 22)
+                     kind = 22;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+static final int[] jjnextStates = {
+   15, 20, 23, 12, 13, 3, 4, 5, 6, 7, 8, 61, 63, 64, 65, 70, 
+   71, 4, 5, 7, 61, 64, 10, 70, 19, 20, 44, 47, 54, 59, 22, 23, 
+   24, 25, 31, 36, 39, 13, 14, 26, 27, 68, 69, 72, 73, 80, 82, 83, 
+   84, 89, 90, 80, 83, 56, 89, 27, 29, 30, 33, 9, 11, 12, 13, 9, 
+   16, 11, 12, 13, 24, 25, 31, 32, 76, 78, 73, 74, 70, 71, 62, 63, 
+   64, 65, 14, 15, 17, 19, 24, 25, 59, 60, 66, 67, 87, 88, 91, 92, 
+   6, 7, 8, 9, 10, 11, 8, 9, 10, 11, 17, 22, 25, 14, 15, 5, 
+   6, 7, 8, 9, 10, 86, 88, 89, 90, 95, 96, 86, 89, 56, 95, 65, 
+   66, 68, 69, 70, 71, 82, 84, 79, 80, 76, 77, 93, 94, 97, 98, 0, 
+   1, 3, 25, 30, 33, 7, 8, 10, 11, 22, 23, 13, 14, 15, 16, 17, 
+   18, 20, 22, 49, 4, 50, 39, 44, 47, 4, 5, 6, 10, 12, 13, 15, 
+   16, 5, 6, 10, 7, 6, 9, 36, 37, 18, 19, 27, 28, 29, 30, 87, 
+   89, 90, 91, 101, 102, 87, 90, 96, 101, 67, 72, 75, 23, 25, 26, 29, 
+   5, 7, 8, 9, 5, 12, 7, 8, 9, 20, 21, 27, 28, 64, 65, 55, 
+   56, 57, 58, 83, 85, 80, 81, 77, 78, 10, 11, 13, 15, 20, 21, 94, 
+   95, 99, 100, 103, 104, 
+};
+private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
+{
+   switch(hiByte)
+   {
+      case 0:
+         return ((jjbitVec2[i2] & l2) != 0L);
+      default :
+         if ((jjbitVec0[i1] & l1) != 0L)
+            return true;
+         return false;
+   }
+}
+
+/** Token literal values. */
+public static final String[] jjstrLiteralImages = {
+null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
+null, null, null, null, null, null, null, null, null, null, null, null, };
+
+/** Lexer state names. */
+public static final String[] lexStateNames = {
+   "PRE_DIRECTIVE",
+   "PRE_REFERENCE",
+   "PRE_OLD_REFERENCE",
+   "REFERENCE",
+   "REFMODIFIER",
+   "OLD_REFMODIFIER",
+   "REFMOD3",
+   "REFINDEX",
+   "DIRECTIVE",
+   "REFMOD2",
+   "DEFAULT",
+   "REFMOD",
+   "IN_TEXTBLOCK",
+   "IN_MULTILINE_COMMENT",
+   "IN_FORMAL_COMMENT",
+   "IN_SINGLE_LINE_COMMENT",
+   "ALT_VAL",
+   "IN_MULTI_LINE_COMMENT",
+};
+
+/** Lex State array. */
+public static final int[] jjnewLexState = {
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+   -1, -1, -1, -1, -1, -1, -1, -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 = {
+   0x8dffffff3e07ffffL, 0x1f3c9L, 
+};
+static final long[] jjtoSkip = {
+   0x40000000L, 0xc00L, 
+};
+static final long[] jjtoSpecial = {
+   0x0L, 0xc00L, 
+};
+static final long[] jjtoMore = {
+   0x81f80000L, 0x0L, 
+};
+protected CharStream input_stream;
+private final int[] jjrounds = new int[108];
+private final int[] jjstateSet = new int[216];
+private final StringBuilder jjimage = new StringBuilder();
+private StringBuilder image = jjimage;
+private int jjimageLen;
+private int lengthOfMatch;
+protected char curChar;
+
+/** Constructor with parser. */
+public StandardParserTokenManager(StandardParser parserArg, CharStream stream){
+   parser = parserArg;
+   input_stream = stream;
+}
+
+/** Constructor with parser. */
+public StandardParserTokenManager(StandardParser parserArg, CharStream stream, int lexState){
+   this(parserArg, stream);
+   SwitchTo(lexState);
+}
+
+/** Reinitialise parser. */
+public void ReInit(CharStream stream)
+{
+   jjmatchedPos = jjnewStateCnt = 0;
+   curLexState = defaultLexState;
+   input_stream = stream;
+   ReInitRounds();
+}
+private void ReInitRounds()
+{
+   int i;
+   jjround = 0x80000001;
+   for (i = 108; i-- > 0;)
+      jjrounds[i] = 0x80000000;
+}
+
+/** Reinitialise parser. */
+public void ReInit(CharStream stream, int lexState)
+{
+   ReInit(stream);
+   SwitchTo(lexState);
+}
+
+/** Switch to specified lex state. */
+public void SwitchTo(int lexState)
+{
+   if (lexState >= 18 || lexState < 0)
+      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+   else
+      curLexState = lexState;
+}
+
+protected Token jjFillToken()
+{
+   final Token t;
+   final String curTokenImage;
+   final int beginLine;
+   final int endLine;
+   final int beginColumn;
+   final int endColumn;
+   String im = jjstrLiteralImages[jjmatchedKind];
+   curTokenImage = (im == null) ? input_stream.GetImage() : im;
+   beginLine = input_stream.getBeginLine();
+   beginColumn = input_stream.getBeginColumn();
+   endLine = input_stream.getEndLine();
+   endColumn = input_stream.getEndColumn();
+   t = Token.newToken(jjmatchedKind, curTokenImage);
+
+   t.beginLine = beginLine;
+   t.endLine = endLine;
+   t.beginColumn = beginColumn;
+   t.endColumn = endColumn;
+
+   return t;
+}
+
+int curLexState = 10;
+int defaultLexState = 10;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+/** Get the next Token. */
+public Token getNextToken() 
+{
+  Token specialToken = null;
+  Token matchedToken;
+  int curPos = 0;
+
+  EOFLoop :
+  for (;;)
+  {
+   try
+   {
+      curChar = input_stream.BeginToken();
+   }
+   catch(java.io.IOException e)
+   {
+      jjmatchedKind = 0;
+      matchedToken = jjFillToken();
+      matchedToken.specialToken = specialToken;
+      return matchedToken;
+   }
+   image = jjimage;
+   image.setLength(0);
+   jjimageLen = 0;
+
+   for (;;)
+   {
+     switch(curLexState)
+     {
+       case 0:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_0();
+         if (jjmatchedPos == 0 && jjmatchedKind > 75)
+         {
+            jjmatchedKind = 75;
+         }
+         break;
+       case 1:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_1();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 2:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_2();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 3:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_3();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 4:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_4();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 5:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_5();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 6:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_6();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 7:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_7();
+         break;
+       case 8:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_8();
+         break;
+       case 9:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_9();
+         break;
+       case 10:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_10();
+         break;
+       case 11:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_11();
+         if (jjmatchedPos == 0 && jjmatchedKind > 74)
+         {
+            jjmatchedKind = 74;
+         }
+         break;
+       case 12:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_12();
+         break;
+       case 13:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_13();
+         break;
+       case 14:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_14();
+         if (jjmatchedPos == 0 && jjmatchedKind > 30)
+         {
+            jjmatchedKind = 30;
+         }
+         break;
+       case 15:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_15();
+         if (jjmatchedPos == 0 && jjmatchedKind > 30)
+         {
+            jjmatchedKind = 30;
+         }
+         break;
+       case 16:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_16();
+         break;
+       case 17:
+         jjmatchedKind = 0x7fffffff;
+         jjmatchedPos = 0;
+         curPos = jjMoveStringLiteralDfa0_17();
+         if (jjmatchedPos == 0 && jjmatchedKind > 30)
+         {
+            jjmatchedKind = 30;
+         }
+         break;
+     }
+     if (jjmatchedKind != 0x7fffffff)
+     {
+        if (jjmatchedPos + 1 < curPos)
+           input_stream.backup(curPos - jjmatchedPos - 1);
+        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+        {
+           matchedToken = jjFillToken();
+           matchedToken.specialToken = specialToken;
+           TokenLexicalActions(matchedToken);
+       if (jjnewLexState[jjmatchedKind] != -1)
+         curLexState = jjnewLexState[jjmatchedKind];
+           return matchedToken;
+        }
+        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+        {
+           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+           {
+              matchedToken = jjFillToken();
+              if (specialToken == null)
+                 specialToken = matchedToken;
+              else
+              {
+                 matchedToken.specialToken = specialToken;
+                 specialToken = (specialToken.next = matchedToken);
+              }
+              SkipLexicalActions(matchedToken);
+           }
+           else
+              SkipLexicalActions(null);
+         if (jjnewLexState[jjmatchedKind] != -1)
+           curLexState = jjnewLexState[jjmatchedKind];
+           continue EOFLoop;
+        }
+        MoreLexicalActions();
+      if (jjnewLexState[jjmatchedKind] != -1)
+        curLexState = jjnewLexState[jjmatchedKind];
+        curPos = 0;
+        jjmatchedKind = 0x7fffffff;
+        try {
+           curChar = input_stream.readChar();
+           continue;
+        }
+        catch (java.io.IOException e1) { }
+     }
+     int error_line = input_stream.getEndLine();
+     int error_column = input_stream.getEndColumn();
+     String error_after = null;
+     boolean EOFSeen = false;
+     try { input_stream.readChar(); input_stream.backup(1); }
+     catch (java.io.IOException e1) {
+        EOFSeen = true;
+        error_after = curPos <= 1 ? "" : input_stream.GetImage();
+        if (curChar == '\n' || curChar == '\r') {
+           error_line++;
+           error_column = 0;
+        }
+        else
+           error_column++;
+     }
+     if (!EOFSeen) {
+        input_stream.backup(1);
+        error_after = curPos <= 1 ? "" : input_stream.GetImage();
+     }
+     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+   }
+  }
+}
+
+void SkipLexicalActions(Token matchedToken)
+{
+   switch(jjmatchedKind)
+   {
+      case 74 :
+         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /*
+         * push every terminator character back into the stream
+         */
+
+        input_stream.backup(1);
+
+        trace("REF_TERM :");
+
+        stateStackPop();
+         break;
+      case 75 :
+         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        trace("DIRECTIVE_TERM :");
+
+        input_stream.backup(1);
+        stateStackPop();
+         break;
+      default :
+         break;
+   }
+}
+void MoreLexicalActions()
+{
+   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
+   switch(jjmatchedKind)
+   {
+      case 19 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+        if (! inComment)
+        {
+            /*
+             * if we find ourselves in REFERENCE or PRE_REFERENCE, we need to pop down
+             * to end the previous ref
+             */
+
+            if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
+            {
+                stateStackPop();
+            }
+
+            int preReferenceState = parser.hyphenAllowedInIdentifiers ? PRE_OLD_REFERENCE : PRE_REFERENCE;
+
+            trace( " $  : going to " + lexStateNames[preReferenceState]);
+
+            /* do not push PRE states */
+            if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+            {
+                stateStackPush();
+            }
+            switchTo(preReferenceState);
+        }
+         break;
+      case 20 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+        if (! inComment)
+        {
+            /*
+             * if we find ourselves in REFERENCE or PRE_REFERENCE, we need to pop down
+             * to end the previous ref
+             */
+
+            if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
+            {
+                stateStackPop();
+            }
+
+            int preReferenceState = parser.hyphenAllowedInIdentifiers ? PRE_OLD_REFERENCE : PRE_REFERENCE;
+
+            trace( " $  : going to " + lexStateNames[preReferenceState]);
+
+            /* do not push PRE states */
+            if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+            {
+                stateStackPush();
+            }
+            switchTo(preReferenceState);
+        }
+         break;
+      case 21 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+       if (!inComment)
+       {
+           inComment = true;
+            /* do not push PRE states */
+            if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+            {
+                stateStackPush();
+            }
+           switchTo( IN_TEXTBLOCK );
+       }
+         break;
+      case 22 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+        if (!inComment)
+        {
+            input_stream.backup(1);
+            inComment = true;
+            /* do not push PRE states */
+            if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+            {
+                stateStackPush();
+            }
+            switchTo( IN_FORMAL_COMMENT);
+        }
+         break;
+      case 23 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+        if (!inComment)
+        {
+            inComment=true;
+            /* do not push PRE states */
+            if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+            {
+                stateStackPush();
+            }
+            switchTo( IN_MULTI_LINE_COMMENT );
+        }
+         break;
+      case 24 :
+         image.append(input_stream.GetSuffix(jjimageLen));
+         jjimageLen = 0;
+        if (! inComment)
+        {
+            /*
+             * We can have the situation where #if($foo)$foo#end.
+             * We need to transition out of REFERENCE before going to DIRECTIVE.
+             * I don't really like this, but I can't think of a legal way
+             * you are going into DIRECTIVE while in REFERENCE.  -gmj
+             */
+
+            if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE || curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
+            {
+                stateStackPop();
+            }
+
+            trace(" # :  going to PRE_DIRECTIVE" );
+
+            /* do not push PRE states */
+            if (curLexState != PRE_REFERENCE && curLexState != PRE_DIRECTIVE && curLexState != PRE_OLD_REFERENCE)
+            {
+                stateStackPush();
+            }
+            switchTo(PRE_DIRECTIVE);
+        }
+         break;
+      default :
+         break;
+   }
+}
+void TokenLexicalActions(Token matchedToken)
+{
+   switch(jjmatchedKind)
+   {
+      case 1 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        stateStackPop();
+         break;
+      case 3 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+     stateStackPush();
+     switchTo(REFINDEX);
+         break;
+      case 4 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+       stateStackPop();
+         break;
+      case 5 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+       if (curlyLevel == 1)
+       {
+           switchTo(ALT_VAL);
+       }
+       else
+       {
+           stateStackPop();
+       }
+         break;
+      case 6 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+     stateStackPop();
+         break;
+      case 12 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        ++curlyLevel;
+         break;
+      case 13 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        --curlyLevel;
+        if (curLexState == ALT_VAL && curlyLevel == 0)
+        {
+            stateStackPop();
+        }
+         break;
+      case 14 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        if (!inComment)
+            lparen++;
+
+        /*
+         * If in REFERENCE and we have seen the dot, then move
+         * to REFMOD2 -> Modifier()
+         */
+
+        if (curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
+            switchTo( REFMOD2 );
+         break;
+      case 15 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+       RPARENHandler();
+         break;
+      case 16 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /*
+         * need to simply switch back to REFERENCE, not drop down the stack
+         * because we can (infinitely) chain, ala
+         * $foo.bar().blargh().woogie().doogie()
+         */
+
+        switchTo( REFMOD3 );
+         break;
+      case 18 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        if (! inComment)
+        {
+            trace(" #set :  going to DIRECTIVE" );
+
+            stateStackPush();
+            setInSet(true);
+            switchTo(DIRECTIVE);
+        }
+
+        /*
+         *  need the LPAREN action
+         */
+
+        if (!inComment)
+        {
+            lparen++;
+
+            /*
+             * If in REFERENCE and we have seen the dot, then move
+             * to REFMOD2 -> Modifier()
+             */
+
+            if (curLexState == REFMODIFIER || curLexState == OLD_REFMODIFIER )
+                switchTo( REFMOD2 );
+        }
+         break;
+      case 25 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        if (!inComment)
+        {
+            if (curLexState == REFERENCE || curLexState == PRE_REFERENCE || curLexState == PRE_OLD_REFERENCE)
+            {
+                stateStackPop();
+            }
+
+            inComment = true;
+            stateStackPush();
+            switchTo(IN_SINGLE_LINE_COMMENT);
+        }
+         break;
+      case 26 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+     inComment = false;
+     stateStackPop();
+     if (curLexState == REFERENCE || curLexState == REFMOD3)
+     {
+       // end of reference: pop again
+       stateStackPop();
+     }
+         break;
+      case 27 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+    inComment = false;
+    stateStackPop();
+     if (curLexState == REFERENCE || curLexState == REFMOD3)
+     {
+       // end of reference: pop again
+       stateStackPop();
+     }
+         break;
+      case 28 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+    inComment = false;
+    stateStackPop();
+     if (curLexState == REFERENCE || curLexState == REFMOD3)
+     {
+       // end of reference: pop again
+       stateStackPop();
+     }
+         break;
+      case 29 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+    inComment = false;
+    stateStackPop();
+         break;
+      case 33 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        trace(" NEWLINE :");
+
+        /* if (isInSet()) */
+        setInSet(false);
+         break;
+      case 34 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+    stateStackPop();
+         break;
+      case 35 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /*
+         *  - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
+         *      don't forget to account for the beloved yet wierd #set
+         *  - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
+         */
+
+         if( curLexState == DIRECTIVE && !isInSet() && lparen == 0)
+            stateStackPop();
+         break;
+      case 53 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        stateStackPop();
+         break;
+      case 54 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        switchTo(DIRECTIVE);
+         break;
+      case 55 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        switchTo(DIRECTIVE);
+         break;
+      case 56 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        stateStackPop();
+         break;
+      case 58 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /*
+         * Remove the double period if it is there
+         */
+        if (matchedToken.image.endsWith("..")) {
+            input_stream.backup(2);
+            matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2);
+        }
+
+        /*
+         * check to see if we are in set
+         *    ex.  #set($foo = $foo + 3)
+         *  because we want to handle the \n after
+         */
+
+        if ( lparen == 0 && !isInSet() && curLexState != REFMOD2 && curLexState != REFINDEX && curLexState != ALT_VAL)
+        {
+            stateStackPop();
+        }
+         break;
+      case 59 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /*
+         * check to see if we are in set
+         *    ex.  #set $foo = $foo + 3
+         *  because we want to handle the \n after
+         */
+
+        if ( lparen == 0 && !isInSet() && curLexState != REFMOD2 && curLexState != ALT_VAL)
+        {
+            stateStackPop();
+    }
+         break;
+      case 67 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        if (curLexState == PRE_REFERENCE)
+        {
+            switchTo(REFERENCE);
+        }
+         break;
+      case 70 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        if (curLexState == PRE_OLD_REFERENCE)
+        {
+            switchTo(REFERENCE);
+        }
+         break;
+      case 71 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /*
+         * push the alpha char back into the stream so the following identifier
+         * is complete
+         */
+
+        input_stream.backup(1);
+
+        /*
+         * and munge the <DOT> so we just get a . when we have normal text that
+         * looks like a ref.ident
+         */
+
+        matchedToken.image = ".";
+
+        int refModifierState = parser.hyphenAllowedInIdentifiers ? OLD_REFMODIFIER : REFMODIFIER;
+
+        trace("DOT : switching to " + lexStateNames[refModifierState]);
+        switchTo(refModifierState);
+         break;
+      case 72 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        ++curlyLevel;
+         break;
+      case 73 :
+        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
+        /* maybe it wasn't for our state */
+        while (curlyLevel == 0 && curLexState != DEFAULT)
+        {
+            stateStackPop();
+        }
+        /* At this point, here are all the possible states:
+         *   - DEFAULT, which means the '}' is schmoo
+         *   - DIRECTIVE or REFMOD2, which means the '}' is a closing map curly
+         *   - one of the other REFERENCE states or ALT_VAL, which means the '}' ends the reference
+         * If we're in the last case, pop up state.
+         */
+        if (curLexState != DEFAULT && curLexState != DIRECTIVE && curLexState != REFMOD2)
+        {
+            stateStackPop();
+        }
+         break;
+      default :
+         break;
+   }
+}
+private void jjCheckNAdd(int state)
+{
+   if (jjrounds[state] != jjround)
+   {
+      jjstateSet[jjnewStateCnt++] = state;
+      jjrounds[state] = jjround;
+   }
+}
+private void jjAddStates(int start, int end)
+{
+   do {
+      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+   } while (start++ != end);
+}
+private void jjCheckNAddTwoStates(int state1, int state2)
+{
+   jjCheckNAdd(state1);
+   jjCheckNAdd(state2);
+}
+
+private void jjCheckNAddStates(int start, int end)
+{
+   do {
+      jjCheckNAdd(jjnextStates[start]);
+   } while (start++ != end);
+}
+
+}
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/Token.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/Token.java
new file mode 100644
index 00000000..066bbbbd
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/Token.java
@@ -0,0 +1,131 @@
+/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */
+/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */
+package org.apache.velocity.runtime.parser;
+
+/**
+ * Describes the input token stream.
+ */
+
+public class Token implements java.io.Serializable {
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * An integer that describes the kind of this token.  This numbering
+   * system is determined by JavaCCParser, and a table of these numbers is
+   * stored in the file ...Constants.java.
+   */
+  public int kind;
+
+  /** The line number of the first character of this Token. */
+  public int beginLine;
+  /** The column number of the first character of this Token. */
+  public int beginColumn;
+  /** The line number of the last character of this Token. */
+  public int endLine;
+  /** The column number of the last character of this Token. */
+  public int endColumn;
+
+  /**
+   * The string image of the token.
+   */
+  public String image;
+
+  /**
+   * A reference to the next regular (non-special) token from the input
+   * stream.  If this is the last token from the input stream, or if the
+   * token manager has not read tokens beyond this one, this field is
+   * set to null.  This is true only if this token is also a regular
+   * token.  Otherwise, see below for a description of the contents of
+   * this field.
+   */
+  public Token next;
+
+  /**
+   * This field is used to access special tokens that occur prior to this
+   * token, but after the immediately preceding regular (non-special) token.
+   * If there are no such special tokens, this field is set to null.
+   * When there are more than one such special token, this field refers
+   * to the last of these special tokens, which in turn refers to the next
+   * previous special token through its specialToken field, and so on
+   * until the first special token (whose specialToken field is null).
+   * The next fields of special tokens refer to other special tokens that
+   * immediately follow it (without an intervening regular token).  If there
+   * is no such token, this field is null.
+   */
+  public Token specialToken;
+
+  /**
+   * An optional attribute value of the Token.
+   * Tokens which are not used as syntactic sugar will often contain
+   * meaningful values that will be used later on by the compiler or
+   * interpreter. This attribute value is often different from the image.
+   * Any subclass of Token that actually wants to return a non-null value can
+   * override this method as appropriate.
+   */
+  public Object getValue() {
+    return null;
+  }
+
+  /**
+   * No-argument constructor
+   */
+  public Token() {}
+
+  /**
+   * Constructs a new token for the specified Image.
+   */
+  public Token(int kind)
+  {
+    this(kind, null);
+  }
+
+  /**
+   * Constructs a new token for the specified Image and Kind.
+   */
+  public Token(int kind, String image)
+  {
+    this.kind = kind;
+    this.image = image;
+  }
+
+  /**
+   * Returns the image.
+   */
+  public String toString()
+  {
+    return image;
+  }
+
+  /**
+   * Returns a new Token object, by default. However, if you want, you
+   * can create and return subclass objects based on the value of ofKind.
+   * Simply add the cases to the switch for all those special cases.
+   * For example, if you have a subclass of Token called IDToken that
+   * you want to create if ofKind is ID, simply add something like :
+   *
+   *    case MyParserConstants.ID : return new IDToken(ofKind, image);
+   *
+   * to the following switch statement. Then you can cast matchedToken
+   * variable to the appropriate type and use sit in your lexical actions.
+   */
+  public static Token newToken(int ofKind, String image)
+  {
+    switch(ofKind)
+    {
+      default : return new Token(ofKind, image);
+    }
+  }
+
+  public static Token newToken(int ofKind)
+  {
+    return newToken(ofKind, null);
+  }
+
+}
+/* JavaCC - OriginalChecksum=0a7b7b090d8309460a5e68cffc5e2260 (do not edit this line) */
diff --git a/generated-sources/javacc/org/apache/velocity/runtime/parser/TokenMgrError.java b/generated-sources/javacc/org/apache/velocity/runtime/parser/TokenMgrError.java
new file mode 100644
index 00000000..f4812925
--- /dev/null
+++ b/generated-sources/javacc/org/apache/velocity/runtime/parser/TokenMgrError.java
@@ -0,0 +1,147 @@
+/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */
+/* JavaCCOptions: */
+package org.apache.velocity.runtime.parser;
+
+/** Token Manager Error. */
+public class TokenMgrError extends Error
+{
+
+  /**
+   * The version identifier for this Serializable class.
+   * Increment only if the <i>serialized</i> form of the
+   * class changes.
+   */
+  private static final long serialVersionUID = 1L;
+
+  /*
+   * Ordinals for various reasons why an Error of this type can be thrown.
+   */
+
+  /**
+   * Lexical error occurred.
+   */
+  public static final int LEXICAL_ERROR = 0;
+
+  /**
+   * An attempt was made to create a second instance of a static token manager.
+   */
+  public static final int STATIC_LEXER_ERROR = 1;
+
+  /**
+   * Tried to change to an invalid lexical state.
+   */
+  public static final int INVALID_LEXICAL_STATE = 2;
+
+  /**
+   * Detected (and bailed out of) an infinite loop in the token manager.
+   */
+  public static final int LOOP_DETECTED = 3;
+
+  /**
+   * Indicates the reason why the exception is thrown. It will have
+   * one of the above 4 values.
+   */
+  int errorCode;
+
+  /**
+   * Replaces unprintable characters by their escaped (or unicode escaped)
+   * equivalents in the given string
+   */
+  protected static final String addEscapes(String str) {
+    StringBuffer retval = new StringBuffer();
+    char ch;
+    for (int i = 0; i < str.length(); i++) {
+      switch (str.charAt(i))
+      {
+        case 0 :
+          continue;
+        case '\b':
+          retval.append("\\b");
+          continue;
+        case '\t':
+          retval.append("\\t");
+          continue;
+        case '\n':
+          retval.append("\\n");
+          continue;
+        case '\f':
+          retval.append("\\f");
+          continue;
+        case '\r':
+          retval.append("\\r");
+          continue;
+        case '\"':
+          retval.append("\\\"");
+          continue;
+        case '\'':
+          retval.append("\\\'");
+          continue;
+        case '\\':
+          retval.append("\\\\");
+          continue;
+        default:
+          if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+            String s = "0000" + Integer.toString(ch, 16);
+            retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+          } else {
+            retval.append(ch);
+          }
+          continue;
+      }
+    }
+    return retval.toString();
+  }
+
+  /**
+   * Returns a detailed message for the Error when it is thrown by the
+   * token manager to indicate a lexical error.
+   * Parameters :
+   *    EOFSeen     : indicates if EOF caused the lexical error
+   *    curLexState : lexical state in which this error occurred
+   *    errorLine   : line number when the error occurred
+   *    errorColumn : column number when the error occurred
+   *    errorAfter  : prefix that was seen before this error occurred
+   *    curchar     : the offending character
+   * Note: You can customize the lexical error message by modifying this method.
+   */
+  protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
+    return("Lexical error at line " +
+          errorLine + ", column " +
+          errorColumn + ".  Encountered: " +
+          (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
+          "after : \"" + addEscapes(errorAfter) + "\"");
+  }
+
+  /**
+   * You can also modify the body of this method to customize your error messages.
+   * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
+   * of end-users concern, so you can return something like :
+   *
+   *     "Internal Error : Please file a bug report .... "
+   *
+   * from this method for such cases in the release version of your parser.
+   */
+  public String getMessage() {
+    return super.getMessage();
+  }
+
+  /*
+   * Constructors of various flavors follow.
+   */
+
+  /** No arg constructor. */
+  public TokenMgrError() {
+  }
+
+  /** Constructor with message and reason. */
+  public TokenMgrError(String message, int reason) {
+    super(message);
+    errorCode = reason;
+  }
+
+  /** Full Constructor. */
+  public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
+    this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
+  }
+}
+/* JavaCC - OriginalChecksum=42f02fdec2666762ff549943b174bf6b (do not edit this line) */
diff --git a/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/JJTStandardParserState.java b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/JJTStandardParserState.java
new file mode 100644
index 00000000..eb61e104
--- /dev/null
+++ b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/JJTStandardParserState.java
@@ -0,0 +1,125 @@
+/* Generated By:JavaCC: Do not edit this line. JJTStandardParserState.java Version 5.0 */
+package org.apache.velocity.runtime.parser.node;
+
+import org.apache.velocity.runtime.parser.*;
+
+public class JJTStandardParserState {
+  private java.util.List<Node> nodes;
+  private java.util.List<Integer> marks;
+
+  private int sp;        // number of nodes on stack
+  private int mk;        // current mark
+  private boolean node_created;
+
+  public JJTStandardParserState() {
+    nodes = new java.util.ArrayList<Node>();
+    marks = new java.util.ArrayList<Integer>();
+    sp = 0;
+    mk = 0;
+  }
+
+  /* Determines whether the current node was actually closed and
+     pushed.  This should only be called in the final user action of a
+     node scope.  */
+  public boolean nodeCreated() {
+    return node_created;
+  }
+
+  /* Call this to reinitialize the node stack.  It is called
+     automatically by the parser's ReInit() method. */
+  public void reset() {
+    nodes.clear();
+    marks.clear();
+    sp = 0;
+    mk = 0;
+  }
+
+  /* Returns the root node of the AST.  It only makes sense to call
+     this after a successful parse. */
+  public Node rootNode() {
+    return nodes.get(0);
+  }
+
+  /* Pushes a node on to the stack. */
+  public void pushNode(Node n) {
+    nodes.add(n);
+    ++sp;
+  }
+
+  /* Returns the node on the top of the stack, and remove it from the
+     stack.  */
+  public Node popNode() {
+    if (--sp < mk) {
+      mk = marks.remove(marks.size()-1);
+    }
+    return nodes.remove(nodes.size()-1);
+  }
+
+  /* Returns the node currently on the top of the stack. */
+  public Node peekNode() {
+    return nodes.get(nodes.size()-1);
+  }
+
+  /* Returns the number of children on the stack in the current node
+     scope. */
+  public int nodeArity() {
+    return sp - mk;
+  }
+
+
+  public void clearNodeScope(Node n) {
+    while (sp > mk) {
+      popNode();
+    }
+    mk = marks.remove(marks.size()-1);
+  }
+
+
+  public void openNodeScope(Node n) {
+    marks.add(mk);
+    mk = sp;
+    n.jjtOpen();
+  }
+
+
+  /* A definite node is constructed from a specified number of
+     children.  That number of nodes are popped from the stack and
+     made the children of the definite node.  Then the definite node
+     is pushed on to the stack. */
+  public void closeNodeScope(Node n, int num) {
+    mk = marks.remove(marks.size()-1);
+    while (num-- > 0) {
+      Node c = popNode();
+      c.jjtSetParent(n);
+      n.jjtAddChild(c, num);
+    }
+    n.jjtClose();
+    pushNode(n);
+    node_created = true;
+  }
+
+
+  /* A conditional node is constructed if its condition is true.  All
+     the nodes that have been pushed since the node was opened are
+     made children of the conditional node, which is then pushed
+     on to the stack.  If the condition is false the node is not
+     constructed and they are left on the stack. */
+  public void closeNodeScope(Node n, boolean condition) {
+    if (condition) {
+      int a = nodeArity();
+      mk = marks.remove(marks.size()-1);
+      while (a-- > 0) {
+        Node c = popNode();
+        c.jjtSetParent(n);
+        n.jjtAddChild(c, a);
+      }
+      n.jjtClose();
+      pushNode(n);
+      node_created = true;
+    } else {
+      mk = marks.remove(marks.size()-1);
+      node_created = false;
+    }
+  }
+}
+/* JavaCC - OriginalChecksum=d34682d17dff0a3b107321d543729d5d (do not edit this line) */
diff --git a/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserTreeConstants.java b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserTreeConstants.java
new file mode 100644
index 00000000..f6cdcb65
--- /dev/null
+++ b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserTreeConstants.java
@@ -0,0 +1,101 @@
+/* Generated By:JavaCC: Do not edit this line. StandardParserTreeConstants.java Version 5.0 */
+package org.apache.velocity.runtime.parser.node;
+
+import org.apache.velocity.runtime.parser.*;
+
+public interface StandardParserTreeConstants
+{
+  public int JJTPROCESS = 0;
+  public int JJTVOID = 1;
+  public int JJTTEXT = 2;
+  public int JJTESCAPEDDIRECTIVE = 3;
+  public int JJTESCAPE = 4;
+  public int JJTCOMMENT = 5;
+  public int JJTTEXTBLOCK = 6;
+  public int JJTFLOATINGPOINTLITERAL = 7;
+  public int JJTINTEGERLITERAL = 8;
+  public int JJTSTRINGLITERAL = 9;
+  public int JJTIDENTIFIER = 10;
+  public int JJTWORD = 11;
+  public int JJTDIRECTIVEASSIGN = 12;
+  public int JJTDIRECTIVE = 13;
+  public int JJTBLOCK = 14;
+  public int JJTMAP = 15;
+  public int JJTOBJECTARRAY = 16;
+  public int JJTINTEGERRANGE = 17;
+  public int JJTMETHOD = 18;
+  public int JJTINDEX = 19;
+  public int JJTREFERENCE = 20;
+  public int JJTTRUE = 21;
+  public int JJTFALSE = 22;
+  public int JJTIFSTATEMENT = 23;
+  public int JJTELSESTATEMENT = 24;
+  public int JJTELSEIFSTATEMENT = 25;
+  public int JJTSETDIRECTIVE = 26;
+  public int JJTEXPRESSION = 27;
+  public int JJTASSIGNMENT = 28;
+  public int JJTORNODE = 29;
+  public int JJTANDNODE = 30;
+  public int JJTEQNODE = 31;
+  public int JJTNENODE = 32;
+  public int JJTLTNODE = 33;
+  public int JJTGTNODE = 34;
+  public int JJTLENODE = 35;
+  public int JJTGENODE = 36;
+  public int JJTADDNODE = 37;
+  public int JJTSUBTRACTNODE = 38;
+  public int JJTMULNODE = 39;
+  public int JJTDIVNODE = 40;
+  public int JJTMODNODE = 41;
+  public int JJTNOTNODE = 42;
+  public int JJTNEGATENODE = 43;
+
+
+  public String[] jjtNodeName = {
+    "process",
+    "void",
+    "Text",
+    "EscapedDirective",
+    "Escape",
+    "Comment",
+    "Textblock",
+    "FloatingPointLiteral",
+    "IntegerLiteral",
+    "StringLiteral",
+    "Identifier",
+    "Word",
+    "DirectiveAssign",
+    "Directive",
+    "Block",
+    "Map",
+    "ObjectArray",
+    "IntegerRange",
+    "Method",
+    "Index",
+    "Reference",
+    "True",
+    "False",
+    "IfStatement",
+    "ElseStatement",
+    "ElseIfStatement",
+    "SetDirective",
+    "Expression",
+    "Assignment",
+    "OrNode",
+    "AndNode",
+    "EQNode",
+    "NENode",
+    "LTNode",
+    "GTNode",
+    "LENode",
+    "GENode",
+    "AddNode",
+    "SubtractNode",
+    "MulNode",
+    "DivNode",
+    "ModNode",
+    "NotNode",
+    "NegateNode",
+  };
+}
+/* JavaCC - OriginalChecksum=3cbe37a416c36eb645df00e50cd4ad4d (do not edit this line) */
diff --git a/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserVisitor.java b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserVisitor.java
new file mode 100644
index 00000000..0140ae18
--- /dev/null
+++ b/generated-sources/jjtree/org/apache/velocity/runtime/parser/node/StandardParserVisitor.java
@@ -0,0 +1,53 @@
+/* Generated By:JavaCC: Do not edit this line. StandardParserVisitor.java Version 5.0 */
+package org.apache.velocity.runtime.parser.node;
+
+import org.apache.velocity.runtime.parser.*;
+
+public interface StandardParserVisitor
+{
+  public Object visit(SimpleNode node, Object data);
+  public Object visit(ASTprocess node, Object data);
+  public Object visit(ASTText node, Object data);
+  public Object visit(ASTEscapedDirective node, Object data);
+  public Object visit(ASTEscape node, Object data);
+  public Object visit(ASTComment node, Object data);
+  public Object visit(ASTTextblock node, Object data);
+  public Object visit(ASTFloatingPointLiteral node, Object data);
+  public Object visit(ASTIntegerLiteral node, Object data);
+  public Object visit(ASTStringLiteral node, Object data);
+  public Object visit(ASTIdentifier node, Object data);
+  public Object visit(ASTWord node, Object data);
+  public Object visit(ASTDirectiveAssign node, Object data);
+  public Object visit(ASTDirective node, Object data);
+  public Object visit(ASTBlock node, Object data);
+  public Object visit(ASTMap node, Object data);
+  public Object visit(ASTObjectArray node, Object data);
+  public Object visit(ASTIntegerRange node, Object data);
+  public Object visit(ASTMethod node, Object data);
+  public Object visit(ASTIndex node, Object data);
+  public Object visit(ASTReference node, Object data);
+  public Object visit(ASTTrue node, Object data);
+  public Object visit(ASTFalse node, Object data);
+  public Object visit(ASTIfStatement node, Object data);
+  public Object visit(ASTElseStatement node, Object data);
+  public Object visit(ASTElseIfStatement node, Object data);
+  public Object visit(ASTSetDirective node, Object data);
+  public Object visit(ASTExpression node, Object data);
+  public Object visit(ASTAssignment node, Object data);
+  public Object visit(ASTOrNode node, Object data);
+  public Object visit(ASTAndNode node, Object data);
+  public Object visit(ASTEQNode node, Object data);
+  public Object visit(ASTNENode node, Object data);
+  public Object visit(ASTLTNode node, Object data);
+  public Object visit(ASTGTNode node, Object data);
+  public Object visit(ASTLENode node, Object data);
+  public Object visit(ASTGENode node, Object data);
+  public Object visit(ASTAddNode node, Object data);
+  public Object visit(ASTSubtractNode node, Object data);
+  public Object visit(ASTMulNode node, Object data);
+  public Object visit(ASTDivNode node, Object data);
+  public Object visit(ASTModNode node, Object data);
+  public Object visit(ASTNotNode node, Object data);
+  public Object visit(ASTNegateNode node, Object data);
+}
+/* JavaCC - OriginalChecksum=ca5f161786ac4b6910db90de458469db (do not edit this line) */