# ExpressionEvaluator.java

    // $ANTLR 2.7.7 (20060906): "expression_evaluator.g" -> "ExpressionEvaluator.java"$

    /*
    ** Module   : ExpressionEvaluator.java
    **            ExpressionEvaluatorTokenTypes.java
    ** Abstract : provides tree walking to drive Progress 4GL expression
    **            evaluation
    **
    ** Copyright (c) 2004-2019, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- -T- --JPRM-- ----------------Description-----------------
    ** 001 GES 20041116 ADD   @18718 WARNING, THIS IS A GENERATED FILE!!!
    **                               DO NOT EDIT THIS FILE. The original source
    **                               file is expression_evaluator.g!
    */

    package com.goldencode.p2j.uast;

    import java.io.*;
    import java.lang.reflect.*;
    import java.util.logging.*;
    import antlr.*;
    import com.goldencode.ast.*;
    import com.goldencode.p2j.cfg.*;
    import com.goldencode.p2j.convert.*;
    import com.goldencode.util.*;
    import com.goldencode.p2j.util.*;

    import antlr.TreeParser;
    import antlr.Token;
    import antlr.collections.AST;
    import antlr.RecognitionException;
    import antlr.ANTLRException;
    import antlr.NoViableAltException;
    import antlr.MismatchedTokenException;
    import antlr.SemanticException;
    import antlr.collections.impl.BitSet;
    import antlr.ASTPair;
    import antlr.collections.impl.ASTArray;

    /**
     * Recursively walks an AST generated from a valid Progress 4GL expression
     * and evaluates each node to obtain the final result of the expression
     * which is returned to the caller as a <code>BaseDataType</code> (wrapper).
     * <p>
     * The caller generates a tree is by calling the
     * <code>{@link ProgressParser#expr}</code> method.  The
     * <code>{@link #evaluate}</code> method is called and this tree as passed as
     * a parameter.
     * <p>
     * Starting at the root of this tree, each node is visited recursively (in a
     * depth-first then left to right traversal).  Each node that is visited
     * must be an operator, built-in function, variable (one of the
     * non-parenthesized built-in functions like <code>OPSYS</code>) or a literal
     * (constant).  When a leaf node is encountered, a result is calculated
     * and returned.  Once all children of a node are evaluated, that node's
     * value is calculated and then returned as the result from that portion of
     * the tree (each child of an operator is an operand and is evaluated before
     * the operator's result can be calculated).  Children of function nodes are
     * the function parameters.
     * <p>
     * By rationalizing all return types as an <code>BaseDataType</code>, the
     * evaluate method is made recursive. This recursive model continues until
     * all subsequent calls to evaluate return. This final result is returned to
     * the original caller as the result of the expression evaluation.
     * <p>
     * The core of the grammar is a single rule called <code>evaluate</code>.
     * <p>
     * Some of the node processing rules are trivial enough to inline all Java
     * code necessary to calculate the return data.  Other rules require helpers,
     * some of which are in the <code>util</code> package (all of the Progress
     * 4GL compatible wrapper processing) and one of which is a manual addition
     * to this class (<code>executeCallback</code>).
     * <p>
     * All operators and features of expression processing for integer, decimal,
     * logical, date and character data types in Progress are supported. All
     * literal types (including unknown value) are supported.
     * <p>
     * Progress recid, rowid and handle expressions are not supported at
     * this time.
     * <p>
     * The following operators are supported:
     * <p>
     * <pre>
     * + (addition, unary plus, date and string concatination)
     * - (subtraction, unary minus and date)
     * *
     * /
     * modulo
     * ()
     * or
     * and
     * not
     * eq
     * ne
     * gt
     * gte
     * lt
     * lte
     * begins
     * matches
     * </pre>
     * <p>
     * The only operators that are not supported are assignment and the where
     * clause <code>contains</code>.
     * <p>
     * The following built-in functions are supported:
     * <p>
     * <pre>
     * absolute
     * asc
     * date
     * day
     * dbtype (currently hard coded to return "PROGRESS")
     * decimal
     * encode
     * entry
     * etime
     * exp
     * fill
     * index
     * int64
     * integer
     * keyword
     * keyword-all
     * lc
     * left-trim
     * length
     * log
     * lookup
     * maximum
     * minimum
     * month
     * num-entries
     * opsys
     * propath
     * proversion
     * r-index
     * random
     * replace
     * right-trim
     * round
     * sqrt
     * string
     * substitute
     * substring
     * time
     * today
     * trim
     * truncate
     * weekday
     * year
     * </pre>
     * <p>
     * audit-enabled, library and member are not supported.
     * <p>
     * All data is returned as an <code>BaseDataType</code>, so one must
     * determine what the real return type is before using the returned data.
     * Example:
     * <pre>
     * BaseDataType result = ExpressionEvaluator.evaluateExpr(expr, null, false);
     *
     * if (result instanceof integer)
     * {
     *    int myResult = ((integer) result).intValue();
     *    do something here...
     * }
     * </pre>
     */
    public class ExpressionEvaluator extends antlr.TreeParser       implements ExpressionEvaluatorTokenTypes
     {

       /** Logger. */
       private static final ConversionStatus LOG = ConversionStatus.get(ExpressionEvaluator.class);

       /** Debug mode enabled. */
       private boolean debug = false;

       /**
        * Stores definitions of user-defined functions/variables. May be
        * <code>null</code> if no user-defined features are in use.
        */
       private CallbackResolver callResolver;

       /**
        * Constructs an instance allowing the helper classes to be provided by
        * the caller.
        *
        * @param    resolve
        *           Dictionary of <code>Callback</code> definitions for user-
        *           defined functions or variables.
        */
       public ExpressionEvaluator(CallbackResolver resolve)
       {
          this();
          callResolver = resolve;
       }

       /**
        * Returns the status of debug mode.
        *
        * @return    Debug mode enabled/disabled.
        */
       public boolean isDebug()
       {
          return debug;
       }

       /**
        * Sets the status of debug mode.
        *
        * @param    dbg
        *           <code>true</code> to enable debug mode, <code>false</code>
        *           to disable.
        */
       public void setDebug(boolean dbg)
       {
          debug = dbg;
       }

       /**
        * Provides a command line interface for an end user to drive and/or test
        * this class.
        * <p>
        * Syntax:
        * <pre>
        *   java.exe ExpressionEvaluator &quot;quoted_expression&quot; [debug]
        * </pre>
        * Where:
        * <ul>
        *   <li> &quot;quoted_expression&quot; is a valid Progress 4GL
        *        expression that is surrounded by double quotes. Note: if strings
        *        must be specified as part of the expression, specify those
        *        strings using the single quote character.
        * </ul>
        *
        * @param   args
        *          List of command line arguments.
        */
       public static void main(String[] args)
       {
          boolean debug  = false;
          String  syntax = "Syntax: java.exe ExpressionEvaluator " +
                           "<quoted_expression> [debug]";

          if (args.length < 1)
          {
             LOG.log(Level.SEVERE, syntax);
             System.exit(-1);
          }

          if (args.length == 2)
          {
             debug = true;
          }

          try
          {
             BaseDataType result = ExpressionEvaluator.evaluateExpr(args[0],
                                                                    null,
                                                                    debug);
             System.out.println("Result = " + result);
          }

          catch (Exception excpt)
          {
             LOG.log(Level.SEVERE, "", excpt);
          }
       }

       /**
        * Add the list of built-in functions that are supported in the
        * preprocessor so that these functions can be used in preprocessor
        * expressions.
        *
        * @param    sym
        *           The parser's symbol resolver.
        * @param    cr
        *           The container managing all function callbacks and variable
        *           references.
        */
       public static void addStandardFunctions(SymbolResolver sym, CallbackResolver cr)
       {
          cr.addCallback(sym.lookupKeyword("absolute"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "abs");
          cr.addCallback(sym.lookupKeyword("asc"),
                         null,
                         "com.goldencode.p2j.util.character",
                         "asc");

          // audit-enabled not yet supported

          cr.addCallback(sym.lookupKeyword("date"),
                         null,
                         "com.goldencode.p2j.util.date",
                         ""); // empty string means this is a constructor
          cr.addCallback(sym.lookupKeyword("day"),
                         null,
                         "com.goldencode.p2j.util.date",
                         "day");

          // this will blindly return "PROGRESS" until we add schema support to the SR for use
          // here; the current SR passed in here has no schema support
          cr.addCallback(sym.lookupKeyword("dbtype"),
                         sym,
                         "com.goldencode.p2j.uast.SymbolResolver",
                         "dbtype");

          cr.addCallback(sym.lookupKeyword("decimal"),
                         null,
                         "com.goldencode.p2j.util.decimal",
                         ""); // empty string means this is a constructor
          cr.addCallback(sym.lookupKeyword("encode"),
                         null,
                         "com.goldencode.p2j.util.SecurityOps",
                         "encode");
          cr.addCallback(sym.lookupKeyword("entry"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "entry");
          cr.addCallback(sym.lookupKeyword("etime"),
                         null,
                         "com.goldencode.p2j.util.date",
                         "elapsed");
          cr.addCallback(sym.lookupKeyword("exp"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "pow");
          cr.addCallback(sym.lookupKeyword("fill"),
                         null,
                         "com.goldencode.p2j.util.character",
                         "fill");
          cr.addCallback(sym.lookupKeyword("index"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "indexOf");
          cr.addCallback(sym.lookupKeyword("int64"),
                         null,
                         "com.goldencode.p2j.util.int64",
                         ""); // empty string means this is a constructor
          cr.addCallback(sym.lookupKeyword("integer"),
                         null,
                         "com.goldencode.p2j.util.integer",
                         ""); // empty string means this is a constructor
          cr.addCallback(sym.lookupKeyword("keyword"),
                         null,
                         "com.goldencode.p2j.uast.ProgressAst",
                         "keyword");
          cr.addCallback(sym.lookupKeyword("keyword-all"),
                         null,
                         "com.goldencode.p2j.uast.ProgressAst",
                         "keywordAll");
          cr.addCallback(sym.lookupKeyword("lc"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "toLowerCase");
          cr.addCallback(sym.lookupKeyword("left-trim"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "leftTrim");
          cr.addCallback(sym.lookupKeyword("length"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "length");

          // no support for library()

          cr.addCallback(sym.lookupKeyword("log"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "log");
          cr.addCallback(sym.lookupKeyword("logical"),
                         null,
                         "com.goldencode.p2j.util.logical",
                         ""); // empty string means this is a constructor
          cr.addCallback(sym.lookupKeyword("lookup"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "lookup");
          cr.addCallback(sym.lookupKeyword("maximum"),
                         null,
                         "com.goldencode.p2j.util.CompareOps",
                         "maximum");

          // no support for member()

          cr.addCallback(sym.lookupKeyword("minimum"),
                         null,
                         "com.goldencode.p2j.util.CompareOps",
                         "minimum");
          cr.addCallback(sym.lookupKeyword("month"),
                         null,
                         "com.goldencode.p2j.util.date",
                         "month");
          cr.addCallback(sym.lookupKeyword("num-entries"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "numEntries");
          cr.addCallback(sym.lookupKeyword("opsys"),
                         null,
                         "com.goldencode.p2j.util.EnvironmentOps",
                         "getOperatingSystem");
          cr.addCallback(sym.lookupKeyword("propath"),
                         null,
                         "com.goldencode.p2j.util.EnvironmentOps",
                         "getSearchPath");
          cr.addCallback(sym.lookupKeyword("proversion"),
                         null,
                         "com.goldencode.p2j.util.EnvironmentOps",
                         "getVersion");
          cr.addCallback(sym.lookupKeyword("random"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "random");
          cr.addCallback(sym.lookupKeyword("replace"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "replaceAll");
          cr.addCallback(sym.lookupKeyword("right-trim"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "rightTrim");
          cr.addCallback(sym.lookupKeyword("r-index"),
                         null,
                         "com.goldencode.p2j.util.character",
                         "lastIndexOf");
          cr.addCallback(sym.lookupKeyword("round"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "round");
          cr.addCallback(sym.lookupKeyword("sqrt"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "sqrt");
          cr.addCallback(sym.lookupKeyword("string"),
                         null,
                         "com.goldencode.p2j.util.character",
                         "valueOf");
          cr.addCallback(sym.lookupKeyword("substitute"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "substitute");
          cr.addCallback(sym.lookupKeyword("substring"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "substring");
          cr.addCallback(sym.lookupKeyword("time"),
                         null,
                         "com.goldencode.p2j.util.date",
                         "secondsSinceMidnight");
          cr.addCallback(sym.lookupKeyword("today"),
                         null,
                         "com.goldencode.p2j.util.date",
                         ""); // empty string means this is a constructor
          cr.addCallback(sym.lookupKeyword("trim"),
                         null,
                         "com.goldencode.p2j.util.TextOps",
                         "trim");
          cr.addCallback(sym.lookupKeyword("truncate"),
                         null,
                         "com.goldencode.p2j.util.MathOps",
                         "truncate");
          cr.addCallback(sym.lookupKeyword("weekday"),
                         null,
                         "com.goldencode.p2j.util.date",
                         "weekday");
          cr.addCallback(sym.lookupKeyword("year"),
                         null,
                         "com.goldencode.p2j.util.date",
                         "year");
       }

       /**
        * External entry point to evaluates a Progress 4GL expression as
        * expressed in a string of source code.
        * <p>
        * Optionally user-defined functions and variables can be provided via
        * a <code>CallbackResolver</code> object.
        * <p>
        * All data is returned as a <code>BaseDataType</code>, so one must
        * determine what the real return type is before using the returned data.
        * Example:
        * <pre>
        * BaseDataType result = ExpressionEvaluator.evaluateExpr(expr, null, false);
        *
        * if (result instanceof integer)
        * {
        *    int myResult = ((integer) result).intValue();
        *    do something here...
        * }
        * </pre>
        *
        * @param    exp
        *           Progress 4GL expression to evaluate.
        * @param    cr
        *           Instance of <code>CallbackResolver</code> configured with
        *           <code>Callback</code> objects representing the functions
        *           and variables to resolve.  If set to <code>null</code> then
        *           no user-defined callbacks will be defined.
        * @param    debug
        *           If true, the expression evaluator will output debugging
        *           information to <code>stdout</code>.  Otherwise no output
        *           is generated.
        *
        * @return   The result of the expression validation or <code>null</code>
        *           on error.
        */
       public static BaseDataType evaluateExpr(String exp, CallbackResolver cr, boolean debug)
       {
          BaseDataType result = null;

          try
          {
             // initial setup (warning, schema dictionary support is disabled
             // but basic lvalue processing in the parser should still be safe
             // since the symbol resolver handles this case)
             SymbolResolver  sym    = new SymbolResolver(false, true, null, true, false, null);
             StringReader    expr   = new StringReader("(" + exp + ")");
             ProgressLexer   lexer  = new ProgressLexer(expr, sym);
             ProgressParser  parser = new ProgressParser(lexer, sym);
             parser.setEvaluatingExpression(true);

             // if one is not provided, we must create one to hold our built-in
             // functions
             if (cr == null)
             {
                cr = new CallbackResolver();
             }

             // populate the CR with the standard built-in functions
             // (this MUST be done after the lexer is initialized above otherwise
             // any conflicts will be blown away)
             addStandardFunctions(sym, cr);

             // populate SymbolResolver with all Keywords in the CallbackResolver
             cr.populateSymbolResolver(sym);

             // parse it and create a tree
             parser.expr();
             CommonAST parseTree = (CommonAST) parser.getAST();

             // evaluate the tree
             ExpressionEvaluator expression = new ExpressionEvaluator(cr);
             expression.setDebug(debug);

             result = expression.evaluate(parseTree);
          }

          catch (Exception excpt)
          {
             if (debug)
             {
                LOG.log(Level.FINE, "", excpt);
             }
          }

          return result;
       }

       /**
        * This is the worker function that indirectly calls (through reflection)
        * the method that matches the text in the <code>AST</code>.  This
        * function manually processes a subtree starting at the function's
        * node.  All children are manually walked and the each child is
        * evaluated to obtain the result.  As the depth of the subtree for
        * each child is arbitrary (each parameter can be a valid Progress 4GL
        * expression of arbitrary complexity), the <code>{@link #evaluate}</code>
        * function is used to recursively process these expressions until the
        * result is returned as an <code>Object</code>.  This is assigned to
        * the function call's array of arguments.  In addition, each of these
        * arguments is queried for its' class and this class is stored in an
        * array that represents the signature of the method.  Once all arguments
        * and the signature are collected, the <code>CallbackResolver</code> is
        * used to invoke the callback that matches the function's text.
        * <p>
        * On the receiving end, each parameter is unpacked into its' primitive
        * form if available.  The method executes and returns as it normally
        * would.  Reflection handles returning the result.  Note that the result
        * must be some form of <code>BaseDataType</code>.
        * <p>
        * Note that there are a large number of potential failures in the
        * reflection lookup and execution process.  This method passes these
        * exceptions through.
        * <p>
        * At this time the <code>returnType</code> is not used but it may be
        * used by the <code>lookupCallback</code> in the future. This is here
        * since the Java reflection interfaces are expected to change to require
        * this.
        *
        * @see      #evaluate(AST)
        * @see      CallbackResolver#lookupCallback
        *
        * @param    function
        *           Node representing the function to be executed.
        * @param    returnType
        *           Return data type represented as a class.
        *
        * @return   Return data from the method call.
        */
       private BaseDataType executeCallback(AST function, Class returnType)
       throws UnsupportedOperationException,
              RecognitionException,
              NullPointerException,
              ReflectiveOperationException
       {
          return executeCallback(function, returnType, false, 0);
       }

       /**
        * This is the worker function that indirectly calls (through reflection)
        * the method that matches the text in the <code>AST</code>.  This
        * function manually processes a subtree starting at the function's
        * node.  All children are manually walked and the each child is
        * evaluated to obtain the result.  As the depth of the subtree for
        * each child is arbitrary (each parameter can be a valid Progress 4GL
        * expression of arbitrary complexity), the <code>{@link #evaluate}</code>
        * function is used to recursively process these expressions until the
        * result is returned as an <code>Object</code>.  This is assigned to
        * the function call's array of arguments.  In addition, each of these
        * arguments is queried for its' class and this class is stored in an
        * array that represents the signature of the method.  Once all arguments
        * and the signature are collected, the <code>CallbackResolver</code> is
        * used to invoke the callback that matches the function's text.
        * <p>
        * On the receiving end, each parameter is unpacked into its' primitive
        * form if available.  The method executes and returns as it normally
        * would.  Reflection handles returning the result.  Note that the result
        * must be some form of <code>BaseDataType</code>.
        * <p>
        * Note that there are a large number of potential failures in the
        * reflection lookup and execution process.  This method passes these
        * exceptions through.
        * <p>
        * At this time the <code>returnType</code> is not used but it may be
        * used by the <code>lookupCallback</code> in the future. This is here
        * since the Java reflection interfaces are expected to change to require
        * this.
        *
        * @see      #evaluate(AST)
        * @see      CallbackResolver#lookupCallback
        *
        * @param    function
        *           Node representing the function to be executed.
        * @param    returnType
        *           Return data type represented as a class.
        * @param    varargs
        *           <code>true</code> to shift the parameters into an array
        *           form that can be used with method signatures that handle
        *           variable arguments by passing a last parameter as an array
        *           of objects.
        * @param    argIdx
        *           The parameter number (0-based, counting from the "left") with
        *           which to start the variable portion of the arguments (only
        *           used if <code>varargs</code> is <code>true</code>).
        *
        * @return   Return data from the method call.
        */
       private BaseDataType executeCallback(AST     function,
                                            Class   returnType,
                                            boolean varargs,
                                            int     argIdx)
       throws UnsupportedOperationException,
              RecognitionException,
              NullPointerException,
              ReflectiveOperationException
       {
          int      num       = function.getNumberOfChildren();
          Object[] args      = new Object[num];
          Class[]  signature = new Class[num];
          AST      child     = function.getFirstChild();
          boolean  undef     = false;

          // build up the function call parameters by evaluating each child
          // in order
          for (int i = 0; i < num; i++)
          {
             args[i] = evaluate(child);

             if (args[i] == null)
                undef = true;
             else
                signature[i] = args[i].getClass();

             child = child.getNextSibling();
          }

          if (undef)
          {
             signature = new Class[0];
             args      = new Object[0];
          }

          if (varargs)
          {
             int vsz = args.length - argIdx;

             Object[]       bcopy = new Object[argIdx + 1];
             Class[]        scopy = new Class[argIdx + 1];
             BaseDataType[] vcopy = new BaseDataType[vsz];

             for (int j = 0; j < args.length; j++)
             {
                if (j < argIdx)
                {
                   // the base copy and signature copy will always have the same
                   // 0-based indexes as args and signature so j is already
                   // correct
                   bcopy[j] = args[j];
                   scopy[j] = signature[j];
                }
                else
                {
                   // the varargs copy may have an offset index position (if
                   // argIdx > 0)
                   vcopy[j - argIdx] = (BaseDataType) args[j];
                }
             }

             // the args have been split (if needed) and now we need to ensure
             // that the variable portion is the last element (if argIdx == 0
             // then this is the only element)
             bcopy[argIdx] = vcopy;

             // switch our arguments to the modified version
             args = bcopy;

             // ensure the last (or only if argIdx == 0) element of the signature
             // represents the var args (an array of BDT values)
             scopy[argIdx] = (new BaseDataType[0]).getClass();

             // switch our signature to the modified version
             signature = scopy;
          }

          Object res = callResolver.invokeCallback(function.getText(),
                                                   returnType,
                                                   signature,
                                                   args);

          if (!(res instanceof BaseDataType))
          {
             // try some simple conversions
             if (res instanceof Integer)
             {
                res = new integer((Integer) res);
             }
             else if (res instanceof Double)
             {
                res = new decimal((Double) res);
             }
             else if (res instanceof Boolean)
             {
                res = new logical((Boolean) res);
             }
             else if (res instanceof String)
             {
                res = new character((String) res);
             }
             else
             {
                throw new ClassCastException("Can't convert " +
                                             res.getClass().getName() +
                                             "to BaseDataType!");
             }
          }

          return (BaseDataType) res;
       }
    public ExpressionEvaluator() {
    	tokenNames = _tokenNames;
    }

    /**
     * Core method that does the following:
     * <ul>
     *   <li> ensures that all alternatives recursively call this same method
     *        for all child nodes
     *   <li> forces the return type to <code>BaseDataType</code> and where
     *        necessary wraps and/or casts the data into the proper non-primitive
     *        objects for a proper return
     *   <li> specifies all possible alternatives and for each one, the proper
     *        processing is either executed inline or is accessed in another
     *        method or class
     * </ul>
     *
     * @param    _t
     *           The tree node to be recursively evaluated.
     *
     * @return   The result of the evaluation of the subtree rooted at the node
     *           passed as a parameter.  This result is wrapped (if necessary) in
     *           a <code>BaseDataType</code> before returning.
     */
    	public final BaseDataType  evaluate(AST _t) throws RecognitionException, RecognitionException,UnsupportedOperationException,NullPointerException,ReflectiveOperationException {
    		BaseDataType r;

    		AST evaluate_AST_in = (_t == ASTNULL) ? null : (AST)_t;
    		AST n = null;
    		AST hx = null;
    		AST d = null;
    		AST da = null;
    		AST s = null;
    		AST fp = null;
    		AST fi = null;
    		AST vi = null;
    		AST fd = null;
    		AST vd = null;
    		AST fb = null;
    		AST vb = null;
    		AST fda = null;
    		AST vda = null;
    		AST fdt = null;
    		AST vdt = null;
    		AST fdz = null;
    		AST vdz = null;
    		AST fc = null;
    		AST vc = null;

    		int num = _t.getNumberOfChildren();

    		// operator processing needs its operands, do this in 1 place
    		final AST a = num > 0 ? _t.getFirstChild() : null;
    		final AST b = num > 1 ? a.getNextSibling() : null;

    		BaseDataType op1     = null;
    		BaseDataType op2     = null;
    		boolean      varargs = false;
    		int          ot      = 0;
    		int          aindx   = 0;

    		r = null;

    		if (isDebug() && _t != null)
    		System.out.println(_tokenNames[_t.getType()]);

    		try {      // for error handling
    			if (_t==null) _t=ASTNULL;
    			switch ( _t.getType()) {
    			case KW_OR:
    			{
    				AST tmp1_AST_in = (AST)_t;
    				match(_t,KW_OR);
    				_t = _t.getNextSibling();

    				LogicalOp lo = new LogicalOp()
    				{
    				public logical evaluate()
    				{
    				logical l = null;

    				try
    				{
    				l = (logical) ExpressionEvaluator.this.evaluate(b);
    				}

    				catch (Exception e)
    				{
    				LOG.log(Level.SEVERE, "", e);
    				}

    				return l;
    				}
    				};
    				r = logical.or((logical) evaluate(a), lo);

    				break;
    			}
    			case KW_AND:
    			{
    				AST tmp2_AST_in = (AST)_t;
    				match(_t,KW_AND);
    				_t = _t.getNextSibling();

    				LogicalOp lo = new LogicalOp()
    				{
    				public logical evaluate()
    				{
    				logical l = null;

    				try
    				{
    				l = (logical) ExpressionEvaluator.this.evaluate(b);
    				}

    				catch (Exception e)
    				{
    				LOG.log(Level.SEVERE, "", e);
    				}

    				return l;
    				}
    				};
    				r = logical.and((logical) evaluate(a), lo);

    				break;
    			}
    			case KW_NOT:
    			{
    				AST tmp3_AST_in = (AST)_t;
    				match(_t,KW_NOT);
    				_t = _t.getNextSibling();
    				r = logical.not((logical) evaluate(a));
    				break;
    			}
    			case EQUALS:
    			{
    				AST tmp4_AST_in = (AST)_t;
    				match(_t,EQUALS);
    				_t = _t.getNextSibling();
    				r = CompareOps.isEqual(evaluate(a), evaluate(b));
    				break;
    			}
    			case NOT_EQ:
    			{
    				AST tmp5_AST_in = (AST)_t;
    				match(_t,NOT_EQ);
    				_t = _t.getNextSibling();
    				r = CompareOps.isNotEqual(evaluate(a), evaluate(b));
    				break;
    			}
    			case GT:
    			{
    				AST tmp6_AST_in = (AST)_t;
    				match(_t,GT);
    				_t = _t.getNextSibling();
    				r = CompareOps.isGreaterThan(evaluate(a), evaluate(b));
    				break;
    			}
    			case LT:
    			{
    				AST tmp7_AST_in = (AST)_t;
    				match(_t,LT);
    				_t = _t.getNextSibling();
    				r = CompareOps.isLessThan(evaluate(a), evaluate(b));
    				break;
    			}
    			case GTE:
    			{
    				AST tmp8_AST_in = (AST)_t;
    				match(_t,GTE);
    				_t = _t.getNextSibling();

    				r = CompareOps.isGreaterThanOrEqual(evaluate(a), evaluate(b));

    				break;
    			}
    			case LTE:
    			{
    				AST tmp9_AST_in = (AST)_t;
    				match(_t,LTE);
    				_t = _t.getNextSibling();

    				r = CompareOps.isLessThanOrEqual(evaluate(a), evaluate(b));

    				break;
    			}
    			case KW_BEGINS:
    			{
    				AST tmp10_AST_in = (AST)_t;
    				match(_t,KW_BEGINS);
    				_t = _t.getNextSibling();

    				r = TextOps.begins((Text) evaluate(a), (character) evaluate(b));

    				break;
    			}
    			case KW_MATCHES:
    			{
    				AST tmp11_AST_in = (AST)_t;
    				match(_t,KW_MATCHES);
    				_t = _t.getNextSibling();

    				boolean windows = !Configuration.getParameter("unix-escapes", true);
    				r = TextOps.matches((Text) evaluate(a), (character) evaluate(b), windows);

    				break;
    			}
    			case PLUS:
    			{
    				AST tmp12_AST_in = (AST)_t;
    				match(_t,PLUS);
    				_t = _t.getNextSibling();

    				op1 = evaluate(a);
    				op2 = evaluate(b);

    				if (op1 instanceof NumberType)
    				{
    				r = MathOps.plus((NumberType) op1, (NumberType) op2);
    				}
    				else if (op1 instanceof character)
    				{
    				r = TextOps.concat((Text) op1, (Text) op2);
    				}
    				else
    				{
    				// assume this is a date + number
    				if (op2 instanceof integer)
    				{
    				r = date.plusDays((date) op1, (integer) op2);
    				}
    				else
    				{
    				r = date.plusDays((date) op1, (decimal) op2);
    				}
    				}

    				break;
    			}
    			case MINUS:
    			{
    				AST tmp13_AST_in = (AST)_t;
    				match(_t,MINUS);
    				_t = _t.getNextSibling();

    				op1 = evaluate(a);
    				op2 = evaluate(b);

    				if (op1 instanceof NumberType)
    				{
    				r = MathOps.minus((NumberType) op1, (NumberType) op2);
    				}
    				else
    				{
    				// assume this is a date - number
    				if (op2 instanceof integer)
    				{
    				r = date.minusDays((date) op1, (integer) op2);
    				}
    				else
    				{
    				r = date.minusDays((date) op1, (decimal) op2);
    				}
    				}

    				break;
    			}
    			case MULTIPLY:
    			{
    				AST tmp14_AST_in = (AST)_t;
    				match(_t,MULTIPLY);
    				_t = _t.getNextSibling();

    				r = MathOps.multiply((NumberType) evaluate(a),
    				(NumberType) evaluate(b));

    				break;
    			}
    			case DIVIDE:
    			{
    				AST tmp15_AST_in = (AST)_t;
    				match(_t,DIVIDE);
    				_t = _t.getNextSibling();

    				r = MathOps.divide((NumberType) evaluate(a),
    				(NumberType) evaluate(b));

    				break;
    			}
    			case KW_MOD:
    			{
    				AST tmp16_AST_in = (AST)_t;
    				match(_t,KW_MOD);
    				_t = _t.getNextSibling();

    				r = MathOps.modulo((NumberType) evaluate(a),
    				(NumberType) evaluate(b));

    				break;
    			}
    			case UN_MINUS:
    			{
    				AST tmp17_AST_in = (AST)_t;
    				match(_t,UN_MINUS);
    				_t = _t.getNextSibling();

    				op1 = evaluate(a);

    				if (op1 instanceof integer)
    				{
    				r = MathOps.negate((integer) op1);
    				}
    				else
    				{
    				r = MathOps.negate((decimal) op1);
    				}

    				break;
    			}
    			case UN_PLUS:
    			{
    				AST tmp18_AST_in = (AST)_t;
    				match(_t,UN_PLUS);
    				_t = _t.getNextSibling();
    				r = evaluate(a);
    				break;
    			}
    			case LPARENS:
    			{
    				AST tmp19_AST_in = (AST)_t;
    				match(_t,LPARENS);
    				_t = _t.getNextSibling();
    				r = evaluate(a);
    				break;
    			}
    			case UNKNOWN_VAL:
    			{
    				AST tmp20_AST_in = (AST)_t;
    				match(_t,UNKNOWN_VAL);
    				_t = _t.getNextSibling();
    				r = new unknown();
    				break;
    			}
    			case NUM_LITERAL:
    			{
    				n = (AST)_t;
    				match(_t,NUM_LITERAL);
    				_t = _t.getNextSibling();
    				r = new integer(n.getText());
    				break;
    			}
    			case HEX_LITERAL:
    			{
    				hx = (AST)_t;
    				match(_t,HEX_LITERAL);
    				_t = _t.getNextSibling();
    				r = decimal.fromUnsignedHexLiteral(hx.getText());
    				break;
    			}
    			case DEC_LITERAL:
    			{
    				d = (AST)_t;
    				match(_t,DEC_LITERAL);
    				_t = _t.getNextSibling();
    				r = new decimal(d.getText());
    				break;
    			}
    			case BOOL_TRUE:
    			{
    				AST tmp21_AST_in = (AST)_t;
    				match(_t,BOOL_TRUE);
    				_t = _t.getNextSibling();
    				r = new logical(true);
    				break;
    			}
    			case BOOL_FALSE:
    			{
    				AST tmp22_AST_in = (AST)_t;
    				match(_t,BOOL_FALSE);
    				_t = _t.getNextSibling();
    				r = new logical(false);
    				break;
    			}
    			case DATE_LITERAL:
    			{
    				da = (AST)_t;
    				match(_t,DATE_LITERAL);
    				_t = _t.getNextSibling();
    				r = new date(da.getText());
    				break;
    			}
    			case STRING:
    			{
    				s = (AST)_t;
    				match(_t,STRING);
    				_t = _t.getNextSibling();

    				String str = character.progressToJavaString(s.getText());
    				str = StringHelper.processEscapes(str);
    				str = StringHelper.stripMatchedComments(str);
    				r = new character(str);

    				break;
    			}
    			case FUNC_POLY:
    			{
    				fp = (AST)_t;
    				match(_t,FUNC_POLY);
    				_t = _t.getNextSibling();

    				aindx   = 0;
    				varargs = false;
    				Aast poly = (Aast) fp;

    				if (poly.isAnnotation("oldtype"))
    				{
    				ot = ((Long) poly.getAnnotation("oldtype")).intValue();

    				if (ot == KW_MIN || ot == KW_MAX)
    				{
    				varargs = true;
    				}
    				}

    				r = executeCallback(fp, null, varargs, aindx);

    				break;
    			}
    			case FUNC_INT:
    			{
    				fi = (AST)_t;
    				match(_t,FUNC_INT);
    				_t = _t.getNextSibling();
    				r = executeCallback(fi, integer.class);
    				break;
    			}
    			case VAR_INT:
    			{
    				vi = (AST)_t;
    				match(_t,VAR_INT);
    				_t = _t.getNextSibling();
    				r = executeCallback(vi, integer.class);
    				break;
    			}
    			case FUNC_DEC:
    			{
    				fd = (AST)_t;
    				match(_t,FUNC_DEC);
    				_t = _t.getNextSibling();
    				r = executeCallback(fd, decimal.class);
    				break;
    			}
    			case VAR_DEC:
    			{
    				vd = (AST)_t;
    				match(_t,VAR_DEC);
    				_t = _t.getNextSibling();
    				r = executeCallback(vd, decimal.class);
    				break;
    			}
    			case FUNC_LOGICAL:
    			{
    				fb = (AST)_t;
    				match(_t,FUNC_LOGICAL);
    				_t = _t.getNextSibling();
    				r = executeCallback(fb, logical.class);
    				break;
    			}
    			case VAR_LOGICAL:
    			{
    				vb = (AST)_t;
    				match(_t,VAR_LOGICAL);
    				_t = _t.getNextSibling();
    				r = executeCallback(vb, logical.class);
    				break;
    			}
    			case FUNC_DATE:
    			{
    				fda = (AST)_t;
    				match(_t,FUNC_DATE);
    				_t = _t.getNextSibling();
    				r = executeCallback(fda, date.class);
    				break;
    			}
    			case VAR_DATE:
    			{
    				vda = (AST)_t;
    				match(_t,VAR_DATE);
    				_t = _t.getNextSibling();
    				r = executeCallback(vda, date.class);
    				break;
    			}
    			case FUNC_DATETIME:
    			{
    				fdt = (AST)_t;
    				match(_t,FUNC_DATETIME);
    				_t = _t.getNextSibling();
    				r = executeCallback(fdt, datetime.class);
    				break;
    			}
    			case VAR_DATETIME:
    			{
    				vdt = (AST)_t;
    				match(_t,VAR_DATETIME);
    				_t = _t.getNextSibling();
    				r = executeCallback(vdt, datetime.class);
    				break;
    			}
    			case FUNC_DATETIME_TZ:
    			{
    				fdz = (AST)_t;
    				match(_t,FUNC_DATETIME_TZ);
    				_t = _t.getNextSibling();
    				r = executeCallback(fdz, datetimetz.class);
    				break;
    			}
    			case VAR_DATETIME_TZ:
    			{
    				vdz = (AST)_t;
    				match(_t,VAR_DATETIME_TZ);
    				_t = _t.getNextSibling();
    				r = executeCallback(vdz, datetimetz.class);
    				break;
    			}
    			case FUNC_CHAR:
    			{
    				fc = (AST)_t;
    				match(_t,FUNC_CHAR);
    				_t = _t.getNextSibling();

    				aindx   = 0;
    				varargs = false;
    				Aast fchar = (Aast) fc;

    				if (fchar.isAnnotation("oldtype"))
    				{
    				ot = ((Long) fchar.getAnnotation("oldtype")).intValue();

    				if (ot == KW_SUBSTIT)
    				{
    				aindx   = 1;
    				varargs = true;
    				}
    				}

    				r = executeCallback(fc, character.class, varargs, aindx);

    				break;
    			}
    			case VAR_CHAR:
    			{
    				vc = (AST)_t;
    				match(_t,VAR_CHAR);
    				_t = _t.getNextSibling();
    				r = executeCallback(vc, character.class);
    				break;
    			}
    			case SYMBOL:
    			{
    				AST tmp23_AST_in = (AST)_t;
    				match(_t,SYMBOL);
    				_t = _t.getNextSibling();
    				break;
    			}
    			case DB_SYMBOL:
    			{
    				AST tmp24_AST_in = (AST)_t;
    				match(_t,DB_SYMBOL);
    				_t = _t.getNextSibling();
    				break;
    			}
    			case FILENAME:
    			{
    				AST tmp25_AST_in = (AST)_t;
    				match(_t,FILENAME);
    				_t = _t.getNextSibling();
    				break;
    			}
    			default:
    			{
    				throw new NoViableAltException(_t);
    			}
    			}
    		}
    		catch (RecognitionException ex) {
    			reportError(ex);
    			if (_t!=null) {_t = _t.getNextSibling();}
    		}
    		_retTree = _t;
    		return r;
    	}

    	public static final String[] _tokenNames = {
    		"<0>",
    		"EOF",
    		"<2>",
    		"NULL_TREE_LOOKAHEAD",
    		"DOT",
    		"FILEROOT",
    		"DB_SYMBOL",
    		"ANY_LOCK",
    		"FILENAME",
    		"BACKSLASH",
    		"LIBRARY_REF",
    		"BEGIN_RECORDTYPES",
    		"TABLE",
    		"BUFFER",
    		"TEMP_TABLE",
    		"WORK_TABLE",
    		"END_RECORDTYPES",
    		"BEGIN_BUFFERTYPES",
    		"NO_REFERENCE",
    		"WEAK_REFERENCE",
    		"STRONG_REFERENCE",
    		"FREE_REFERENCE",
    		"END_BUFFERTYPES",
    		"EXPANDED_SCOPE",
    		"BUFFER_SCOPE",
    		"BEGIN_SCHEMA",
    		"ABBREVIATED",
    		"AREA",
    		"CATEGORY",
    		"CYCLE_ON_LIMIT",
    		"DESCRIPTION",
    		"DUMP_NAME",
    		"FROZEN",
    		"HIDDEN",
    		"INCREMENT",
    		"MANDATORY",
    		"ORDER",
    		"POSITION",
    		"SQL_WIDTH",
    		"TRAILER",
    		"VALEXP",
    		"VALMSG",
    		"VALMG_SA",
    		"BEGIN_SCHEMAKW",
    		"KW_ABBV",
    		"KW_AREA",
    		"KW_BIGINT",
    		"KW_BUFRPOOL",
    		"KW_BUFPOOL",
    		"KW_CATEGORY",
    		"KW_CLOB_CP",
    		"KW_CLOB_COL",
    		"KW_CLOB_TYP",
    		"KW_COL_L_SA",
    		"KW_CRC",
    		"KW_CYCLE",
    		"KW_DMP_NAME",
    		"KW_FLD_TRG",
    		"KW_FIXCHAR",
    		"KW_FMT_SA",
    		"KW_FROZEN",
    		"KW_HELP_SA",
    		"KW_IDX_FLD",
    		"KW_INACTIVE",
    		"KW_INCR",
    		"KW_INIT_SA",
    		"KW_LABEL_SA",
    		"KW_LOB_AREA",
    		"KW_LOB_BYTE",
    		"KW_LOB_SIZE",
    		"KW_MULTI_TN",
    		"KW_NO_DEFAR",
    		"KW_NO_OVRRD",
    		"KW_NOT_CS",
    		"KW_NULLALWD",
    		"KW_PSC",
    		"KW_SEQUENCE",
    		"KW_SQL_WID",
    		"KW_TAB_TRG",
    		"KW_TIMESTMP",
    		"KW_VALEXP",
    		"KW_VALMSG",
    		"KW_VALMG_SA",
    		"END_SCHEMAKW",
    		"BEGIN_METATYPES",
    		"FIELD_BIGINT",
    		"FIELD_BYTE",
    		"FIELD_DOUBLE",
    		"FIELD_FIXCHAR",
    		"FIELD_FLOAT",
    		"FIELD_SHORT",
    		"FIELD_TIMESTAMP",
    		"FIELD_TIME",
    		"END_METATYPES",
    		"END_SCHEMA",
    		"DATABASE",
    		"INDEX",
    		"INDEX_FIELD",
    		"BEGIN_INDEX_MATCH_TYPES",
    		"NO_MATCH",
    		"SELF_REFERENCE",
    		"EQUALITY_MATCH",
    		"BEGINS_MATCH",
    		"RANGE_MATCH",
    		"WORD_MATCH",
    		"SORT_MATCH",
    		"END_INDEX_MATCH_TYPES",
    		"SEQUENCE",
    		"PROPERTIES",
    		"MANY_TO_ONE",
    		"ONE_TO_MANY",
    		"ONE_TO_ONE",
    		"KEY_FIELD",
    		"RAW_STRING",
    		"QUERY",
    		"QUERY_SUBST",
    		"CLIENT_WHERE",
    		"CLIENT_WHERE_SUBST",
    		"EMBEDDED_SQL",
    		"COLUMN_LIST",
    		"BLOCK",
    		"PROCEDURE",
    		"CLASS_DEF",
    		"INTERFACE_DEF",
    		"ENUM_DEF",
    		"METHOD_DEF",
    		"CONSTRUCTOR",
    		"DESTRUCTOR",
    		"CLASS_NAME",
    		"ANNOTATION",
    		"OBJECT_INVOCATION",
    		"METHOD_INVOCATION",
    		"PROPERTY_INVOCATION",
    		"EVENT_SIGNATURE",
    		"DOTNET_DELEGATE",
    		"INT_PROC",
    		"WEB_PROC",
    		"FUNCTION",
    		"INNER_BLOCK",
    		"TRIGGER_BLOCK",
    		"EDITING_BLOCK",
    		"FRAME_SCOPE",
    		"FRAME_ALLOC",
    		"COPY_TO_SB",
    		"COPY_FROM_SB",
    		"CUSTOMER_SPECIFIC",
    		"VALIDATION",
    		"TRANSACTION",
    		"SUB_TRANSACTION",
    		"NO_TRANSACTION",
    		"STATEMENT",
    		"BROKEN_PREPROC_ARG",
    		"LABEL_DEF",
    		"LABEL",
    		"EXPRESSION",
    		"EVENT",
    		"DB_EVENT",
    		"CLASS_EVENT",
    		"EVENT_LIST",
    		"KEY_FUNCTION",
    		"WIDGET_LIST",
    		"WIDGET_POOL",
    		"ASSIGNMENT",
    		"ASSIGN",
    		"ARGUMENTS",
    		"PARAMETER",
    		"HANDLE_TO",
    		"COMMAND_TOKENS",
    		"COMMAND_TEXT",
    		"CONNECT_OPTIONS",
    		"CONNECT_TEXT",
    		"IO_OPTIONS",
    		"PUT_FIELD",
    		"IMPORT_FIELD",
    		"EXPORT_FIELD",
    		"AGGREGATE",
    		"FRAME_PHRASE",
    		"FORMAT_PHRASE",
    		"TRIGGER_PHRASE",
    		"RECORD_PHRASE",
    		"COLOR_PHRASE",
    		"INLINE_VAR_DEF_ARRAY",
    		"INLINE_VAR_DEF",
    		"CONTENT_ARRAY",
    		"FRAME_ELEMENT",
    		"WHEN_LIST",
    		"EMBEDDED_ASSIGNMENT",
    		"FORM_ITEM",
    		"COLUMN_REF",
    		"RUNTIME_FRAME_OPTIONS",
    		"RUNTIME_BROWSE_OPTIONS",
    		"PARENT_CHILD_RELATION",
    		"DATA_SET",
    		"DATA_SOURCE",
    		"DATA_RELATION",
    		"PARENT_ID_RELATION",
    		"LANGUAGES",
    		"DYNAMIC",
    		"MINUS",
    		"PLUS",
    		"UN_MINUS",
    		"UN_PLUS",
    		"BITWISE_OR",
    		"BITWISE_AND",
    		"BITWISE_NOT",
    		"BITWISE_XOR",
    		"BOOL_TRUE",
    		"BOOL_FALSE",
    		"DEC_LITERAL",
    		"DATE_LITERAL",
    		"DATETIME_LITERAL",
    		"DATETIME_TZ_LITERAL",
    		"HEX_LITERAL",
    		"UNQUOTED_TEXT",
    		"NO_LOCK_LITERAL",
    		"SHARE_LOCK_LITERAL",
    		"EXCLUSIVE_LOCK_LITERAL",
    		"NO_WAIT_LITERAL",
    		"READ_AVAILABLE_LITERAL",
    		"READ_EXACT_NUM_LITERAL",
    		"SEARCH_SELF_LITERAL",
    		"SEARCH_TARGET_LITERAL",
    		"PROC_CALL_TYPE_LITERAL",
    		"FUNC_CALL_TYPE_LITERAL",
    		"GET_ATTR_CTYPE_LITERAL",
    		"SET_ATTR_CTYPE_LITERAL",
    		"DLL_CALL_TYPE_LITERAL",
    		"OPTION",
    		"COM_METHOD",
    		"COM_PROPERTY",
    		"COM_PARAMETER",
    		"COM_INVOCATION",
    		"ENUM_VALUE",
    		"FILTER_SPEC",
    		"SUPPORT_LVL_NONE",
    		"SUPPORT_LVL_PARTIAL",
    		"SUPPORT_LVL_FULL_WITH_LIMITATIONS",
    		"SUPPORT_LVL_FULL",
    		"BOGUS",
    		"STATIC_WRAPPER",
    		"FRAME_LOCK",
    		"FRAME_UNLOCK",
    		"BEGIN_MULTIWORD",
    		"ALTER_TABLE",
    		"AS_BUTTON",
    		"CLOSE_QUERY",
    		"CLOSE_CURSOR",
    		"CLOSE_STORED_PROCEDURE",
    		"CREATE_ALIAS",
    		"CREATE_BROWSE",
    		"CREATE_BUFFER",
    		"CREATE_CALL",
    		"CREATE_CLIENT_PRINCIPAL",
    		"CREATE_OBJECT",
    		"CREATE_DATABASE",
    		"CREATE_DATASET",
    		"CREATE_DATA_SOURCE",
    		"CREATE_INDEX",
    		"CREATE_QUERY",
    		"CREATE_SAX_ATTRIBUTES",
    		"CREATE_SAX_READER",
    		"CREATE_SAX_WRITER",
    		"CREATE_SERVER",
    		"CREATE_SRV_SOCKET",
    		"CREATE_SOAP_HEADER",
    		"CREATE_SOAP_HEADER_ENTRYREF",
    		"CREATE_SOCKET",
    		"CREATE_TABLE",
    		"CREATE_TEMP_TABLE",
    		"CREATE_VIEW",
    		"CREATE_WIDGET",
    		"CREATE_WIDGET_POOL",
    		"CREATE_X_DOCUMENT",
    		"CREATE_X_NODEREF",
    		"DDE_ADVISE",
    		"DDE_EXECUTE",
    		"DDE_GET",
    		"DDE_INITIATE",
    		"DDE_REQUEST",
    		"DDE_SEND",
    		"DDE_TERMINATE",
    		"DECLARE_CURSOR",
    		"DEFINE_BROWSE",
    		"DEFINE_BUFFER",
    		"DEFINE_BUTTON",
    		"DEFINE_DATASET",
    		"DEFINE_DATA_SOURCE",
    		"DEFINE_ENUM",
    		"DEFINE_EVENT",
    		"DEFINE_FIELD",
    		"DEFINE_FRAME",
    		"DEFINE_IMAGE",
    		"DEFINE_MENU",
    		"DEFINE_PARAMETER",
    		"DEFINE_PROPERTY",
    		"DEFINE_QUERY",
    		"DEFINE_RECTANGLE",
    		"DEFINE_STREAM",
    		"DEFINE_SUB_MENU",
    		"DEFINE_TEMP_TABLE",
    		"DEFINE_VARIABLE",
    		"DEFINE_WORK_TABLE",
    		"DELETE_ALIAS",
    		"DELETE_FROM",
    		"DELETE_OBJECT",
    		"DELETE_PROCEDURE",
    		"DELETE_WIDGET",
    		"DELETE_WIDGET_POOL",
    		"DISABLE_TRIGGERS",
    		"DROP_INDEX",
    		"DROP_TABLE",
    		"DROP_VIEW",
    		"EMPTY_TEMP_TABLE",
    		"GROUP_BY",
    		"IN_WIDGET_POOL",
    		"INNER_JOIN",
    		"INPUT_CLEAR",
    		"INPUT_CLOSE",
    		"INPUT_FROM",
    		"INPUT_THRU",
    		"INPUT_OUTPUT_CLOSE",
    		"INPUT_OUTPUT_THRU",
    		"INSERT_INTO",
    		"IS_NULL",
    		"IS_NOT_NULL",
    		"LEFT_OUTER_JOIN",
    		"OPEN_CURSOR",
    		"OPEN_QUERY",
    		"ORDER_BY",
    		"OUTPUT_CLOSE",
    		"OUTPUT_THRU",
    		"OUTPUT_TO",
    		"NOT_BETWEEN",
    		"NOT_ENTERED",
    		"NOT_EXISTS",
    		"NOT_IN",
    		"NOT_LIKE",
    		"NOT_NULL",
    		"PROCESS_EVENTS",
    		"PUT_CURSOR",
    		"PUT_SCREEN",
    		"RELEASE_EXTERNAL",
    		"RELEASE_OBJECT",
    		"RIGHT_OUTER_JOIN",
    		"RUN_SUPER",
    		"RUN_STORED_PROCEDURE",
    		"SAVE_CACHE",
    		"SYSTEM_DIALOG_COLOR",
    		"SYSTEM_DIALOG_FONT",
    		"SYSTEM_DIALOG_GET_DIR",
    		"SYSTEM_DIALOG_GET_FILE",
    		"SYSTEM_DIALOG_PRINTER_SETUP",
    		"TRANSACTION_DISTINCT",
    		"TRIGGER_PROCEDURE",
    		"TRANSACTION_MODE_AUTO",
    		"UPDATE_SQL",
    		"WHERE_CURRENT_OF",
    		"WITH_CHECK_OPTION",
    		"WITH_GRANT_OPTION",
    		"DATA_SOURCE_QUERY",
    		"DATA_SOURCE_BUFFER",
    		"END_MULTIWORD",
    		"BEGIN_FUNCTYPES",
    		"FUNC_CHAR",
    		"FUNC_CLASS",
    		"FUNC_COM_HANDLE",
    		"FUNC_DATE",
    		"FUNC_DATETIME",
    		"FUNC_DATETIME_TZ",
    		"FUNC_DEC",
    		"FUNC_INT",
    		"FUNC_INT64",
    		"FUNC_LOGICAL",
    		"FUNC_LONGCHAR",
    		"FUNC_RECID",
    		"FUNC_ROWID",
    		"FUNC_HANDLE",
    		"FUNC_RAW",
    		"FUNC_MEMPTR",
    		"FUNC_POLY",
    		"FUNC_VOID",
    		"END_FUNCTYPES",
    		"BEGIN_LVALUE",
    		"BEGIN_VARTYPES",
    		"VAR_CHAR",
    		"VAR_CLASS",
    		"VAR_COM_HANDLE",
    		"VAR_DATE",
    		"VAR_DATETIME",
    		"VAR_DATETIME_TZ",
    		"VAR_DEC",
    		"VAR_HANDLE",
    		"VAR_INT",
    		"VAR_INT64",
    		"VAR_LOGICAL",
    		"VAR_LONGCHAR",
    		"VAR_MEMPTR",
    		"VAR_RAW",
    		"VAR_RECID",
    		"VAR_ROWID",
    		"SYS_HANDLE",
    		"VAR_POLY",
    		"BEGIN_NATIVE_VARTYPES",
    		"VAR_BYTE",
    		"VAR_DOUBLE",
    		"VAR_FLOAT",
    		"VAR_LONG",
    		"VAR_SHORT",
    		"VAR_ULONG",
    		"VAR_USHORT",
    		"END_NATIVE_VARTYPES",
    		"END_VARTYPES",
    		"BEGIN_FIELDTYPES",
    		"FIELD_BLOB",
    		"FIELD_CHAR",
    		"FIELD_CLASS",
    		"FIELD_CLOB",
    		"FIELD_COM_HANDLE",
    		"FIELD_DATE",
    		"FIELD_DATETIME",
    		"FIELD_DATETIME_TZ",
    		"FIELD_DEC",
    		"FIELD_INT",
    		"FIELD_INT64",
    		"FIELD_LOGICAL",
    		"FIELD_RECID",
    		"FIELD_ROWID",
    		"FIELD_HANDLE",
    		"FIELD_RAW",
    		"END_FIELDTYPES",
    		"BEGIN_WIDGETS",
    		"WID_BROWSE",
    		"WID_BROWSE_COL",
    		"WID_BUTTON",
    		"WID_COMBO",
    		"WID_DIALOG",
    		"WID_EDITOR",
    		"WID_FILL_IN",
    		"WID_FRAME",
    		"WID_IMAGE",
    		"WID_LITERAL",
    		"WID_MENU",
    		"WID_MENU_ITM",
    		"WID_RADIO",
    		"WID_RECT",
    		"WID_SEL_LST",
    		"WID_SLIDER",
    		"WID_SUB_MENU",
    		"WID_TEXT",
    		"WID_TOGGLE",
    		"WID_WINDOW",
    		"END_WIDGETS",
    		"STREAM",
    		"END_LVALUE",
    		"BEGIN_ATTR_METH",
    		"BEGIN_ATTR",
    		"ATTR_CHAR",
    		"ATTR_CLASS",
    		"ATTR_COM_HANDLE",
    		"ATTR_DATE",
    		"ATTR_DATETIME",
    		"ATTR_DATETIME_TZ",
    		"ATTR_DEC",
    		"ATTR_HANDLE",
    		"ATTR_INT",
    		"ATTR_INT64",
    		"ATTR_LOGICAL",
    		"ATTR_LONGCHAR",
    		"ATTR_MEMPTR",
    		"ATTR_RAW",
    		"ATTR_RECID",
    		"ATTR_ROWID",
    		"ATTR_POLY",
    		"END_ATTR",
    		"BEGIN_METH",
    		"METH_CHAR",
    		"METH_CLASS",
    		"METH_COM_HANDLE",
    		"METH_DATE",
    		"METH_DATETIME",
    		"METH_DATETIME_TZ",
    		"METH_DEC",
    		"METH_HANDLE",
    		"METH_INT",
    		"METH_INT64",
    		"METH_LOGICAL",
    		"METH_LONGCHAR",
    		"METH_MEMPTR",
    		"METH_POLY",
    		"METH_RAW",
    		"METH_RECID",
    		"METH_ROWID",
    		"METH_VOID",
    		"END_METH",
    		"END_ATTR_METH",
    		"BEGIN_OO_METH",
    		"OO_METH_CHAR",
    		"OO_METH_CLASS",
    		"OO_METH_COM_HANDLE",
    		"OO_METH_DATE",
    		"OO_METH_DATETIME",
    		"OO_METH_DATETIME_TZ",
    		"OO_METH_DEC",
    		"OO_METH_HANDLE",
    		"OO_METH_INT",
    		"OO_METH_INT64",
    		"OO_METH_LOGICAL",
    		"OO_METH_LONGCHAR",
    		"OO_METH_MEMPTR",
    		"OO_METH_RAW",
    		"OO_METH_RECID",
    		"OO_METH_ROWID",
    		"OO_METH_POLY",
    		"OO_METH_VOID",
    		"END_OO_METH",
    		"BEGIN_RESERVED",
    		"KW_U_CTRL",
    		"KW_U_MSG",
    		"KW_U_PCTRL",
    		"KW_U_SERIAL",
    		"KW_ACCUM",
    		"KW_ADD",
    		"KW_ASCEND",
    		"KW_ASC",
    		"KW_ACT_FORM",
    		"KW_ACT_WIN",
    		"KW_ALIAS",
    		"KW_ALL",
    		"KW_ALTER",
    		"KW_AMBIG",
    		"KW_ANALYZ",
    		"KW_AND",
    		"KW_ANY",
    		"KW_APPLY",
    		"KW_AS",
    		"KW_ASYNC",
    		"KW_ASSIGN",
    		"KW_AT",
    		"KW_ATTR",
    		"KW_AUD_CTRL",
    		"KW_AUD_POL",
    		"KW_AUTHORZN",
    		"KW_AUTO_RET",
    		"KW_AVAIL",
    		"KW_B_ENDIAN",
    		"KW_BACKGRND",
    		"KW_B4_HIDE",
    		"KW_BEGINS",
    		"KW_BELL",
    		"KW_BETWEEN",
    		"KW_BLANK",
    		"KW_BREAK",
    		"KW_BTOS",
    		"KW_BUF_COMP",
    		"KW_BUF_COPY",
    		"KW_BY",
    		"KW_CALL",
    		"KW_CAN_DO",
    		"KW_CAN_FIND",
    		"KW_CASE",
    		"KW_CASE_SEN",
    		"KW_CAST",
    		"KW_CENTER",
    		"KW_CHR",
    		"KW_CHECK",
    		"KW_CLEAR",
    		"KW_CLIP",
    		"KW_CODEBASE",
    		"KW_COL_LAB",
    		"KW_COLON",
    		"KW_COLOR",
    		"KW_COLUMNS",
    		"KW_COMPILER",
    		"KW_CONN_ED",
    		"KW_CONTROL",
    		"KW_COUNT_OF",
    		"KW_CPY_LOB",
    		"KW_CREATE",
    		"KW_CTOS",
    		"KW_CURRENT",
    		"KW_CUR_CHG",
    		"KW_CUR_LANG",
    		"KW_CUR_WIN",
    		"KW_CURSOR",
    		"KW_DATA_SRC",
    		"KW_DATABASE",
    		"KW_DATASRV",
    		"KW_DATASET",
    		"KW_DB_CTXT",
    		"KW_DB_REF",
    		"KW_DB_REM_H",
    		"KW_DBCP",
    		"KW_DBCOLL",
    		"KW_DBNAME",
    		"KW_DBPARAM",
    		"KW_DBREST",
    		"KW_DBTASKID",
    		"KW_DBTYPE",
    		"KW_DBVERS",
    		"KW_DDE",
    		"KW_DEBLANK",
    		"KW_DEBUGGER",
    		"KW_DBG_LST",
    		"KW_DECIMALS",
    		"KW_DECLARE",
    		"KW_DEFAULT",
    		"KW_DEF_NOXL",
    		"KW_DEF_WIN",
    		"KW_DEFINE",
    		"KW_DELETE",
    		"KW_DELIMIT",
    		"KW_DESCEND",
    		"KW_DICT",
    		"KW_DISABLE",
    		"KW_DIS_A_ZA",
    		"KW_DISCONN",
    		"KW_DISP",
    		"KW_DISTINCT",
    		"KW_DLL_C_T",
    		"KW_DO",
    		"KW_DOS",
    		"KW_DOWN",
    		"KW_DROP",
    		"KW_DSET_HND",
    		"KW_DSL_MGR",
    		"KW_DYN_ENUM",
    		"KW_DYN_FUNC",
    		"KW_DYN_INVK",
    		"KW_DYN_NEW",
    		"KW_DYN_PROP",
    		"KW_EACH",
    		"KW_EDITING",
    		"KW_ELSE",
    		"KW_ENABLE",
    		"KW_ENCODE",
    		"KW_END",
    		"KW_ENTRY",
    		"KW_ERR_STAT",
    		"KW_ESCAPE",
    		"KW_EVT_PROC",
    		"KW_EXC_LOCK",
    		"KW_EXISTS",
    		"KW_ETIME",
    		"KW_EXCEPT",
    		"KW_EXPORT",
    		"KW_FETCH",
    		"KW_FIELD",
    		"KW_FIL_INFO",
    		"KW_FILL",
    		"KW_FIND",
    		"KW_FIND_CS",
    		"KW_FIND_GLO",
    		"KW_FIND_NO",
    		"KW_FIND_PO",
    		"KW_FIND_SEL",
    		"KW_FIND_WA",
    		"KW_FIRST",
    		"KW_FIRST_OF",
    		"KW_FOCUS",
    		"KW_FONT",
    		"KW_FOR",
    		"KW_FORM",
    		"KW_FORMAT",
    		"KW_FRAME",
    		"KW_FR_COL",
    		"KW_FR_DB",
    		"KW_FR_DOWN",
    		"KW_FR_FIELD",
    		"KW_FR_FILE",
    		"KW_FR_INDEX",
    		"KW_FR_LINE",
    		"KW_FR_NAME",
    		"KW_FR_ROW",
    		"KW_FR_VAL",
    		"KW_FROM",
    		"KW_FROM_CHR",
    		"KW_FROM_PIX",
    		"KW_FUNC_C_T",
    		"KW_FWD_DRIV",
    		"KW_GW",
    		"KW_GET_A_CT",
    		"KW_GET_BUFH",
    		"KW_GET_BYTE",
    		"KW_GET_CODP",
    		"KW_GET_COLL",
    		"KW_GET_ERRC",
    		"KW_GET_ERRR",
    		"KW_GET_FNAM",
    		"KW_GET_FOFF",
    		"KW_GET_K_V",
    		"KW_GLOBAL",
    		"KW_GO_ON",
    		"KW_GO_PEND",
    		"KW_GRANT",
    		"KW_GRAPHIC",
    		"KW_GROUP",
    		"KW_HASHCODE",
    		"KW_HEADER",
    		"KW_HAVING",
    		"KW_HELP",
    		"KW_HIDE",
    		"KW_HOST_B_O",
    		"KW_IF",
    		"KW_IMPORT",
    		"KW_IN",
    		"KW_INDEX",
    		"KW_INDICAT",
    		"KW_INPUT",
    		"KW_IN_OUT",
    		"KW_INSERT",
    		"KW_INTO",
    		"KW_IS",
    		"KW_IS_ATTR",
    		"KW_IS_LEAD",
    		"KW_JOIN",
    		"KW_KBLABEL",
    		"KW_KEYCODE",
    		"KW_KEYFUNC",
    		"KW_KEYLAB",
    		"KW_KEYS",
    		"KW_KW",
    		"KW_L_ENDIAN",
    		"KW_LABEL",
    		"KW_LAST",
    		"KW_LASTKEY",
    		"KW_LAST_EVT",
    		"KW_LAST_OF",
    		"KW_LDBNAME",
    		"KW_LEAVE",
    		"KW_LIB",
    		"KW_LIKE",
    		"KW_LINE_CNT",
    		"KW_LISTING",
    		"KW_LOCKED",
    		"KW_LOG_MGR",
    		"KW_LOOKUP",
    		"KW_MACH_CLS",
    		"KW_MAP",
    		"KW_MEMBER",
    		"KW_MOUSE",
    		"KW_MPE",
    		"KW_MSG",
    		"KW_MSG_LINE",
    		"KW_NEW",
    		"KW_NEXT",
    		"KW_NEXT_PMT",
    		"KW_NO_ATTR",
    		"KW_NO_ATTRL",
    		"KW_NO_ERROR",
    		"KW_NO_FILL",
    		"KW_NO_FOCUS",
    		"KW_NO_HIDE",
    		"KW_NO_LABEL",
    		"KW_NO_LOBS",
    		"KW_NO_LOCK",
    		"KW_NO_MAP",
    		"KW_NO_MSG",
    		"KW_NO_PAUSE",
    		"KW_NO_PRE",
    		"KW_NO_RET_V",
    		"KW_NO_UNDO",
    		"KW_NO_VALID",
    		"KW_NO_WAIT",
    		"KW_NOT",
    		"KW_NOW",
    		"KW_NULL",
    		"KW_NUM_ALIA",
    		"KW_NUM_DBS",
    		"KW_NUM_ENT",
    		"KW_OF",
    		"KW_OFF",
    		"KW_OLD",
    		"KW_ON",
    		"KW_OPEN",
    		"KW_OR",
    		"KW_OUTPUT",
    		"KW_OPSYS",
    		"KW_OPTION",
    		"KW_OS2",
    		"KW_OS_APPND",
    		"KW_OS_COPY",
    		"KW_OS_CMD",
    		"KW_OS_MKDIR",
    		"KW_OS_DEL",
    		"KW_OS_DIR",
    		"KW_OS_REN",
    		"KW_OTHER",
    		"KW_OVERLAY",
    		"KW_PAGE",
    		"KW_PAGE_B",
    		"KW_PAGE_NUM",
    		"KW_PAGE_T",
    		"KW_PARM",
    		"KW_PASSWD_F",
    		"KW_PAUSE",
    		"KW_PDBNAME",
    		"KW_PERSIST",
    		"KW_PIXELS",
    		"KW_PREPROC",
    		"KW_PRIVILEG",
    		"KW_PROCESS",
    		"KW_PROC_C_T",
    		"KW_PROC_HND",
    		"KW_PROC_ST",
    		"KW_PROFILER",
    		"KW_PROGNAME",
    		"KW_PROGRESS",
    		"KW_PROMPT",
    		"KW_PRMT_FOR",
    		"KW_PROMSGS",
    		"KW_PROPATH",
    		"KW_PROVER",
    		"KW_PUBLISH",
    		"KW_PUT",
    		"KW_PUT_BYTE",
    		"KW_PUT_K_V",
    		"KW_QUERY",
    		"KW_QRY_CLOS",
    		"KW_QRY_OFF",
    		"KW_QRY_TUNE",
    		"KW_QUIT",
    		"KW_R_INDEX",
    		"KW_RCOD_INF",
    		"KW_READ_AVL",
    		"KW_READ_E_N",
    		"KW_READKEY",
    		"KW_RECID",
    		"KW_RECT",
    		"KW_RELEASE",
    		"KW_REPEAT",
    		"KW_REPL_CRE",
    		"KW_REPL_DEL",
    		"KW_REPL_WRI",
    		"KW_REPOS",
    		"KW_REPOS_B",
    		"KW_REPOS_F",
    		"KW_REPOS_2R",
    		"KW_REPOS_2I",
    		"KW_RETAIN",
    		"KW_RETRY",
    		"KW_RETURN",
    		"KW_REVERT",
    		"KW_REVOKE",
    		"KW_ROW_CRTD",
    		"KW_ROW_DELD",
    		"KW_ROW_MODD",
    		"KW_ROW_UMOD",
    		"KW_RTOPSYS",
    		"KW_RUN",
    		"KW_SAVE",
    		"KW_SAX_COMP",
    		"KW_SAX_PARE",
    		"KW_SAX_RUNN",
    		"KW_SAX_UNIN",
    		"KW_SAX_WBEG",
    		"KW_SAX_WCOM",
    		"KW_SAX_WCON",
    		"KW_SAX_WELM",
    		"KW_SAX_WERR",
    		"KW_SAX_WIDL",
    		"KW_SAX_WTAG",
    		"KW_SCHEMA",
    		"KW_SCREEN",
    		"KW_SCRN_IO",
    		"KW_SCRN_LNS",
    		"KW_SCROLL",
    		"KW_SDBNAME",
    		"KW_SEAR_SLF",
    		"KW_SEAR_TRG",
    		"KW_SEARCH",
    		"KW_SECUR_P",
    		"KW_SEEK",
    		"KW_SELECT",
    		"KW_SELF",
    		"KW_SESSION",
    		"KW_SET",
    		"KW_SET_A_CT",
    		"KW_SETUSER",
    		"KW_SH_LOCK",
    		"KW_SHARED",
    		"KW_SHOW_ST",
    		"KW_SING_RUN",
    		"KW_SKIP",
    		"KW_SKIP_D_R",
    		"KW_SOME",
    		"KW_SPACE",
    		"KW_STATUS",
    		"KW_STREAM",
    		"KW_STRM_HND",
    		"KW_STRM_IO",
    		"KW_SUBSCRIB",
    		"KW_SUPER",
    		"KW_SYS_DLG",
    		"KW_TABLE",
    		"KW_TAB_NUM",
    		"KW_TERM",
    		"KW_TEXT",
    		"KW_THEN",
    		"KW_THIS_OBJ",
    		"KW_THIS_PRC",
    		"KW_TIME",
    		"KW_TITLE",
    		"KW_TO",
    		"KW_TOP_ONLY",
    		"KW_TO_ROWID",
    		"KW_TRANS",
    		"KW_TRIGGER",
    		"KW_TRIGGERS",
    		"KW_TRIM",
    		"KW_TXT_CURS",
    		"KW_UNDO",
    		"KW_UNION",
    		"KW_UNIQUE",
    		"KW_UNIX",
    		"KW_UNDERLIN",
    		"KW_UNFORMAT",
    		"KW_UNSUBSCR",
    		"KW_UP",
    		"KW_UPDATE",
    		"KW_USE_IDX",
    		"KW_USERID",
    		"KW_USING",
    		"KW_V6FRAME",
    		"KW_VALUE",
    		"KW_VAL_CHG",
    		"KW_VALUES",
    		"KW_VIEW",
    		"KW_VIEW_AS",
    		"KW_VMS",
    		"KW_WAIT_FOR",
    		"KW_WHEN",
    		"KW_WHERE",
    		"KW_WHILE",
    		"KW_WINDOW",
    		"KW_WIN_DMIN",
    		"KW_WIN_MAX",
    		"KW_WIN_MIN",
    		"KW_WIN_NORM",
    		"KW_WITH",
    		"KW_WORK_TAB",
    		"KW_WRITE",
    		"KW_XCODE",
    		"KW_XOR",
    		"KW_XREF",
    		"KW_XREF_XML",
    		"END_RESERVED",
    		"BEGIN_UNRESERVED",
    		"KW_ABORT",
    		"KW_ABS",
    		"KW_ABSTRACT",
    		"KW_ACC_CHG",
    		"KW_ACC_RCHG",
    		"KW_ACCEL",
    		"KW_ACTIVE",
    		"KW_ACTOR",
    		"KW_ADD_BUF",
    		"KW_ADD_C_C",
    		"KW_ADD_C_F",
    		"KW_ADD_EVTP",
    		"KW_ADD_F_F",
    		"KW_ADD_1ST",
    		"KW_ADD_HENT",
    		"KW_ADD_INVL",
    		"KW_ADD_IDXF",
    		"KW_ADD_LAST",
    		"KW_ADD_L_C",
    		"KW_ADD_LIKF",
    		"KW_ADD_LIKI",
    		"KW_ADD_NEWF",
    		"KW_ADD_NEWI",
    		"KW_ADD_PREL",
    		"KW_ADD_REL",
    		"KW_ADD_SLOC",
    		"KW_ADD_SRCB",
    		"KW_ADD_SUP",
    		"KW_ADM_DATA",
    		"KW_ADM_TO",
    		"KW_ADVISE",
    		"KW_AFT_BUFF",
    		"KW_AFT_FILL",
    		"KW_AFT_R_F",
    		"KW_AFT_ROID",
    		"KW_AFT_TBL",
    		"KW_ALERT_BX",
    		"KW_ALIGN",
    		"KW_ALLW_C_S",
    		"KW_ALLW_REP",
    		"KW_ALT_KEY",
    		"KW_ALW_ON_T",
    		"KW_ANSI_ONL",
    		"KW_ANY_KEY",
    		"KW_ANY_PRT",
    		"KW_ANYWHERE",
    		"KW_APPEND",
    		"KW_APPEND_C",
    		"KW_APPEND_L",
    		"KW_APPL_A_B",
    		"KW_APPL",
    		"KW_APPL_CID",
    		"KW_APPL_CBK",
    		"KW_APP_INFO",
    		"KW_APP_PW",
    		"KW_APP_UID",
    		"KW_ARR_MSG",
    		"KW_ASCII_2H",
    		"KW_ASK_OVER",
    		"KW_ASSEMBLY",
    		"KW_ASYNC_RC",
    		"KW_ASYNC_RH",
    		"KW_ATT_DSRC",
    		"KW_ATT_PLST",
    		"KW_ATTR_NAM",
    		"KW_AUD_ENAB",
    		"KW_AUD_EV_C",
    		"KW_AUTHBLOB",
    		"KW_AUTHEN_F",
    		"KW_AUTO_COM",
    		"KW_AUTO_DEL",
    		"KW_AUTO_D_X",
    		"KW_AUTO_END",
    		"KW_AUTO_GO",
    		"KW_AUTO_IND",
    		"KW_AUTO_RES",
    		"KW_AUTO_SYN",
    		"KW_AUTO_VAL",
    		"KW_AUTO_ZAP",
    		"KW_AUTOMATC",
    		"KW_AVERAGE",
    		"KW_AVG",
    		"KW_AVL_FMTS",
    		"KW_AVL_MSGS",
    		"KW_BACKSP",
    		"KW_BACKWARD",
    		"KW_BACK_TAB",
    		"KW_BAS_LOGG",
    		"KW_BASE64_D",
    		"KW_BASE64_E",
    		"KW_BASE_ADE",
    		"KW_BASE_KEY",
    		"KW_BATCH_MO",
    		"KW_BATCH_SZ",
    		"KW_B4_BUFF",
    		"KW_B4_FILL",
    		"KW_B4_R_F",
    		"KW_B4_ROWID",
    		"KW_B4_TABLE",
    		"KW_BEG_EV_G",
    		"KW_BGCOLOR",
    		"KW_BGCOLRGB",
    		"KW_BINARY",
    		"KW_BIND",
    		"KW_BIND_WH",
    		"KW_BLOB",
    		"KW_BLOCK",
    		"KW_BLK_LVL",
    		"KW_BLK_IT_D",
    		"KW_BORD_B_C",
    		"KW_BORD_B_P",
    		"KW_BORD_L_C",
    		"KW_BORD_L_P",
    		"KW_BORD_R_C",
    		"KW_BORD_R_P",
    		"KW_BORD_T_C",
    		"KW_BORD_T_P",
    		"KW_BOTH",
    		"KW_BOTTOM",
    		"KW_BOTTOM_C",
    		"KW_BOX",
    		"KW_BOX_SEL",
    		"KW_BR_AGENT",
    		"KW_BR_IP",
    		"KW_BR_PORT",
    		"KW_BR_TZ",
    		"KW_BREAK_L",
    		"KW_BROWSE",
    		"KW_BUFFER",
    		"KW_BUFFER_C",
    		"KW_BUF_CREA",
    		"KW_BUF_DEL",
    		"KW_BUF_FLD",
    		"KW_BUF_GRPI",
    		"KW_BUF_GRPN",
    		"KW_BUF_HNDL",
    		"KW_BUF_NAME",
    		"KW_BUF_PARI",
    		"KW_BUFFER_L",
    		"KW_BUF_REL",
    		"KW_BUF_TENI",
    		"KW_BUF_TENN",
    		"KW_BUF_VLID",
    		"KW_BUF_VAL",
    		"KW_BUTTON",
    		"KW_BY_PTR",
    		"KW_BY_REF",
    		"KW_BY_VALUE",
    		"KW_BY_VAR_P",
    		"KW_BYTE",
    		"KW_BYTES_R",
    		"KW_BYTES_W",
    		"KW_CACHE",
    		"KW_CACHE_SZ",
    		"KW_CALL_NAM",
    		"KW_CALL_TYP",
    		"KW_CANC_BRK",
    		"KW_CANCEL_B",
    		"KW_CANCEL_P",
    		"KW_CANCEL_R",
    		"KW_CANCELLD",
    		"KW_CAN_CREA",
    		"KW_CAN_DEL",
    		"KW_CAN_DUMP",
    		"KW_CAN_LOAD",
    		"KW_CAN_QRY",
    		"KW_CAN_READ",
    		"KW_CAN_SET",
    		"KW_CAN_WRT",
    		"KW_CAPS",
    		"KW_CARE_PNT",
    		"KW_CBIT",
    		"KW_CATCH",
    		"KW_CDECL",
    		"KW_CFG_NAME",
    		"KW_CHAINED",
    		"KW_CHAR",
    		"KW_CHAR_LEN",
    		"KW_CHARSET",
    		"KW_CHART",
    		"KW_CHECKED",
    		"KW_CHECK_AM",
    		"KW_CHLD_BUF",
    		"KW_CHLD_NUM",
    		"KW_CHOICES",
    		"KW_CHOOSE",
    		"KW_CLASS",
    		"KW_CLN_IP",
    		"KW_CLN_PORT",
    		"KW_CLN_TZ",
    		"KW_CLN_TIME",
    		"KW_CLOB",
    		"KW_CLR_SEL",
    		"KW_CLR_AP_C",
    		"KW_CLR_LOG",
    		"KW_CLR_S_AR",
    		"KW_CLS_TYPE",
    		"KW_CLNT_C_I",
    		"KW_CLNT_DIS",
    		"KW_CLNT_PRL",
    		"KW_CLNT_TTY",
    		"KW_CLNT_TYP",
    		"KW_CLNT_WS",
    		"KW_CLONE_ND",
    		"KW_CLOSE",
    		"KW_CLOSE_AP",
    		"KW_CLOSE_LG",
    		"KW_CNCL_R_A",
    		"KW_CNTRL_BX",
    		"KW_CODE",
    		"KW_CP_CVT",
    		"KW_CP",
    		"KW_COLLATE",
    		"KW_COLON_AL",
    		"KW_COLR_TAB",
    		"KW_COL",
    		"KW_COL_BGC",
    		"KW_COL_CP",
    		"KW_COL_DC",
    		"KW_COL_FGC",
    		"KW_COL_FONT",
    		"KW_COL_MOV",
    		"KW_COL_PFC",
    		"KW_COL_OF",
    		"KW_COL_R_O",
    		"KW_COL_RES",
    		"KW_COL_SCR",
    		"KW_COM_HNDL",
    		"KW_COM_SELF",
    		"KW_COMBO_BX",
    		"KW_COMMAND",
    		"KW_COMPARE",
    		"KW_COMPARES",
    		"KW_COMPILE",
    		"KW_COMPLETE",
    		"KW_CONN",
    		"KW_CONSTRUC",
    		"KW_CTX",
    		"KW_CTX_H",
    		"KW_CTX_H_F",
    		"KW_CTX_H_ID",
    		"KW_CTX_POP",
    		"KW_CONTAINS",
    		"KW_CONTENTS",
    		"KW_CNTRL_FR",
    		"KW_CNTRL_NM",
    		"KW_CONTROLS",
    		"KW_CVT_DT",
    		"KW_CONVERT",
    		"KW_CVT_2OFF",
    		"KW_CVT_3D_C",
    		"KW_COOKIE_D",
    		"KW_COPY",
    		"KW_CPY_DSET",
    		"KW_CPY_SATR",
    		"KW_CPY_TTBL",
    		"KW_COUNT",
    		"KW_COVERAGE",
    		"KW_CPCASE",
    		"KW_CPCOLL",
    		"KW_CPINTERN",
    		"KW_CPLOG",
    		"KW_CPPRINT",
    		"KW_CPRCODEI",
    		"KW_CPRCODEO",
    		"KW_CPSTREAM",
    		"KW_CPTERM",
    		"KW_CRC_VAL",
    		"KW_CREAT_LK",
    		"KW_CR_LK_SQ",
    		"KW_CREAT_OA",
    		"KW_CREAT_ND",
    		"KW_CREAT_NN",
    		"KW_CREAT_RL",
    		"KW_CREAT_TF",
    		"KW_CURRENCY",
    		"KW_CUR_COL",
    		"KW_CUR_DATE",
    		"KW_CUR_QRY",
    		"KW_CUR_RES",
    		"KW_CUR_RQI",
    		"KW_CUR_RSI",
    		"KW_CUR_R_M",
    		"KW_CUR_VAL",
    		"KW_CUR_CHAR",
    		"KW_CUR_ENV",
    		"KW_CUR_DOWN",
    		"KW_CUR_ITER",
    		"KW_CUR_LEFT",
    		"KW_CUR_LINE",
    		"KW_CUR_OFF",
    		"KW_CUR_RGHT",
    		"KW_CUR_UP",
    		"KW_CUT",
    		"KW_DATA_BND",
    		"KW_DATA_E_R",
    		"KW_DATA_REL",
    		"KW_DATA_SCM",
    		"KW_DATA_SM",
    		"KW_DATA_SRI",
    		"KW_DATATYPE",
    		"KW_DATE",
    		"KW_DATETIME",
    		"KW_DATE_TZ",
    		"KW_DATE_FMT",
    		"KW_DAY",
    		"KW_DB_JOIN",
    		"KW_DB_LIST",
    		"KW_DCOLOR",
    		"KW_DDE_ERR",
    		"KW_DDE_ID",
    		"KW_DDE_ITEM",
    		"KW_DDE_NAME",
    		"KW_DDE_NOTI",
    		"KW_DDE_TOPI",
    		"KW_DEBUG",
    		"KW_DECRYPT",
    		"KW_DBG_ALRT",
    		"KW_DE_REGIS",
    		"KW_DEC",
    		"KW_DECL_NSP",
    		"KW_DEF_ACTN",
    		"KW_DEFLT_BN",
    		"KW_DEF_BUFH",
    		"KW_DEF_COMM",
    		"KW_DEF_EXTN",
    		"KW_DEF_STR",
    		"KW_DEF_POP",
    		"KW_DEF_VAL",
    		"KW_DEF_UEVM",
    		"KW_DELEGATE",
    		"KW_DEL_CHAR",
    		"KW_DEL_COL",
    		"KW_DEL_COOK",
    		"KW_DEL_C_R",
    		"KW_DEL_E_L",
    		"KW_DEL_FLD",
    		"KW_DEL_H_EN",
    		"KW_DEL_LINE",
    		"KW_DEL_NODE",
    		"KW_DEL_PROC",
    		"KW_DEL_R_L",
    		"KW_DEL_S_C",
    		"KW_DEL_S_R",
    		"KW_DEL_S_RS",
    		"KW_DEL_WORD",
    		"KW_DESCR",
    		"KW_DESEL_FR",
    		"KW_DESEL_R",
    		"KW_DESEL_SR",
    		"KW_DESELCTN",
    		"KW_DESTRUCT",
    		"KW_DET_DSRC",
    		"KW_DEVICEID",
    		"KW_DIALOG",
    		"KW_DIR",
    		"KW_DIRECTRY",
    		"KW_DIS_D_TR",
    		"KW_DIS_L_TR",
    		"KW_DIS_REDR",
    		"KW_DISABL_C",
    		"KW_DISABLED",
    		"KW_DISPATCH",
    		"KW_DISP_MSG",
    		"KW_DISP_TZ",
    		"KW_DISP_TYP",
    		"KW_DOMAIN_D",
    		"KW_DOMAIN_N",
    		"KW_DOMAIN_T",
    		"KW_DOUBLE",
    		"KW_DRAG_EN",
    		"KW_DROP_DWN",
    		"KW_DROP_FN",
    		"KW_DROP_LST",
    		"KW_DROP_TAR",
    		"KW_DUMP",
    		"KW_DUMP_LGN",
    		"KW_DYN_CAST",
    		"KW_DYN_CURV",
    		"KW_DYN_NEXV",
    		"KW_DYNAMIC",
    		"KW_ECHO",
    		"KW_EDGE_C",
    		"KW_EDGE_P",
    		"KW_EDIT_C_P",
    		"KW_EDIT_C_U",
    		"KW_EDIT_CLR",
    		"KW_EDIT_CPY",
    		"KW_EDIT_CUT",
    		"KW_EDIT_PAS",
    		"KW_EDIT_UND",
    		"KW_EDITOR",
    		"KW_EDIT_B_T",
    		"KW_EDIT_TAB",
    		"KW_EH_FL",
    		"KW_EH_SR",
    		"KW_NO_EMBED",
    		"KW_EMPTY",
    		"KW_EMPTY_DS",
    		"KW_EMPTY_SN",
    		"KW_EMPTY_TT",
    		"KW_ENABLE_C",
    		"KW_ENABLE_E",
    		"KW_ENC_AMK",
    		"KW_ENC_SALT",
    		"KW_ENCODING",
    		"KW_ENCRYPT",
    		"KW_END_B_SN",
    		"KW_END_DOC",
    		"KW_END_ELEM",
    		"KW_END_EV_G",
    		"KW_END_SEAR",
    		"KW_END_USER",
    		"KW_END_ERR",
    		"KW_END_F_D",
    		"KW_END_MOV",
    		"KW_END_RESZ",
    		"KW_END_RRES",
    		"KW_ENDKEY",
    		"KW_ENT_TLST",
    		"KW_ENUM",
    		"KW_ENTERED",
    		"KW_ENTER_MB",
    		"KW_ENT_EX_L",
    		"KW_ERROR",
    		"KW_ERR_CODE",
    		"KW_ERR_COL",
    		"KW_ERR_OBJD",
    		"KW_ERR_ROW",
    		"KW_ERR_S_T",
    		"KW_ERR_STR",
    		"KW_EQ",
    		"KW_EVENTS",
    		"KW_EVT_GRID",
    		"KW_EVT_TYPE",
    		"KW_E_PROC_C",
    		"KW_EXCL_ID",
    		"KW_EXCL_WEB",
    		"KW_EXECUTE",
    		"KW_EXEC_LOG",
    		"KW_EXIT",
    		"KW_EXITCODE",
    		"KW_EXP",
    		"KW_EXPAND",
    		"KW_EXPANDBL",
    		"KW_EXPORT_P",
    		"KW_EXPLICIT",
    		"KW_EXTENDED",
    		"KW_EXTENT",
    		"KW_EXTERN",
    		"KW_FETCH_SR",
    		"KW_FGCOLOR",
    		"KW_FGCOLRGB",
    		"KW_FILE",
    		"KW_FIL_C_D",
    		"KW_FIL_C_T",
    		"KW_FIL_NAME",
    		"KW_FIL_OFF",
    		"KW_FIL_M_D",
    		"KW_FIL_M_T",
    		"KW_FIL_SIZE",
    		"KW_FIL_TYPE",
    		"KW_FILL_IN",
    		"KW_FILL_MOD",
    		"KW_FILL_WST",
    		"KW_FILLED",
    		"KW_FILTERS",
    		"KW_FINAL",
    		"KW_FINALLY",
    		"KW_FIND_BR",
    		"KW_FIND_CUR",
    		"KW_FIND_FD",
    		"KW_FIND_1ST",
    		"KW_FIND_LST",
    		"KW_FIND_NXT",
    		"KW_FIND_PRV",
    		"KW_FIND_UNI",
    		"KW_FINDER",
    		"KW_FIR_DSET",
    		"KW_FIRST_AR",
    		"KW_FIRST_BU",
    		"KW_FIRST_CH",
    		"KW_FIRST_CO",
    		"KW_FIRST_DS",
    		"KW_FIRST_FM",
    		"KW_FIRST_OB",
    		"KW_FIRST_PR",
    		"KW_FIRST_QR",
    		"KW_FIRST_SR",
    		"KW_FIRST_SS",
    		"KW_FIRST_SO",
    		"KW_FIRST_TI",
    		"KW_FIT_LCOL",
    		"KW_FIX_CP",
    		"KW_FIXD_ONL",
    		"KW_FLAGS",
    		"KW_FLAT_BUT",
    		"KW_FLOAT",
    		"KW_FONT_TAB",
    		"KW_FOCUS_R",
    		"KW_FOCUS_RS",
    		"KW_FORCE_F",
    		"KW_FORE",
    		"KW_F_KEY_H",
    		"KW_FORM_INP",
    		"KW_FORM_LIN",
    		"KW_FMT_DT",
    		"KW_FORMATTE",
    		"KW_FORWARD",
    		"KW_FRAGMENT",
    		"KW_FREQ",
    		"KW_FROM_CUR",
    		"KW_FR_SPACE",
    		"KW_FR_X",
    		"KW_FR_Y",
    		"KW_FUNCT",
    		"KW_FULL_H_C",
    		"KW_FULL_H_P",
    		"KW_FULL_W_C",
    		"KW_FULL_W_P",
    		"KW_FULLPATH",
    		"KW_FWD_LOGF",
    		"KW_FWD_ONLY",
    		"KW_GEN_MD5",
    		"KW_GEN_PBEK",
    		"KW_GEN_PBES",
    		"KW_GEN_RNDK",
    		"KW_GEN_UUID",
    		"KW_GET",
    		"KW_GETATTRI",
    		"KW_GET_ATTR",
    		"KW_GET_A_N",
    		"KW_GET_BDAT",
    		"KW_GET_BITS",
    		"KW_GET_B_OR",
    		"KW_GET_BLUE",
    		"KW_GET_BR_C",
    		"KW_GET_BYTS",
    		"KW_GET_B_A",
    		"KW_GET_CFG",
    		"KW_GET_CFGV",
    		"KW_GET_CBPC",
    		"KW_GET_CBPN",
    		"KW_GET_CGIL",
    		"KW_GET_CGIV",
    		"KW_GET_CGL",
    		"KW_GET_CGLV",
    		"KW_GET_CHG",
    		"KW_GET_CHLD",
    		"KW_GET_CLL",
    		"KW_GET_CLNT",
    		"KW_GET_CREL",
    		"KW_GET_CUR",
    		"KW_GET_DIR",
    		"KW_GET_DBCL",
    		"KW_GET_DBL",
    		"KW_GET_DS_B",
    		"KW_GET_D_E",
    		"KW_GET_D_F",
    		"KW_GET_DYN",
    		"KW_GET_FILE",
    		"KW_GET_1ST",
    		"KW_GET_FLT",
    		"KW_GET_GRN",
    		"KW_GET_HD_E",
    		"KW_GET_IBNN",
    		"KW_GET_IBQN",
    		"KW_GET_I64",
    		"KW_GET_ITER",
    		"KW_GET_LAST",
    		"KW_GET_LNBI",
    		"KW_GET_LIC",
    		"KW_GET_LONG",
    		"KW_GET_LPRM",
    		"KW_GET_L_V",
    		"KW_GET_MOP",
    		"KW_GET_MSG",
    		"KW_GET_MSGG",
    		"KW_GET_MSGS",
    		"KW_GET_NEXT",
    		"KW_GET_NODE",
    		"KW_GET_NUM",
    		"KW_GET_PAR",
    		"KW_GET_PTR",
    		"KW_GET_PREV",
    		"KW_GET_PROP",
    		"KW_GET_PRT",
    		"KW_GET_QNBI",
    		"KW_GET_R_R",
    		"KW_GET_RED",
    		"KW_GET_REL",
    		"KW_GET_RGB",
    		"KW_GET_SHRT",
    		"KW_GET_SELW",
    		"KW_GET_SER",
    		"KW_GET_SIG",
    		"KW_GET_SRCB",
    		"KW_GET_SZ",
    		"KW_GET_S_O",
    		"KW_GET_STR",
    		"KW_GET_T_S",
    		"KW_GET_TBI",
    		"KW_GET_TBNN",
    		"KW_GET_TBQN",
    		"KW_GET_TI",
    		"KW_GET_THCH",
    		"KW_GET_THPX",
    		"KW_GET_TOPB",
    		"KW_GET_TWCH",
    		"KW_GET_TWPX",
    		"KW_GET_UBI",
    		"KW_GET_UL",
    		"KW_GET_USHT",
    		"KW_GET_U_F",
    		"KW_GET_VAL",
    		"KW_GET_VBI",
    		"KW_GET_VBNN",
    		"KW_GET_VBQN",
    		"KW_GET_WAIT",
    		"KW_GET_WKDR",
    		"KW_GO",
    		"KW_GOTO",
    		"KW_GRD_F_H",
    		"KW_GRD_F_V",
    		"KW_GRD_SNAP",
    		"KW_GRD_UHC",
    		"KW_GRD_UHP",
    		"KW_GRD_UWC",
    		"KW_GRD_UWP",
    		"KW_GRD_VIS",
    		"KW_GROUP_BX",
    		"KW_GETCLASS",
    		"KW_GET_CGI",
    		"KW_GET_COOK",
    		"KW_GET_FLD",
    		"KW_GT",
    		"KW_GTE",
    		"KW_GUID",
    		"KW_HANDLE",
    		"KW_HANDLER",
    		"KW_HAS_LOBS",
    		"KW_HAS_REC",
    		"KW_HEIGHT_C",
    		"KW_HEIGHT_P",
    		"KW_HELP_TOP",
    		"KW_HEX_DECD",
    		"KW_HEX_ENCD",
    		"KW_HID_FLD",
    		"KW_HID_FLDL",
    		"KW_HIDDEN",
    		"KW_HINT",
    		"KW_HOME",
    		"KW_HORIZ",
    		"KW_HTML_CHS",
    		"KW_HTML_ENC",
    		"KW_HTML_EOL",
    		"KW_HTML_EOP",
    		"KW_HTML_FRB",
    		"KW_HTML_FRE",
    		"KW_HTML_H_B",
    		"KW_HTML_H_E",
    		"KW_HTML_T_B",
    		"KW_HTML_T_E",
    		"KW_HTMLERR",
    		"KW_HWND",
    		"KW_HYPERLNK",
    		"KW_HONOR_PK",
    		"KW_HONOR_RK",
    		"KW_ICON",
    		"KW_ICFPARM",
    		"KW_IDEPHWND",
    		"KW_IDEWNTYP",
    		"KW_IDX_HINT",
    		"KW_IDX_INFO",
    		"KW_IGN_CMOD",
    		"KW_IMAGE",
    		"KW_IMG_DOWN",
    		"KW_IMG_INS",
    		"KW_IMG_ONLY",
    		"KW_IMG_SZ",
    		"KW_IMG_SZ_C",
    		"KW_IMG_SZ_P",
    		"KW_IMG_UP",
    		"KW_IDX_REPO",
    		"KW_IMM_DISP",
    		"KW_IMP_NODE",
    		"KW_IMP_PRNC",
    		"KW_IMPLEMTS",
    		"KW_IN_HNDL",
    		"KW_INC_EX_I",
    		"KW_INFO",
    		"KW_INH_BGC",
    		"KW_INH_FGC",
    		"KW_INHERITS",
    		"KW_INIT_SES",
    		"KW_INIT",
    		"KW_INIT_C_P",
    		"KW_INIT_D_T",
    		"KW_INIT_DIR",
    		"KW_INIT_FLT",
    		"KW_INITIATE",
    		"KW_INNER_C",
    		"KW_INNER_L",
    		"KW_INNER",
    		"KW_INPT_VAL",
    		"KW_INS_ATTR",
    		"KW_INS_B4",
    		"KW_INS_BTAB",
    		"KW_INS_COL",
    		"KW_INS_FLD",
    		"KW_INS_FLDD",
    		"KW_INS_FLDL",
    		"KW_INS_MODE",
    		"KW_INS_FILE",
    		"KW_INS_ROW",
    		"KW_INS_STR",
    		"KW_INS_TAB",
    		"KW_INST_PRC",
    		"KW_INT",
    		"KW_INT64",
    		"KW_INT_ENT",
    		"KW_INTERFAC",
    		"KW_INTERVAL",
    		"KW_INVOKE",
    		"KW_IP_TIME",
    		"KW_IS_CLASS",
    		"KW_IS_COLCP",
    		"KW_IS_CP_FX",
    		"KW_IS_DB_MT",
    		"KW_IS_JSON",
    		"KW_IS_M_TEN",
    		"KW_IS_OPEN",
    		"KW_IS_PART",
    		"KW_IS_P_SET",
    		"KW_IS_R_SEL",
    		"KW_IS_SEL",
    		"KW_IS_XML",
    		"KW_ISO_DATE",
    		"KW_ITEM",
    		"KW_ITEM_ROW",
    		"KW_ITER_CHG",
    		"KW_IUNKNOWN",
    		"KW_JAVA",
    		"KW_JOIN_BY",
    		"KW_KEEP_CON",
    		"KW_KEEP_ZOR",
    		"KW_KEEP_MSG",
    		"KW_KEEP_SEC",
    		"KW_KEEP_TAB",
    		"KW_KEY",
    		"KW_KW_ALL",
    		"KW_LAB_BGC",
    		"KW_LAB_DC",
    		"KW_LAB_FGC",
    		"KW_LAB_FONT",
    		"KW_LAB_PFC",
    		"KW_LABELS",
    		"KW_LAB_H_C",
    		"KW_LANDSCAP",
    		"KW_LANGUAGE",
    		"KW_LARGE",
    		"KW_LAST_BAT",
    		"KW_LAST_FRM",
    		"KW_LAST_OBJ",
    		"KW_LAST_TI",
    		"KW_LG_2_SM",
    		"KW_LAST_AR",
    		"KW_LAST_CH",
    		"KW_LAST_PRC",
    		"KW_LAST_SRV",
    		"KW_LAST_SS",
    		"KW_LAST_SOC",
    		"KW_LCHR_2NV",
    		"KW_LEFT",
    		"KW_LEFT_AL",
    		"KW_LEFT_END",
    		"KW_LEFT_MC",
    		"KW_LEFT_MDC",
    		"KW_LEFT_MD",
    		"KW_LEFT_MU",
    		"KW_LENGTH",
    		"KW_LINE",
    		"KW_L_TRIM",
    		"KW_LIB_C_C",
    		"KW_LISTINGS",
    		"KW_LST_PAIR",
    		"KW_LIST_ITM",
    		"KW_LIST_PNM",
    		"KW_LIT_QSTN",
    		"KW_LST_EVNT",
    		"KW_LST_QRY",
    		"KW_LST_SET",
    		"KW_LST_WID",
    		"KW_LOAD",
    		"KW_LOAD_DMN",
    		"KW_LOAD_ICO",
    		"KW_LOAD_IMG",
    		"KW_LOAD_I_D",
    		"KW_LOAD_I_I",
    		"KW_LOAD_I_U",
    		"KW_LOAD_M_P",
    		"KW_LOAD_PIC",
    		"KW_LOAD_S_I",
    		"KW_LOADCTRL",
    		"KW_LOB_DIR",
    		"KW_LOC_V_I",
    		"KW_LOC_C_N",
    		"KW_LOC_HOST",
    		"KW_LOC_L_N",
    		"KW_LOC_NAME",
    		"KW_LOC_PORT",
    		"KW_LOC_P_ID",
    		"KW_LOC_S_ID",
    		"KW_LOC_TYPE",
    		"KW_LOCK_REG",
    		"KW_LOG",
    		"KW_LOG_A_EV",
    		"KW_LOG_E_TS",
    		"KW_LOG_EN_T",
    		"KW_LOG_ID",
    		"KW_LOG_HOST",
    		"KW_LOG_STAT",
    		"KW_LOG_THRS",
    		"KW_LOGF_NAM",
    		"KW_LOGG_LEV",
    		"KW_LOGICAL",
    		"KW_LOGOUT",
    		"KW_LOOKAHD",
    		"KW_LONG",
    		"KW_LONGCHAR",
    		"KW_LC",
    		"KW_LT",
    		"KW_LTE",
    		"KW_MAINMENU",
    		"KW_MAND",
    		"KW_MAN_HIGH",
    		"KW_MARG_EX",
    		"KW_MARG_H_C",
    		"KW_MARG_H_P",
    		"KW_MARG_W_C",
    		"KW_MARG_W_P",
    		"KW_MARK_NEW",
    		"KW_MARK_RS",
    		"KW_MATCHES",
    		"KW_MAX",
    		"KW_MAX_BTN",
    		"KW_MAX_CHAR",
    		"KW_MAX_D_G",
    		"KW_MAX_HT",
    		"KW_MAX_H_C",
    		"KW_MAX_H_P",
    		"KW_MAX_LVL",
    		"KW_MAX_W_C",
    		"KW_MAX_W_P",
    		"KW_MAX_ROWS",
    		"KW_MAX_SZ",
    		"KW_MAX_VAL",
    		"KW_MAX_WID",
    		"KW_MAXIMIZE",
    		"KW_MD5_VAL",
    		"KW_MD5_DIG",
    		"KW_MEMPTR",
    		"KW_MPTR_2NV",
    		"KW_MENU",
    		"KW_MENU_BAR",
    		"KW_MENU_DRP",
    		"KW_MENU_ITM",
    		"KW_MENU_KEY",
    		"KW_MENU_MOU",
    		"KW_MERGE_BF",
    		"KW_MERGE_CH",
    		"KW_MERGE_RC",
    		"KW_METHOD",
    		"KW_MF_DFR",
    		"KW_MF_DI",
    		"KW_MF_DIP",
    		"KW_MF_DL",
    		"KW_MF_DR",
    		"KW_MF_DT",
    		"KW_MF_DTAX",
    		"KW_MF_DTAXL",
    		"KW_MF_DTAXR",
    		"KW_MF_DTB",
    		"KW_MF_DTBL",
    		"KW_MF_DTBR",
    		"KW_MF_DTSX",
    		"KW_MF_GF",
    		"KW_MF_GFH",
    		"KW_MF_GFSD",
    		"KW_MF_GFSR",
    		"KW_MF_GPH",
    		"KW_MF_GPN",
    		"KW_MF_GPW",
    		"KW_MF_GTW",
    		"KW_MF_GXY",
    		"KW_MF_GZF",
    		"KW_MF_INIT",
    		"KW_MF_IR",
    		"KW_MF_MPDF",
    		"KW_MF_P2MU",
    		"KW_MF_RP",
    		"KW_MF_SF",
    		"KW_MF_SFC",
    		"KW_MF_SFH",
    		"KW_MF_SI",
    		"KW_MF_SIA",
    		"KW_MF_SLA",
    		"KW_MF_SLC",
    		"KW_MF_SLM",
    		"KW_MF_SLS",
    		"KW_MF_SNP",
    		"KW_MF_SNTL",
    		"KW_MF_SPF",
    		"KW_MF_SPN",
    		"KW_MF_SPNP",
    		"KW_MF_SPNT",
    		"KW_MF_SPO",
    		"KW_MF_SR",
    		"KW_MF_STA",
    		"KW_MF_STC",
    		"KW_MF_STS",
    		"KW_MF_SXY",
    		"KW_MF_SZF",
    		"KW_MODIFIRS",
    		"KW_MSG_AREA",
    		"KW_MSG_AFNT",
    		"KW_MSG_AMSG",
    		"KW_MSG_DIG",
    		"KW_MESSAGES",
    		"KW_MDL_MC",
    		"KW_MDL_MDC",
    		"KW_MDL_MD",
    		"KW_MDL_MU",
    		"KW_MIN",
    		"KW_MIN_BTN",
    		"KW_MIN_CWCH",
    		"KW_MIN_CWPX",
    		"KW_MIN_H_C",
    		"KW_MIN_H_P",
    		"KW_MIN_SCHM",
    		"KW_MIN_SZ",
    		"KW_MIN_VAL",
    		"KW_MIN_W_C",
    		"KW_MIN_W_P",
    		"KW_MNEMON",
    		"KW_MODIFIED",
    		"KW_MOD",
    		"KW_MONTH",
    		"KW_MOU_XC",
    		"KW_MOU_XDC",
    		"KW_MOU_XD",
    		"KW_MOU_XU",
    		"KW_MOU_MC",
    		"KW_MOU_MDC",
    		"KW_MOU_MD",
    		"KW_MOU_MU",
    		"KW_MOU_MVC",
    		"KW_MOU_MVDC",
    		"KW_MOU_MVD",
    		"KW_MOU_MVU",
    		"KW_MOU_PTR",
    		"KW_MOU_SC",
    		"KW_MOU_SDC",
    		"KW_MOU_SD",
    		"KW_MOU_SU",
    		"KW_MOVABLE",
    		"KW_MOVE",
    		"KW_MOV_A_T",
    		"KW_MOV_B_T",
    		"KW_MOV_COL",
    		"KW_MOV_2_B",
    		"KW_MOV_2_T",
    		"KW_MOV_2EOF",
    		"KW_MSICON",
    		"KW_MSPNTNUM",
    		"KW_MTIME",
    		"KW_MULT_CMP",
    		"KW_MULTIPLE",
    		"KW_MULT_KEY",
    		"KW_MULTI_IN",
    		"KW_MUST_EXI",
    		"KW_MUST_UND",
    		"KW_NAME",
    		"KW_NAMESP_P",
    		"KW_NAMESP_U",
    		"KW_NATIVE",
    		"KW_NE",
    		"KW_NEEDS_AP",
    		"KW_NEEDS_PR",
    		"KW_NESTED",
    		"KW_NEXT_COL",
    		"KW_NEXT_ERR",
    		"KW_NEXT_FR",
    		"KW_NEXT_RID",
    		"KW_NEXT_SIB",
    		"KW_NEXT_TAB",
    		"KW_NEXT_VAL",
    		"KW_NEXTWORD",
    		"KW_NEW_INST",
    		"KW_NEW_LINE",
    		"KW_NEW_ROW",
    		"KW_NEW_SESS",
    		"KW_NON_SER",
    		"KW_NNMSP_SL",
    		"KW_NORMAL",
    		"KW_NORMALZE",
    		"KW_NO_APPLY",
    		"KW_NO_ARMSG",
    		"KW_NO_ASSGN",
    		"KW_NO_AUTOV",
    		"KW_NO_BIND",
    		"KW_NO_BOX",
    		"KW_NO_COLS",
    		"KW_NO_CONS",
    		"KW_NO_CVT",
    		"KW_NO_CV_3D",
    		"KW_NO_CUR_V",
    		"KW_NO_DEBUG",
    		"KW_NO_DRAG",
    		"KW_NO_ECHO",
    		"KW_NO_EH_SR",
    		"KW_NO_EH_FL",
    		"KW_NO_EM_SP",
    		"KW_NO_HELP",
    		"KW_NO_IDX_H",
    		"KW_NO_INHBG",
    		"KW_NO_INHFG",
    		"KW_NO_JOIN",
    		"KW_NO_LOOKA",
    		"KW_NO_ROW_M",
    		"KW_NO_SCH_M",
    		"KW_NO_SEP_C",
    		"KW_NO_SEPS",
    		"KW_NO_SCR_V",
    		"KW_NO_TAB_S",
    		"KW_NO_UNDL",
    		"KW_NO_WRAP",
    		"KW_NODE_CHE",
    		"KW_NODE_VAL",
    		"KW_NODE_V2M",
    		"KW_NODV_2LC",
    		"KW_NONE",
    		"KW_NUM_BUFF",
    		"KW_NUM_BUTT",
    		"KW_NUM_CHLN",
    		"KW_NUM_CH_R",
    		"KW_NUM_COL",
    		"KW_NUM_COPY",
    		"KW_NUM_DROP",
    		"KW_NUM_FLD",
    		"KW_NUM_FMTS",
    		"KW_NUM_HD_E",
    		"KW_NUM_ITMS",
    		"KW_NUM_ITER",
    		"KW_NUM_LOGF",
    		"KW_NUM_LK_C",
    		"KW_NUM_LNS",
    		"KW_NUM_MSG",
    		"KW_NUM_PARM",
    		"KW_NUM_REF",
    		"KW_NUM_REL",
    		"KW_NUM_REPL",
    		"KW_NUM_RES",
    		"KW_NUM_SR",
    		"KW_NUM_SRCB",
    		"KW_NUM_TOPB",
    		"KW_NUM_SW",
    		"KW_NUM_TABS",
    		"KW_NUM_2RTN",
    		"KW_NUM_V_C",
    		"KW_NUM_D_P",
    		"KW_NUMERIC",
    		"KW_NUM_FMT",
    		"KW_NUM_SEP",
    		"KW_OBJECT",
    		"KW_OCT_LEN",
    		"KW_OFF_END",
    		"KW_OFF_HOME",
    		"KW_OK",
    		"KW_OK_CAN",
    		"KW_OLE_INVL",
    		"KW_OLE_NAML",
    		"KW_ON_FR_B",
    		"KW_ONLY",
    		"KW_ORG_HAND",
    		"KW_ORG_ROID",
    		"KW_ORDER",
    		"KW_ORD_JOIN",
    		"KW_OPEN_L_A",
    		"KW_OPENMIME",
    		"KW_OPENPOPU",
    		"KW_OPEN_URL",
    		"KW_OPTIONS",
    		"KW_OPTIONSF",
    		"KW_ORDINAL",
    		"KW_OS_DRV",
    		"KW_OS_ERR",
    		"KW_OS_G_ENV",
    		"KW_OS_UID",
    		"KW_OUT_JOIN",
    		"KW_OUTER",
    		"KW_OUTPUTCT",
    		"KW_OUT_HDR",
    		"KW_OUT_HH",
    		"KW_OUT_MSGS",
    		"KW_OVERRIDE",
    		"KW_OWNER",
    		"KW_OWN_DOC",
    		"KW_P2J_RC",
    		"KW_PAGE_DWN",
    		"KW_PAGE_LFT",
    		"KW_PAGE_RT",
    		"KW_PAGE_SZ",
    		"KW_PAGE_UP",
    		"KW_PAGE_WID",
    		"KW_PAGED",
    		"KW_PAR_BUFF",
    		"KW_PAR_FLDA",
    		"KW_PAR_FLDB",
    		"KW_PAR_IFLD",
    		"KW_PAR_IREL",
    		"KW_PAR_REL",
    		"KW_PAR_W_C",
    		"KW_PARENT",
    		"KW_PART_KEY",
    		"KW_PATHNAME",
    		"KW_PARSE_ST",
    		"KW_PASCAL",
    		"KW_PASTE",
    		"KW_PBE_H_AL",
    		"KW_PBE_KEYR",
    		"KW_PERF",
    		"KW_PREF_DS",
    		"KW_PRE_LBL",
    		"KW_PRS_PROC",
    		"KW_PRS_C_D",
    		"KW_PFCOLOR",
    		"KW_PICK",
    		"KW_PICK_ARE",
    		"KW_PICK_BTH",
    		"KW_PIX_COL",
    		"KW_PIX_ROW",
    		"KW_PK_PRIV",
    		"KW_PK_PROT",
    		"KW_POLY",
    		"KW_POP_MENU",
    		"KW_POP_ONLY",
    		"KW_PORTRAIT",
    		"KW_POS",
    		"KW_PRECISN",
    		"KW_PREP_STR",
    		"KW_PREPARED",
    		"KW_PRESEL",
    		"KW_PREV",
    		"KW_PREV_COL",
    		"KW_PREV_FR",
    		"KW_PREV_SIB",
    		"KW_PREV_T_I",
    		"KW_PREVWORD",
    		"KW_PRIM_P_P",
    		"KW_PRIMARY",
    		"KW_PRINTER",
    		"KW_PRT_C_H",
    		"KW_PRT_HDC",
    		"KW_PRT_NAME",
    		"KW_PRT_PORT",
    		"KW_PRT_SET",
    		"KW_PRIVATE",
    		"KW_PRIV_DAT",
    		"KW_PROCNAME",
    		"KW_PROCTYPE",
    		"KW_PROC_COM",
    		"KW_PROC",
    		"KW_PROC_W_R",
    		"KW_PROC_TXT",
    		"KW_PROC_T_B",
    		"KW_PRODATAS",
    		"KW_PROFILNG",
    		"KW_PROG_SRC",
    		"KW_PRO_ARCH",
    		"KW_PROPERTY",
    		"KW_PROTECTD",
    		"KW_PROXY",
    		"KW_PROX_PWD",
    		"KW_PROX_UID",
    		"KW_PUBLIC",
    		"KW_PUB_ID",
    		"KW_PUB_EVTS",
    		"KW_PUT_BITS",
    		"KW_PUT_BYTS",
    		"KW_PUT_I64",
    		"KW_PUT_DBL",
    		"KW_PUT_FLT",
    		"KW_PUT_LONG",
    		"KW_PUT_SHT",
    		"KW_PUT_STR",
    		"KW_PUT_UL",
    		"KW_PUT_USHT",
    		"KW_QRY_OPEN",
    		"KW_QRY_PREP",
    		"KW_QUAL_UID",
    		"KW_QUEST",
    		"KW_QUE_MSG",
    		"KW_QUOTER",
    		"KW_RADIO_B",
    		"KW_RADIO_S",
    		"KW_RANDOM",
    		"KW_RAW",
    		"KW_RAW_TRAN",
    		"KW_READ",
    		"KW_REAL",
    		"KW_READ_FIL",
    		"KW_READ_JSN",
    		"KW_READ_ONL",
    		"KW_READ_RES",
    		"KW_READ_XML",
    		"KW_READ_XSC",
    		"KW_RECALL",
    		"KW_REC_LEN",
    		"KW_RECURSE",
    		"KW_REF_ONLY",
    		"KW_REFR_A_P",
    		"KW_REFRESH",
    		"KW_REFRABLE",
    		"KW_REG_DMN",
    		"KW_REGISTER",
    		"KW_REJ_CHGS",
    		"KW_REJ_RCHG",
    		"KW_REJECTED",
    		"KW_REL_FLDS",
    		"KW_RELS_ACT",
    		"KW_RELSESID",
    		"KW_REM_HOST",
    		"KW_REM_PORT",
    		"KW_REMOTE",
    		"KW_REM_ATTR",
    		"KW_REM_EVTP",
    		"KW_REM_CHLD",
    		"KW_REM_SUP",
    		"KW_REPLACE",
    		"KW_REPOS_M",
    		"KW_REP_CHLD",
    		"KW_REP_STXT",
    		"KW_REPORTS",
    		"KW_REQUEST",
    		"KW_REQ_INFO",
    		"KW_RSP_INFO",
    		"KW_RESET",
    		"KW_RESIZE",
    		"KW_RESIZABL",
    		"KW_REST_RID",
    		"KW_REST_ROW",
    		"KW_RESULT",
    		"KW_RESUME_D",
    		"KW_RET_SHAP",
    		"KW_RETRY_C",
    		"KW_RET_INS",
    		"KW_RET_VAL",
    		"KW_RET_VDT",
    		"KW_RET_VLT",
    		"KW_RET_2SD",
    		"KW_RETURNS",
    		"KW_REV_FROM",
    		"KW_RFRSH_UI",
    		"KW_RGB_VAL",
    		"KW_RIGHT",
    		"KW_RIGHT_AL",
    		"KW_RT_END",
    		"KW_RT_MC",
    		"KW_RT_MDC",
    		"KW_RT_MD",
    		"KW_RT_MU",
    		"KW_R_TRIM",
    		"KW_ROLE",
    		"KW_ROLES",
    		"KW_ROUND",
    		"KW_ROUNDED",
    		"KW_ROUTINEL",
    		"KW_ROW",
    		"KW_ROW_CRT",
    		"KW_ROW_DEL",
    		"KW_ROW_DISP",
    		"KW_ROW_ENTR",
    		"KW_ROW_H_C",
    		"KW_ROW_H_P",
    		"KW_ROW_LEAV",
    		"KW_ROW_OF",
    		"KW_ROW_MARK",
    		"KW_ROW_RESZ",
    		"KW_ROW_STAT",
    		"KW_ROW_UPD",
    		"KW_ROWID",
    		"KW_RUN_PROC",
    		"KW_RUN_W_O",
    		"KW_RULE",
    		"KW_RULE_ROW",
    		"KW_RULE_Y",
    		"KW_SAVE_AS",
    		"KW_SAVE_FIL",
    		"KW_SAX_ATTR",
    		"KW_SAX_PARF",
    		"KW_SAX_PARN",
    		"KW_SAX_PARS",
    		"KW_SAX_READ",
    		"KW_SAX_WRIT",
    		"KW_SAVE_RCH",
    		"KW_SAVE_WST",
    		"KW_SCH_CHG",
    		"KW_SCH_LOC",
    		"KW_SCH_MARS",
    		"KW_SCH_PATH",
    		"KW_SCROLLBL",
    		"KW_SCROLLBA",
    		"KW_SCR_DELT",
    		"KW_SCR_LEFT",
    		"KW_SCROLL_H",
    		"KW_SCR_MODE",
    		"KW_SCR_NOT",
    		"KW_SCR_OFFS",
    		"KW_SCR_RT",
    		"KW_SCR_2CR",
    		"KW_SCR_2ITM",
    		"KW_SCR_2SR",
    		"KW_SCR_COL",
    		"KW_SCR_HGHT",
    		"KW_SCR_SCAL",
    		"KW_SCR_WDTH",
    		"KW_SCRN_VAL",
    		"KW_SCROLL_V",
    		"KW_SCR_RPOS",
    		"KW_SCROLLIN",
    		"KW_SEAL",
    		"KW_SEAL_TST",
    		"KW_SECTION",
    		"KW_SEL_ALL",
    		"KW_SEL_END",
    		"KW_SEL_FOCR",
    		"KW_SEL_NEXT",
    		"KW_SEL_PREV",
    		"KW_SEL_ROW",
    		"KW_SEL_STRT",
    		"KW_SEL_TXT",
    		"KW_SELECTBL",
    		"KW_SELECTED",
    		"KW_SELECTN",
    		"KW_SEL_LST",
    		"KW_SEND",
    		"KW_SEND_SQL",
    		"KW_SENSITIV",
    		"KW_SEPS",
    		"KW_SEP_CONN",
    		"KW_SEP_FGC",
    		"KW_SERIALAB",
    		"KW_SERIALZH",
    		"KW_SERIALZN",
    		"KW_SERIALZR",
    		"KW_SERVER",
    		"KW_SESS_END",
    		"KW_SESSN_ID",
    		"KW_SRV_C_B",
    		"KW_SRV_C_BR",
    		"KW_SRV_C_C",
    		"KW_SRV_C_I",
    		"KW_SRV_OP_M",
    		"KW_SETTINGS",
    		"KW_SET_ACTR",
    		"KW_SET_ACTX",
    		"KW_SET_ATTR",
    		"KW_SET_A_L",
    		"KW_SET_A_N",
    		"KW_SET_BLUE",
    		"KW_SET_BRK",
    		"KW_SET_BUF",
    		"KW_SET_B_OR",
    		"KW_SET_CB_P",
    		"KW_SET_CBAC",
    		"KW_SET_CLNT",
    		"KW_SET_COMM",
    		"KW_SET_C_P",
    		"KW_SET_CONT",
    		"KW_SET_COOK",
    		"KW_SET_DBCL",
    		"KW_SET_DYN",
    		"KW_SET_EVMO",
    		"KW_SET_GRN",
    		"KW_SET_ISRC",
    		"KW_SET_LSTK",
    		"KW_SET_M_UN",
    		"KW_SET_N_F",
    		"KW_SET_NODE",
    		"KW_SET_ODST",
    		"KW_SET_OPT",
    		"KW_SET_PARM",
    		"KW_SET_PROP",
    		"KW_SET_PTR",
    		"KW_SET_RED",
    		"KW_SET_RGB",
    		"KW_SET_RRP",
    		"KW_SET_RPOS",
    		"KW_SET_ROLL",
    		"KW_SET_SEL",
    		"KW_SET_SERD",
    		"KW_SET_SZ",
    		"KW_SET_S_AR",
    		"KW_SET_T_S",
    		"KW_SET_U_F",
    		"KW_SET_S_O",
    		"KW_SET_WAIT",
    		"KW_SET_WKDR",
    		"KW_SET_W_S",
    		"KW_SRV_SOCK",
    		"KW_SHA1_DIG",
    		"KW_SHORT",
    		"KW_SHOW_ITB",
    		"KW_SIDE_L",
    		"KW_SIDE_L_H",
    		"KW_SIGNATUR",
    		"KW_SILENT",
    		"KW_SIMPLE",
    		"KW_SINGLE",
    		"KW_SINGLTON",
    		"KW_SIZE",
    		"KW_SIZE_C",
    		"KW_SIZE_P",
    		"KW_SLIDER",
    		"KW_SMAL_ICO",
    		"KW_SMAL_TTL",
    		"KW_SMALLINT",
    		"KW_SRC_PROC",
    		"KW_SOAP_HDR",
    		"KW_SOAP_HER",
    		"KW_SOAP_F",
    		"KW_SOAP_F_A",
    		"KW_SOAP_F_C",
    		"KW_SOAP_F_D",
    		"KW_SOAP_FMH",
    		"KW_SOAP_F_N",
    		"KW_SOAP_F_R",
    		"KW_SOAP_F_S",
    		"KW_SOAP_FSC",
    		"KW_SOAP_VER",
    		"KW_SOCKET",
    		"KW_SORT",
    		"KW_SORT_ASC",
    		"KW_SORT_NUM",
    		"KW_SOURCE",
    		"KW_SQL",
    		"KW_SQRT",
    		"KW_SSL_SRVN",
    		"KW_STANDALN",
    		"KW_START",
    		"KW_START_BS",
    		"KW_START_DC",
    		"KW_START_EL",
    		"KW_START_MV",
    		"KW_START_RS",
    		"KW_START_RR",
    		"KW_START_SC",
    		"KW_STARTING",
    		"KW_STAT_DET",
    		"KW_STATIC",
    		"KW_STATUS_A",
    		"KW_STAT_A_F",
    		"KW_STDCALL",
    		"KW_STOP",
    		"KW_STOP_AFT",
    		"KW_STOP_D",
    		"KW_STOP_PRS",
    		"KW_STOPPED",
    		"KW_STORPROC",
    		"KW_STUP_PAR",
    		"KW_ST_2_FIT",
    		"KW_STR_VAL",
    		"KW_STR_XREF",
    		"KW_STRICT",
    		"KW_STRIC_ER",
    		"KW_STRING",
    		"KW_SUB_AVG",
    		"KW_SUB_CNT",
    		"KW_SUB_MAX",
    		"KW_SUB_MENU",
    		"KW_SUB_M_H",
    		"KW_SUB_MIN",
    		"KW_SUB_TOT",
    		"KW_SUBSTIT",
    		"KW_SUBSTR",
    		"KW_SUBTYPE",
    		"KW_SUM",
    		"KW_SUP_NS_P",
    		"KW_SUP_PROC",
    		"KW_SUP_WARN",
    		"KW_SUPW_LST",
    		"KW_SYM_EN_A",
    		"KW_SYM_EN_I",
    		"KW_SYM_EN_K",
    		"KW_SYM_SUPP",
    		"KW_SYNCHRON",
    		"KW_SYS_A_B",
    		"KW_SYS_HELP",
    		"KW_SYS_ID",
    		"KW_TAB",
    		"KW_TAB_CRCL",
    		"KW_TAB_HAND",
    		"KW_TAB_LIST",
    		"KW_TAB_POS",
    		"KW_TAB_SCAN",
    		"KW_TAB_STOP",
    		"KW_TAG",
    		"KW_TARGET",
    		"KW_TAR_PROC",
    		"KW_TEMP_DIR",
    		"KW_TEMP_TAB",
    		"KW_TRC_FILT",
    		"KW_TRAC_CHG",
    		"KW_TT_PREP",
    		"KW_TEN_ID",
    		"KW_TENNAME",
    		"KW_TN_TOID",
    		"KW_TERM_HK",
    		"KW_TERMINAT",
    		"KW_TXT_SEG",
    		"KW_TXT_SEL",
    		"KW_3D",
    		"KW_THROUGH",
    		"KW_THROW",
    		"KW_THR_SAFE",
    		"KW_TIC_MARK",
    		"KW_TIMEZONE",
    		"KW_TIME_SRC",
    		"KW_TITL_BGC",
    		"KW_TITL_DC",
    		"KW_TITL_FGC",
    		"KW_TITL_FON",
    		"KW_TODAY",
    		"KW_TOGGL_BX",
    		"KW_TOOLTIP",
    		"KW_TOOLTIPS",
    		"KW_TOP",
    		"KW_TOP_COL",
    		"KW_TOP_NAVQ",
    		"KW_TOPIC",
    		"KW_TOTAL",
    		"KW_TRACING",
    		"KW_TRAILING",
    		"KW_TRAN_I_P",
    		"KW_TRAN_MOD",
    		"KW_TRANSPAR",
    		"KW_TRUNC",
    		"KW_TTCP",
    		"KW_TYPE",
    		"KW_TYPE_OF",
    		"KW_UNBOX",
    		"KW_UNBUF",
    		"KW_UNDO_T_S",
    		"KW_UNIQ_ID",
    		"KW_UNIQ_MAT",
    		"KW_UNIX_END",
    		"KW_UNL_HID",
    		"KW_UNLOAD",
    		"KW_UNS_BYTE",
    		"KW_UNS_SHRT",
    		"KW_UNS_LONG",
    		"KW_UPD_ATTR",
    		"KW_URL",
    		"KW_URL_DECO",
    		"KW_URL_ENCO",
    		"KW_URL_FLD",
    		"KW_URL_FLDL",
    		"KW_URL_FMT",
    		"KW_URL_PW",
    		"KW_URL_UID",
    		"KW_USE",
    		"KW_USE_DCT",
    		"KW_USE_FIL",
    		"KW_USE_REV",
    		"KW_USE_TXT",
    		"KW_USE_UND",
    		"KW_USE_WIDP",
    		"KW_USR_DATA",
    		"KW_USER_ID",
    		"KW_UTC_OFF",
    		"KW_V6DISP",
    		"KW_VAL_ENAB",
    		"KW_VAL_EXPR",
    		"KW_VAL_MSG",
    		"KW_VAL_SEAL",
    		"KW_VAL_XML",
    		"KW_VALIDATE",
    		"KW_VAL_EVT",
    		"KW_VAL_HND",
    		"KW_VAL_OBJ",
    		"KW_VAR",
    		"KW_VERBOSE",
    		"KW_VERSION",
    		"KW_VERT",
    		"KW_VIEW_FCR",
    		"KW_VIRT_HC",
    		"KW_VIRT_HP",
    		"KW_VIRT_WC",
    		"KW_VIRT_WP",
    		"KW_VISIBLE",
    		"KW_WAIT",
    		"KW_VOID",
    		"KW_WARN",
    		"KW_WC_AD_AP",
    		"KW_WEB",
    		"KW_WEB_CTX",
    		"KW_WEB_FUP",
    		"KW_WEB_OUT",
    		"KW_WEEK",
    		"KW_WHERE_ST",
    		"KW_WIDGET",
    		"KW_WID_ENT",
    		"KW_WID_HAND",
    		"KW_WID_ID",
    		"KW_WID_LEAV",
    		"KW_WID_POOL",
    		"KW_WIDTH",
    		"KW_WIDTH_C",
    		"KW_WIDTH_P",
    		"KW_WIN_CLOS",
    		"KW_WIN_NAME",
    		"KW_WIN_RESI",
    		"KW_WIN_REST",
    		"KW_WIN_STAT",
    		"KW_WIN_SYS",
    		"KW_WORD_IDX",
    		"KW_WORD_WRP",
    		"KW_WA_H_P",
    		"KW_WA_W_P",
    		"KW_WA_X",
    		"KW_WA_Y",
    		"KW_WR_CDATA",
    		"KW_WR_CHARS",
    		"KW_WR_CMNT",
    		"KW_WR_DATA",
    		"KW_WR_D_ELM",
    		"KW_WR_E_ELM",
    		"KW_WR_ENT_R",
    		"KW_WR_EXDTD",
    		"KW_WR_FRAGM",
    		"KW_WR_JSON",
    		"KW_WR_MSG",
    		"KW_WR_PRINS",
    		"KW_WR_STAT",
    		"KW_WR_XML",
    		"KW_WR_XMLSC",
    		"KW_WUPL_ERR",
    		"KW_WUPL_FLS",
    		"KW_X",
    		"KW_XML_DTYP",
    		"KW_XML_E_EL",
    		"KW_XML_NNAM",
    		"KW_XML_NTYP",
    		"KW_XML_SCHP",
    		"KW_XML_S_ER",
    		"KW_XML_SNSP",
    		"KW_XPR2PDF",
    		"KW_X_DOC",
    		"KW_X_NODE",
    		"KW_X_OF",
    		"KW_YEAR",
    		"KW_YEAR_OFF",
    		"KW_YES_NO",
    		"KW_YES_NO_C",
    		"KW_Y",
    		"KW_Y_OF",
    		"BEGIN_FWD_EXTENSION",
    		"KW_TIMER",
    		"KW_CALLBACK",
    		"KW_ENABLED",
    		"KW_CEASE",
    		"CREATE_TIMER",
    		"CREATE_GENERIC_OCX",
    		"KW_CONNTYPE",
    		"KW_ACTIVATE",
    		"KW_ADD_TO_A",
    		"KW_ADD_CC_A",
    		"KW_ADD_BCCA",
    		"KW_AS_THRD",
    		"KW_ATT_FILE",
    		"KW_ATT_URL",
    		"KW_CHECK_BO",
    		"KW_CLR_ATTL",
    		"KW_CLR_BCCL",
    		"KW_CLR_CC_L",
    		"KW_CLR_EMBL",
    		"KW_CLR_TO_L",
    		"KW_EMB_FILE",
    		"KW_EMB_URL",
    		"KW_GET_ATTL",
    		"KW_GET_BCCL",
    		"KW_GET_CC_L",
    		"KW_GET_EMBL",
    		"KW_GET_TO_L",
    		"KW_SMTP_EML",
    		"KW_SMTPFROM",
    		"KW_SMTPHOST",
    		"KW_SMTPHTML",
    		"KW_SMTPPORT",
    		"KW_SMTPREPL",
    		"KW_SMTPSUBJ",
    		"KW_SMTPTEXT",
    		"KW_SMTPUSER",
    		"KW_SMTP_PW",
    		"KW_SMTP_VAL",
    		"CREATE_SMTP_EMAIL",
    		"KW_REPORT",
    		"KW_RPT_ADDC",
    		"KW_RPT_DSGN",
    		"KW_RPT_CAP",
    		"KW_RPT_CSV",
    		"KW_RPT_DOCX",
    		"KW_RPT_GSRC",
    		"KW_RPT_GSRR",
    		"KW_RPT_HTML",
    		"KW_RPT_ICSV",
    		"KW_RPT_PDF",
    		"KW_RPT_RTF",
    		"KW_RPT_SRC",
    		"KW_RPT_XLS",
    		"KW_RPT_XLSX",
    		"KW_SET_R_P",
    		"CREATE_REPORT",
    		"KW_TREEVIEW",
    		"KW_ADD_C_N",
    		"KW_ADD_F_N",
    		"KW_ADD_L_N",
    		"KW_ADD_N_N",
    		"KW_BUILD_TR",
    		"KW_CLR_ALL",
    		"KW_CLR_NIML",
    		"KW_CLR_NODS",
    		"KW_COL_NODE",
    		"KW_COLL_A_E",
    		"KW_COLL_ALL",
    		"KW_CRE_IMAG",
    		"KW_CREAT_SN",
    		"KW_CRT_MIMG",
    		"KW_DCLK_EXP",
    		"KW_DD_OTREE",
    		"KW_DRAGDROP",
    		"KW_ENS_N_V",
    		"KW_EXP_N_IC",
    		"KW_EXP_NODE",
    		"KW_EXP_ON_E",
    		"KW_EXP_SCLK",
    		"KW_EXPA_ALL",
    		"KW_FIND_NOD",
    		"KW_FIRST_N",
    		"KW_FNT_BOLD",
    		"KW_FNT_ITAL",
    		"KW_FNT_NAME",
    		"KW_FNT_SIZE",
    		"KW_FNT_UNDL",
    		"KW_FOC_NKEY",
    		"KW_FOC_NODE",
    		"KW_FS_NKEY",
    		"KW_FS_NODE",
    		"KW_FV_NODE",
    		"KW_GET_FCN",
    		"KW_GET_N_AT",
    		"KW_GET_N_BG",
    		"KW_GET_N_FG",
    		"KW_GET_N_HC",
    		"KW_GET_N_N",
    		"KW_GET_NLEV",
    		"KW_GET_NSN",
    		"KW_GET_NTXT",
    		"KW_GET_NVV",
    		"KW_GET_PARN",
    		"KW_GET_PSN",
    		"KW_GET_SNC",
    		"KW_GET_TNOD",
    		"KW_HIT_TEST",
    		"KW_HIT_TFWD",
    		"KW_INDENT",
    		"KW_IS_MSEL",
    		"KW_IS_N_EXP",
    		"KW_NEW_LBL",
    		"KW_N_AEDIT",
    		"KW_N_BEDIT",
    		"KW_N_CLICK",
    		"KW_N_COLED",
    		"KW_N_COLING",
    		"KW_N_EXPED",
    		"KW_N_EXPING",
    		"KW_N_HEIGHT",
    		"KW_N_KEY_ID",
    		"KW_NODE_BLD",
    		"KW_NODE_CNT",
    		"KW_NODE_EXP",
    		"KW_NODE_ICO",
    		"KW_NODE_ID",
    		"KW_NODE_IDX",
    		"KW_NODE_KEY",
    		"KW_NODE_PAR",
    		"KW_NODE_TXT",
    		"KW_NODES",
    		"KW_REM_NOCO",
    		"KW_REM_NODE",
    		"KW_SCR_NTOP",
    		"KW_SCR_VERT",
    		"KW_SCR_WLNS",
    		"KW_SEL_NID",
    		"KW_SEL_NKEY",
    		"KW_SEL_NODE",
    		"KW_SEL_SFVN",
    		"KW_SET_MSEL",
    		"KW_SET_N_BG",
    		"KW_SET_N_FG",
    		"KW_SET_N_HC",
    		"KW_SET_NTXT",
    		"KW_SET_SNC",
    		"KW_SET_TN_I",
    		"KW_SHOW_BUT",
    		"KW_TEXTEDIT",
    		"KW_TNOD_VAL",
    		"KW_TREE_R_H",
    		"KW_TRIG_NOD",
    		"KW_TRIG_COL",
    		"KW_SCR_NODC",
    		"KW_V_N_CNT",
    		"KW_V_R_CNT",
    		"KW_TABSET",
    		"KW_ADD_TAB",
    		"KW_TABS",
    		"KW_CLR_TABS",
    		"KW_CURR_TAB",
    		"KW_TAB_IDX",
    		"KW_TAB_ML",
    		"KW_TAB_SHOW",
    		"KW_SET_F_D",
    		"KW_FOC_ASEL",
    		"KW_HTML_BWS",
    		"KW_CTX_PATH",
    		"KW_OPENHTML",
    		"KW_OPENPAGE",
    		"KW_POSTMSG",
    		"KW_PRINT",
    		"KW_RES_BASE",
    		"KW_TREELIST",
    		"KW_AST_ACTI",
    		"KW_CRT_COL",
    		"KW_COL_SRT",
    		"KW_C_T_V_N",
    		"KW_C_NOD_D",
    		"KW_DATE_SEP",
    		"KW_DEC_SEP",
    		"KW_EVT_ACTI",
    		"KW_FIX_C_L",
    		"KW_G_C_BGCO",
    		"KW_G_C_FGCO",
    		"KW_G_COL_P",
    		"KW_G_COL_W",
    		"KW_GET_C_S",
    		"KW_IS_C_VIS",
    		"KW_M_D_I_P",
    		"KW_M_U_I_P",
    		"KW_RESORT",
    		"KW_S_C_BGCO",
    		"KW_S_C_FGCO",
    		"KW_S_COL_C",
    		"KW_S_COL_W",
    		"KW_SET_C_IC",
    		"KW_SET_C_S",
    		"KW_SET_C_VI",
    		"KW_SHOW_HDR",
    		"KW_SHR_D_F",
    		"KW_SOR_C_C",
    		"KW_SOR_COLS",
    		"KW_THO_SEP",
    		"KW_AT_W_BRW",
    		"KW_UPLOAD",
    		"KW_H_SCRL_P",
    		"KW_V_SCRL_P",
    		"KW_IMG_LIST",
    		"KW_IL_IMG",
    		"KW_IL_BGCOL",
    		"KW_IL_HEIGH",
    		"KW_IL_WIDTH",
    		"KW_IL_LIST",
    		"KW_IL_MASK",
    		"KW_IL_OVER",
    		"KW_IL_UMASK",
    		"KW_ADD_IMG",
    		"KW_MS_CLICK",
    		"KW_MS_DBCLK",
    		"KW_MS_DOWN",
    		"KW_MS_MOVE",
    		"KW_MS_UP",
    		"KW_OCX_MBTN",
    		"KW_OCX_MSHT",
    		"KW_OCX_MSX",
    		"KW_OCX_MSY",
    		"KW_OLE_DGMD",
    		"KW_OLE_DRMD",
    		"KW_OLE_DRAG",
    		"KW_OLE_EFFE",
    		"KW_OLE_STAT",
    		"KW_OLE_DEFC",
    		"KW_OLE_DATF",
    		"KW_OLE_AEFF",
    		"KW_OLE_CDRG",
    		"KW_OLE_DD",
    		"KW_OLE_DGOV",
    		"KW_OLE_GIVF",
    		"KW_OLE_SETD",
    		"KW_OLE_STDG",
    		"KW_OLE_X",
    		"KW_OLE_Y",
    		"KW_DRAG_NOD",
    		"KW_DRAG_OVR",
    		"KW_PROG_BAR",
    		"KW_PB_APPEA",
    		"KW_PB_ENABL",
    		"KW_PB_BRSTY",
    		"KW_PB_ORIEN",
    		"KW_PB_MIN",
    		"KW_PB_MAX",
    		"KW_PB_VALUE",
    		"KW_PB_SCROL",
    		"KW_COM_DATA",
    		"KW_CALBGCLR",
    		"KW_CALFGCLR",
    		"KW_CALTITBG",
    		"KW_CALTITFG",
    		"KW_CALTRLFG",
    		"KW_CALENDAR",
    		"KW_CALCUFMT",
    		"KW_CALFMTST",
    		"KW_CALUPDWN",
    		"KW_CALVALUE",
    		"KW_CLEA_TAB",
    		"KW_CLEA_WIN",
    		"KW_GET_SIMG",
    		"KW_KPAD_HOT",
    		"KW_KPAD_CLE",
    		"KW_KPAD_QRY",
    		"KW_LCD_REFR",
    		"KW_LCD_SWIN",
    		"KW_LCD_WSTR",
    		"KW_NUM_PNTS",
    		"KW_SET_IMGF",
    		"KW_SET_PENW",
    		"KW_SET_IMGH",
    		"KW_SET_IMGW",
    		"KW_SET_JMOD",
    		"KW_SET_JSTX",
    		"KW_SET_JSTY",
    		"KW_SET_CPTM",
    		"KW_SET_SWIN",
    		"KW_SET_TSTA",
    		"KW_SET_TBME",
    		"KW_TAB_MOD",
    		"KW_BTN_LIST",
    		"KW_BL_CURGR",
    		"KW_BL_CGR_K",
    		"KW_BL_BTNFN",
    		"KW_BL_ITMFN",
    		"KW_BL_GCLR",
    		"KW_BL_GADD",
    		"KW_BL_GIFP",
    		"KW_BL_IADD",
    		"KW_BL_G_KEY",
    		"KW_BL_GIKEY",
    		"KW_BL_NGR",
    		"KW_BL_NGRI",
    		"KW_BL_G_GR",
    		"KW_BL_G_GRI",
    		"KW_CAPFNT",
    		"KW_CAPFNTSZ",
    		"KW_SPRSHEET",
    		"KW_FLTR_MAP",
    		"KW_SORT_MAP",
    		"KW_DIS_STRP",
    		"KW_DIS_CEDT",
    		"KW_UNIQ_KEY",
    		"END_FWD_EXTENSION",
    		"END_UNRESERVED",
    		"BEGIN_CALLGRAPH",
    		"FILE_RESOURCE",
    		"AST_NODE",
    		"IPC_RESOURCE",
    		"NATIVE_PROGRAM_RESOURCE",
    		"UNKNOWN_RESOURCE",
    		"INCLUDES",
    		"RUN_FILENAME",
    		"RUN_FILENAME_ON_SERVER",
    		"RUN_INT_PROC",
    		"RUN_INT_PROC_ON_SERVER",
    		"RUN_VALUE",
    		"RUN_VALUE_ON_SERVER",
    		"RUN_PORT_TYPE_ON_SERVER",
    		"RUN_PORT_TYPE_VALUE_ON_SERVER",
    		"RUN_LIBRARY_REF",
    		"RUN_LIBRARY_REF_ON_SERVER",
    		"FUNCTION_CALL",
    		"AMBIGUOUS",
    		"MISSING",
    		"PROCEDURE_FILE",
    		"INCLUDE_FILE",
    		"SCHEMA_FILE",
    		"EXTERNAL_PROCEDURE",
    		"INTERNAL_PROCEDURE",
    		"LIBRARY_PROCEDURE",
    		"PORT_TYPE",
    		"SHARED_LIBRARY",
    		"NATIVE_API",
    		"NATIVE_PROCESS",
    		"CHILD_PROCESS",
    		"NETWORK_CONNECTION",
    		"COM_OBJECT",
    		"DDE_SERVER",
    		"OCX_CONTROL",
    		"DEFINE_PROPERTY_GET",
    		"DEFINE_PROPERTY_SET",
    		"MORE",
    		"END_CALLGRAPH",
    		"UNKNOWN_TOKEN",
    		"AT",
    		"EQUALS",
    		"LBRACKET",
    		"RBRACKET",
    		"COLON",
    		"COMMA",
    		"LPARENS",
    		"RPARENS",
    		"STRING",
    		"MULTIPLY",
    		"KW_NOT_ACTV",
    		"CARET",
    		"MULT_ASSIGN",
    		"PLUS_ASSIGN",
    		"MINUS_ASSIGN",
    		"DIV_ASSIGN",
    		"GT",
    		"LT",
    		"DIVIDE",
    		"UNKNOWN_VAL",
    		"NUM_LITERAL",
    		"SYMBOL",
    		"KW_LIKE_SEQ",
    		"NOT_EQ",
    		"GTE",
    		"LTE",
    		"DB_REF_NON_STATIC",
    		"WS",
    		"TILDE",
    		"COMMENT",
    		"HEX_DIGIT",
    		"VALID_SYM_CHAR",
    		"SSTRING",
    		"DSTRING",
    		"XSTRING",
    		"RSTRING",
    		"STR_OPTIONS",
    		"LETTER",
    		"DIGIT",
    		"SYM_CHAR",
    		"CMT_OPEN",
    		"CMT_CLOSE",
    		"SLASH_SLASH",
    		"MONTH_TRASH_MODE",
    		"YEAR_TRASH_MODE",
    		"JUNK"
    	};

    	}