ptc.js

/* parser generated by jison 0.6.1-215 */

/*
 * Returns a Parser object of the following structure:
 *
 *  Parser: {
 *    yy: {}     The so-called "shared state" or rather the *source* of it;
 *               the real "shared state" `yy` passed around to
 *               the rule actions, etc. is a derivative/copy of this one,
 *               not a direct reference!
 *  }
 *
 *  Parser.prototype: {
 *    yy: {},
 *    EOF: 1,
 *    TERROR: 2,
 *
 *    trace: function(errorMessage, ...),
 *
 *    JisonParserError: function(msg, hash),
 *
 *    quoteName: function(name),
 *               Helper function which can be overridden by user code later on: put suitable
 *               quotes around literal IDs in a description string.
 *
 *    originalQuoteName: function(name),
 *               The basic quoteName handler provided by JISON.
 *               `cleanupAfterParse()` will clean up and reset `quoteName()` to reference this function
 *               at the end of the `parse()`.
 *
 *    describeSymbol: function(symbol),
 *               Return a more-or-less human-readable description of the given symbol, when
 *               available, or the symbol itself, serving as its own 'description' for lack
 *               of something better to serve up.
 *
 *               Return NULL when the symbol is unknown to the parser.
 *
 *    symbols_: {associative list: name ==> number},
 *    terminals_: {associative list: number ==> name},
 *    nonterminals: {associative list: rule-name ==> {associative list: number ==> rule-alt}},
 *    terminal_descriptions_: (if there are any) {associative list: number ==> description},
 *    productions_: [...],
 *
 *    performAction: function parser__performAction(yytext, yyleng, yylineno, yyloc, yystate, yysp, yyvstack, yylstack, yystack, yysstack),
 *
 *               The function parameters and `this` have the following value/meaning:
 *               - `this`    : reference to the `yyval` internal object, which has members (`$` and `_$`)
 *                             to store/reference the rule value `$$` and location info `@$`.
 *
 *                 One important thing to note about `this` a.k.a. `yyval`: every *reduce* action gets
 *                 to see the same object via the `this` reference, i.e. if you wish to carry custom
 *                 data from one reduce action through to the next within a single parse run, then you
 *                 may get nasty and use `yyval` a.k.a. `this` for storing you own semi-permanent data.
 *
 *                 `this.yy` is a direct reference to the `yy` shared state object.
 *
 *                 `%parse-param`-specified additional `parse()` arguments have been added to this `yy`
 *                 object at `parse()` start and are therefore available to the action code via the
 *                 same named `yy.xxxx` attributes (where `xxxx` represents a identifier name from
 *                 the %parse-param` list.
 *
 *               - `yytext`  : reference to the lexer value which belongs to the last lexer token used
 *                             to match this rule. This is *not* the look-ahead token, but the last token
 *                             that's actually part of this rule.
 *
 *                 Formulated another way, `yytext` is the value of the token immediately preceeding
 *                 the current look-ahead token.
 *                 Caveats apply for rules which don't require look-ahead, such as epsilon rules.
 *
 *               - `yyleng`  : ditto as `yytext`, only now for the lexer.yyleng value.
 *
 *               - `yylineno`: ditto as `yytext`, only now for the lexer.yylineno value.
 *
 *               - `yyloc`   : ditto as `yytext`, only now for the lexer.yylloc lexer token location info.
 *
 *                               WARNING: since jison 0.4.18-186 this entry may be NULL/UNDEFINED instead
 *                               of an empty object when no suitable location info can be provided.
 *
 *               - `yystate` : the current parser state number, used internally for dispatching and
 *                               executing the action code chunk matching the rule currently being reduced.
 *
 *               - `yysp`    : the current state stack position (a.k.a. 'stack pointer')
 *
 *                 This one comes in handy when you are going to do advanced things to the parser
 *                 stacks, all of which are accessible from your action code (see the next entries below).
 *
 *                 Also note that you can access this and other stack index values using the new double-hash
 *                 syntax, i.e. `##$ === ##0 === yysp`, while `##1` is the stack index for all things
 *                 related to the first rule term, just like you have `$1`, `@1` and `#1`.
 *                 This is made available to write very advanced grammar action rules, e.g. when you want
 *                 to investigate the parse state stack in your action code, which would, for example,
 *                 be relevant when you wish to implement error diagnostics and reporting schemes similar
 *                 to the work described here:
 *
 *                 + Pottier, F., 2016. Reachability and error diagnosis in LR(1) automata.
 *                   In Journées Francophones des Languages Applicatifs.
 *
 *                 + Jeffery, C.L., 2003. Generating LR syntax error messages from examples.
 *                   ACM Transactions on Programming Languages and Systems (TOPLAS), 25(5), pp.631–640.
 *
 *               - `yyrulelength`: the current rule's term count, i.e. the number of entries occupied on the stack.
 *
 *                 This one comes in handy when you are going to do advanced things to the parser
 *                 stacks, all of which are accessible from your action code (see the next entries below).
 *
 *               - `yyvstack`: reference to the parser value stack. Also accessed via the `$1` etc.
 *                             constructs.
 *
 *               - `yylstack`: reference to the parser token location stack. Also accessed via
 *                             the `@1` etc. constructs.
 *
 *                             WARNING: since jison 0.4.18-186 this array MAY contain slots which are
 *                             UNDEFINED rather than an empty (location) object, when the lexer/parser
 *                             action code did not provide a suitable location info object when such a
 *                             slot was filled!
 *
 *               - `yystack` : reference to the parser token id stack. Also accessed via the
 *                             `#1` etc. constructs.
 *
 *                 Note: this is a bit of a **white lie** as we can statically decode any `#n` reference to
 *                 its numeric token id value, hence that code wouldn't need the `yystack` but *you* might
 *                 want access this array for your own purposes, such as error analysis as mentioned above!
 *
 *                 Note that this stack stores the current stack of *tokens*, that is the sequence of
 *                 already parsed=reduced *nonterminals* (tokens representing rules) and *terminals*
 *                 (lexer tokens *shifted* onto the stack until the rule they belong to is found and
 *                 *reduced*.
 *
 *               - `yysstack`: reference to the parser state stack. This one carries the internal parser
 *                             *states* such as the one in `yystate`, which are used to represent
 *                             the parser state machine in the *parse table*. *Very* *internal* stuff,
 *                             what can I say? If you access this one, you're clearly doing wicked things
 *
 *               - `...`     : the extra arguments you specified in the `%parse-param` statement in your
 *                             grammar definition file.
 *
 *    table: [...],
 *               State transition table
 *               ----------------------
 *
 *               index levels are:
 *               - `state`  --> hash table
 *               - `symbol` --> action (number or array)
 *
 *                 If the `action` is an array, these are the elements' meaning:
 *                 - index [0]: 1 = shift, 2 = reduce, 3 = accept
 *                 - index [1]: GOTO `state`
 *
 *                 If the `action` is a number, it is the GOTO `state`
 *
 *    defaultActions: {...},
 *
 *    parseError: function(str, hash, ExceptionClass),
 *    yyError: function(str, ...),
 *    yyRecovering: function(),
 *    yyErrOk: function(),
 *    yyClearIn: function(),
 *
 *    constructParseErrorInfo: function(error_message, exception_object, expected_token_set, is_recoverable),
 *               Helper function **which will be set up during the first invocation of the `parse()` method**.
 *               Produces a new errorInfo 'hash object' which can be passed into `parseError()`.
 *               See it's use in this parser kernel in many places; example usage:
 *
 *                   var infoObj = parser.constructParseErrorInfo('fail!', null,
 *                                     parser.collect_expected_token_set(state), true);
 *                   var retVal = parser.parseError(infoObj.errStr, infoObj, parser.JisonParserError);
 *
 *    originalParseError: function(str, hash, ExceptionClass),
 *               The basic `parseError` handler provided by JISON.
 *               `cleanupAfterParse()` will clean up and reset `parseError()` to reference this function
 *               at the end of the `parse()`.
 *
 *    options: { ... parser %options ... },
 *
 *    parse: function(input[, args...]),
 *               Parse the given `input` and return the parsed value (or `true` when none was provided by
 *               the root action, in which case the parser is acting as a *matcher*).
 *               You MAY use the additional `args...` parameters as per `%parse-param` spec of this grammar:
 *               these extra `args...` are added verbatim to the `yy` object reference as member variables.
 *
 *               WARNING:
 *               Parser's additional `args...` parameters (via `%parse-param`) MAY conflict with
 *               any attributes already added to `yy` by the jison run-time;
 *               when such a collision is detected an exception is thrown to prevent the generated run-time
 *               from silently accepting this confusing and potentially hazardous situation!
 *
 *               The lexer MAY add its own set of additional parameters (via the `%parse-param` line in
 *               the lexer section of the grammar spec): these will be inserted in the `yy` shared state
 *               object and any collision with those will be reported by the lexer via a thrown exception.
 *
 *    cleanupAfterParse: function(resultValue, invoke_post_methods, do_not_nuke_errorinfos),
 *               Helper function **which will be set up during the first invocation of the `parse()` method**.
 *               This helper API is invoked at the end of the `parse()` call, unless an exception was thrown
 *               and `%options no-try-catch` has been defined for this grammar: in that case this helper MAY
 *               be invoked by calling user code to ensure the `post_parse` callbacks are invoked and
 *               the internal parser gets properly garbage collected under these particular circumstances.
 *
 *    yyMergeLocationInfo: function(first_index, last_index, first_yylloc, last_yylloc, dont_look_back),
 *               Helper function **which will be set up during the first invocation of the `parse()` method**.
 *               This helper API can be invoked to calculate a spanning `yylloc` location info object.
 *
 *               Note: %epsilon rules MAY specify no `first_index` and `first_yylloc`, in which case
 *               this function will attempt to obtain a suitable location marker by inspecting the location stack
 *               backwards.
 *
 *               For more info see the documentation comment further below, immediately above this function's
 *               implementation.
 *
 *    lexer: {
 *        yy: {...},           A reference to the so-called "shared state" `yy` once
 *                             received via a call to the `.setInput(input, yy)` lexer API.
 *        EOF: 1,
 *        ERROR: 2,
 *        JisonLexerError: function(msg, hash),
 *        parseError: function(str, hash, ExceptionClass),
 *        setInput: function(input, [yy]),
 *        input: function(),
 *        unput: function(str),
 *        more: function(),
 *        reject: function(),
 *        less: function(n),
 *        pastInput: function(n),
 *        upcomingInput: function(n),
 *        showPosition: function(),
 *        test_match: function(regex_match_array, rule_index, ...),
 *        next: function(...),
 *        lex: function(...),
 *        begin: function(condition),
 *        pushState: function(condition),
 *        popState: function(),
 *        topState: function(),
 *        _currentRules: function(),
 *        stateStackSize: function(),
 *        cleanupAfterLex: function()
 *
 *        options: { ... lexer %options ... },
 *
 *        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START, ...),
 *        rules: [...],
 *        conditions: {associative list: name ==> set},
 *    }
 *  }
 *
 *
 *  token location info (@$, _$, etc.): {
 *    first_line: n,
 *    last_line: n,
 *    first_column: n,
 *    last_column: n,
 *    range: [start_number, end_number]
 *               (where the numbers are indexes into the input string, zero-based)
 *  }
 *
 * ---
 *
 * The `parseError` function receives a 'hash' object with these members for lexer and
 * parser errors:
 *
 *  {
 *    text:        (matched text)
 *    token:       (the produced terminal token, if any)
 *    token_id:    (the produced terminal token numeric ID, if any)
 *    line:        (yylineno)
 *    loc:         (yylloc)
 *  }
 *
 * parser (grammar) errors will also provide these additional members:
 *
 *  {
 *    expected:    (array describing the set of expected tokens;
 *                  may be UNDEFINED when we cannot easily produce such a set)
 *    state:       (integer (or array when the table includes grammar collisions);
 *                  represents the current internal state of the parser kernel.
 *                  can, for example, be used to pass to the `collect_expected_token_set()`
 *                  API to obtain the expected token set)
 *    action:      (integer; represents the current internal action which will be executed)
 *    new_state:   (integer; represents the next/planned internal state, once the current
 *                  action has executed)
 *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule
 *                  available for this particular error)
 *    state_stack: (array: the current parser LALR/LR internal state stack; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    value_stack: (array: the current parser LALR/LR internal `$$` value stack; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    location_stack: (array: the current parser LALR/LR internal location stack; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    yy:          (object: the current parser internal "shared state" `yy`
 *                  as is also available in the rule actions; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    lexer:       (reference to the current lexer instance used by the parser)
 *    parser:      (reference to the current parser instance)
 *  }
 *
 * while `this` will reference the current parser instance.
 *
 * When `parseError` is invoked by the lexer, `this` will still reference the related *parser*
 * instance, while these additional `hash` fields will also be provided:
 *
 *  {
 *    lexer:       (reference to the current lexer instance which reported the error)
 *  }
 *
 * When `parseError` is invoked by the parser due to a **JavaScript exception** being fired
 * from either the parser or lexer, `this` will still reference the related *parser*
 * instance, while these additional `hash` fields will also be provided:
 *
 *  {
 *    exception:   (reference to the exception thrown)
 *  }
 *
 * Please do note that in the latter situation, the `expected` field will be omitted as
 * this type of failure is assumed not to be due to *parse errors* but rather due to user
 * action code in either parser or lexer failing unexpectedly.
 *
 * ---
 *
 * You can specify parser options by setting / modifying the `.yy` object of your Parser instance.
 * These options are available:
 *
 * ### options which are global for all parser instances
 *
 *  Parser.pre_parse: function(yy)
 *                 optional: you can specify a pre_parse() function in the chunk following
 *                 the grammar, i.e. after the last `%%`.
 *  Parser.post_parse: function(yy, retval, parseInfo) { return retval; }
 *                 optional: you can specify a post_parse() function in the chunk following
 *                 the grammar, i.e. after the last `%%`. When it does not return any value,
 *                 the parser will return the original `retval`.
 *
 * ### options which can be set up per parser instance
 *
 *  yy: {
 *      pre_parse:  function(yy)
 *                 optional: is invoked before the parse cycle starts (and before the first
 *                 invocation of `lex()`) but immediately after the invocation of
 *                 `parser.pre_parse()`).
 *      post_parse: function(yy, retval, parseInfo) { return retval; }
 *                 optional: is invoked when the parse terminates due to success ('accept')
 *                 or failure (even when exceptions are thrown).
 *                 `retval` contains the return value to be produced by `Parser.parse()`;
 *                 this function can override the return value by returning another.
 *                 When it does not return any value, the parser will return the original
 *                 `retval`.
 *                 This function is invoked immediately before `parser.post_parse()`.
 *
 *      parseError: function(str, hash, ExceptionClass)
 *                 optional: overrides the default `parseError` function.
 *      quoteName: function(name),
 *                 optional: overrides the default `quoteName` function.
 *  }
 *
 *  parser.lexer.options: {
 *      pre_lex:  function()
 *                 optional: is invoked before the lexer is invoked to produce another token.
 *                 `this` refers to the Lexer object.
 *      post_lex: function(token) { return token; }
 *                 optional: is invoked when the lexer has produced a token `token`;
 *                 this function can override the returned token value by returning another.
 *                 When it does not return any (truthy) value, the lexer will return
 *                 the original `token`.
 *                 `this` refers to the Lexer object.
 *
 *      ranges: boolean
 *                 optional: `true` ==> token location info will include a .range[] member.
 *      flex: boolean
 *                 optional: `true` ==> flex-like lexing behaviour where the rules are tested
 *                 exhaustively to find the longest match.
 *      backtrack_lexer: boolean
 *                 optional: `true` ==> lexer regexes are tested in order and for invoked;
 *                 the lexer terminates the scan when a token is returned by the action code.
 *      xregexp: boolean
 *                 optional: `true` ==> lexer rule regexes are "extended regex format" requiring the
 *                 `XRegExp` library. When this `%option` has not been specified at compile time, all lexer
 *                 rule regexes have been written as standard JavaScript RegExp expressions.
 *  }
 */

        
    
            var ptc = (function () {


// See also:
// http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508
// but we keep the prototype.constructor and prototype.name assignment lines too for compatibility
// with userland code which might access the derived class in a 'classic' way.
function JisonParserError(msg, hash) {
    Object.defineProperty(this, 'name', {
        enumerable: false,
        writable: false,
        value: 'JisonParserError'
    });

    if (msg == null) msg = '???';

    Object.defineProperty(this, 'message', {
        enumerable: false,
        writable: true,
        value: msg
    });

    this.hash = hash;

    var stacktrace;
    if (hash && hash.exception instanceof Error) {
        var ex2 = hash.exception;
        this.message = ex2.message || msg;
        stacktrace = ex2.stack;
    }
    if (!stacktrace) {
        if (Error.hasOwnProperty('captureStackTrace')) {        // V8/Chrome engine
            Error.captureStackTrace(this, this.constructor);
        } else {
            stacktrace = (new Error(msg)).stack;
        }
    }
    if (stacktrace) {
        Object.defineProperty(this, 'stack', {
            enumerable: false,
            writable: false,
            value: stacktrace
        });
    }
}

if (typeof Object.setPrototypeOf === 'function') {
    Object.setPrototypeOf(JisonParserError.prototype, Error.prototype);
} else {
    JisonParserError.prototype = Object.create(Error.prototype);
}
JisonParserError.prototype.constructor = JisonParserError;
JisonParserError.prototype.name = 'JisonParserError';




        // helper: reconstruct the productions[] table
        function bp(s) {
            var rv = [];
            var p = s.pop;
            var r = s.rule;
            for (var i = 0, l = p.length; i < l; i++) {
                rv.push([
                    p[i],
                    r[i]
                ]);
            }
            return rv;
        }
    


        // helper: reconstruct the defaultActions[] table
        function bda(s) {
            var rv = {};
            var d = s.idx;
            var g = s.goto;
            for (var i = 0, l = d.length; i < l; i++) {
                var j = d[i];
                rv[j] = g[i];
            }
            return rv;
        }
    


        // helper: reconstruct the 'goto' table
        function bt(s) {
            var rv = [];
            var d = s.len;
            var y = s.symbol;
            var t = s.type;
            var a = s.state;
            var m = s.mode;
            var g = s.goto;
            for (var i = 0, l = d.length; i < l; i++) {
                var n = d[i];
                var q = {};
                for (var j = 0; j < n; j++) {
                    var z = y.shift();
                    switch (t.shift()) {
                    case 2:
                        q[z] = [
                            m.shift(),
                            g.shift()
                        ];
                        break;

                    case 0:
                        q[z] = a.shift();
                        break;

                    default:
                        // type === 1: accept
                        q[z] = [
                            3
                        ];
                    }
                }
                rv.push(q);
            }
            return rv;
        }
    


        // helper: runlength encoding with increment step: code, length: step (default step = 0)
        // `this` references an array
        function s(c, l, a) {
            a = a || 0;
            for (var i = 0; i < l; i++) {
                this.push(c);
                c += a;
            }
        }

        // helper: duplicate sequence from *relative* offset and length.
        // `this` references an array
        function c(i, l) {
            i = this.length - i;
            for (l += i; i < l; i++) {
                this.push(this[i]);
            }
        }

        // helper: unpack an array using helpers and data, all passed in an array argument 'a'.
        function u(a) {
            var rv = [];
            for (var i = 0, l = a.length; i < l; i++) {
                var e = a[i];
                // Is this entry a helper function?
                if (typeof e === 'function') {
                    i++;
                    e.apply(rv, a[i]);
                } else {
                    rv.push(e);
                }
            }
            return rv;
        }
    

var parser = {
    // Code Generator Information Report
    // ---------------------------------
    //
    // Options:
    //
    //   default action mode: ............. ["classic","merge"]
    //   test-compile action mode: ........ "parser:*,lexer:*"
    //   try..catch: ...................... true
    //   default resolve on conflict: ..... true
    //   on-demand look-ahead: ............ false
    //   error recovery token skip maximum: 3
    //   yyerror in parse actions is: ..... NOT recoverable,
    //   yyerror in lexer actions and other non-fatal lexer are:
    //   .................................. NOT recoverable,
    //   debug grammar/output: ............ false
    //   has partial LR conflict upgrade:   true
    //   rudimentary token-stack support:   false
    //   parser table compression mode: ... 2
    //   export debug tables: ............. false
    //   export *all* tables: ............. false
    //   module type: ..................... commonjs
    //   parser engine type: .............. lalr
    //   output main() in the module: ..... true
    //   has user-specified main(): ....... false
    //   has user-specified require()/import modules for main():
    //   .................................. false
    //   number of expected conflicts: .... 0
    //
    //
    // Parser Analysis flags:
    //
    //   no significant actions (parser is a language matcher only):
    //   .................................. false
    //   uses yyleng: ..................... false
    //   uses yylineno: ................... false
    //   uses yytext: ..................... false
    //   uses yylloc: ..................... false
    //   uses ParseError API: ............. false
    //   uses YYERROR: .................... false
    //   uses YYRECOVERING: ............... false
    //   uses YYERROK: .................... false
    //   uses YYCLEARIN: .................. false
    //   tracks rule values: .............. true
    //   assigns rule values: ............. true
    //   uses location tracking: .......... false
    //   assigns location: ................ false
    //   uses yystack: .................... false
    //   uses yysstack: ................... false
    //   uses yysp: ....................... true
    //   uses yyrulelength: ............... false
    //   uses yyMergeLocationInfo API: .... false
    //   has error recovery: .............. true
    //   has error reporting: ............. false
    //
    // --------- END OF REPORT -----------

trace: function no_op_trace() { },
JisonParserError: JisonParserError,
yy: {},
options: {
  type: "lalr",
  hasPartialLrUpgradeOnConflict: true,
  errorRecoveryTokenDiscardCount: 3
},
symbols_: {
  "!": 19,
  "!=": 195,
  "$accept": 0,
  "$end": 1,
  "%": 16,
  "(": 4,
  ")": 5,
  "*": 14,
  "+": 13,
  ",": 8,
  "-": 12,
  "/": 15,
  ":": 3,
  ";": 11,
  "<": 18,
  "<=": 197,
  "=": 9,
  "==": 194,
  ">": 17,
  ">=": 196,
  "?": 10,
  "ABS": 128,
  "ACLS": 56,
  "AND": 191,
  "ASC": 141,
  "ATAN": 140,
  "BEEP": 112,
  "BGCHK": 150,
  "BGCLIP": 106,
  "BGCLR": 105,
  "BGCOPY": 111,
  "BGFILL": 109,
  "BGMCHK": 151,
  "BGMCLEAR": 118,
  "BGMGETV": 152,
  "BGMPLAY": 113,
  "BGMPRG": 120,
  "BGMSET": 116,
  "BGMSETD": 117,
  "BGMSETV": 119,
  "BGMSTOP": 114,
  "BGMVOL": 115,
  "BGOFS": 107,
  "BGPAGE": 104,
  "BGPUT": 108,
  "BGREAD": 110,
  "BREPEAT": 60,
  "BTRIG": 124,
  "BUTTON": 123,
  "CANCEL": 176,
  "CHKCHR": 122,
  "CHR$": 155,
  "CHRINIT": 88,
  "CHRREAD": 90,
  "CHRSET": 89,
  "CLEAR": 28,
  "CLS": 53,
  "COLINIT": 85,
  "COLOR": 54,
  "COLREAD": 87,
  "COLSET": 86,
  "COMMENT": 20,
  "COS": 138,
  "CSRX": 161,
  "CSRY": 162,
  "DATA": 49,
  "DATE$": 200,
  "DEG": 136,
  "DELETE": 67,
  "DIM": 27,
  "DTREAD": 52,
  "ELSE": 47,
  "END": 40,
  "ENDL": 21,
  "EOF": 1,
  "ERL": 166,
  "ERR": 165,
  "EXEC": 71,
  "EXP": 131,
  "FALSE": 175,
  "FLOOR": 126,
  "FOR": 41,
  "FREEMEM": 163,
  "FREEVAR": 178,
  "FUNCNO": 177,
  "GBOX": 78,
  "GCIRCLE": 80,
  "GCLS": 74,
  "GCOLOR": 73,
  "GCOPY": 83,
  "GDRAWMD": 82,
  "GFILL": 79,
  "GLINE": 77,
  "GOSUB": 37,
  "GOTO": 36,
  "GPAGE": 72,
  "GPAINT": 76,
  "GPRIO": 81,
  "GPSET": 75,
  "GPUTCHR": 84,
  "GSPOIT": 144,
  "HEX$": 156,
  "ICONCHK": 125,
  "ICONCLR": 64,
  "ICONPAGE": 186,
  "ICONPUSE": 185,
  "ICONSET": 63,
  "IF": 45,
  "INKEY$": 154,
  "INPUT": 58,
  "INSTR": 143,
  "KEY": 29,
  "KEYBOARD": 179,
  "LABEL": 23,
  "LEFT$": 159,
  "LEN": 142,
  "LINPUT": 59,
  "LOAD": 65,
  "LOCATE": 55,
  "LOG": 132,
  "MAINCNTH": 172,
  "MAINCNTL": 173,
  "MEM$": 203,
  "MID$": 157,
  "NEXT": 44,
  "NOT": 198,
  "NUMB10": 188,
  "NUMB16": 190,
  "NUMB2": 189,
  "NUMVAR": 24,
  "ON": 35,
  "OR": 192,
  "PACKAGE$": 202,
  "PI": 134,
  "PNLSTR": 62,
  "PNLTYPE": 61,
  "POW": 133,
  "PRGNAME$": 201,
  "PRINT": 26,
  "RAD": 135,
  "READ": 48,
  "RECVFILE": 69,
  "REM": 22,
  "RENAME": 68,
  "RESTORE": 50,
  "RESULT": 167,
  "RETURN": 38,
  "RIGHT$": 158,
  "RND": 127,
  "RSORT": 32,
  "SAVE": 66,
  "SENDFILE": 70,
  "SGN": 129,
  "SIN": 137,
  "SORT": 31,
  "SPANGLE": 98,
  "SPANIM": 97,
  "SPCHK": 145,
  "SPCHR": 96,
  "SPCLR": 93,
  "SPCOL": 102,
  "SPCOLVEC": 103,
  "SPGETV": 146,
  "SPHIT": 147,
  "SPHITNO": 180,
  "SPHITRC": 149,
  "SPHITSP": 148,
  "SPHITT": 183,
  "SPHITX": 181,
  "SPHITY": 182,
  "SPHOME": 94,
  "SPOFS": 95,
  "SPPAGE": 91,
  "SPREAD": 100,
  "SPSCALE": 99,
  "SPSET": 92,
  "SPSETV": 101,
  "SQR": 130,
  "STEP": 43,
  "STOP": 39,
  "STR$": 153,
  "STRING": 204,
  "STRVAR": 25,
  "SUBST$": 160,
  "SWAP": 30,
  "SYSBEEP": 187,
  "TABSTEP": 184,
  "TAN": 139,
  "TCHST": 170,
  "TCHTIME": 171,
  "TCHX": 168,
  "TCHY": 169,
  "THEN": 46,
  "TIME$": 199,
  "TMREAD": 51,
  "TO": 42,
  "TRUE": 174,
  "VAL": 121,
  "VERSION": 164,
  "VISIBLE": 57,
  "VSYNC": 33,
  "WAIT": 34,
  "XOR": 193,
  "[": 6,
  "]": 7,
  "abs": 320,
  "acls": 239,
  "asc": 333,
  "atan": 332,
  "beep": 295,
  "bgchk": 342,
  "bgclip": 289,
  "bgclr": 288,
  "bgcopy": 294,
  "bgfill": 292,
  "bgmchk": 343,
  "bgmclear": 301,
  "bgmgetv": 344,
  "bgmplay": 296,
  "bgmprg": 303,
  "bgmset": 299,
  "bgmsetd": 300,
  "bgmsetv": 302,
  "bgmstop": 297,
  "bgmvol": 298,
  "bgofs": 290,
  "bgpage": 287,
  "bgput": 291,
  "bgread": 293,
  "brepeat": 243,
  "btrig": 316,
  "button": 315,
  "chkchr": 314,
  "chr": 348,
  "chrinit": 271,
  "chrread": 273,
  "chrset": 272,
  "clear": 215,
  "cls": 236,
  "colinit": 268,
  "color": 237,
  "colread": 270,
  "colset": 269,
  "command": 212,
  "cos": 330,
  "data": 232,
  "dataargs": 305,
  "declare": 211,
  "deg": 328,
  "delete": 250,
  "dim": 214,
  "dimargs": 310,
  "dtread": 235,
  "end": 227,
  "error": 2,
  "exec": 254,
  "exp": 323,
  "floor": 318,
  "for": 228,
  "gbox": 261,
  "gcircle": 263,
  "gcls": 257,
  "gcolor": 256,
  "gcopy": 266,
  "gdrawmd": 265,
  "gfill": 262,
  "gline": 260,
  "gosub": 224,
  "goto": 223,
  "gpage": 255,
  "gpaint": 259,
  "gprio": 264,
  "gpset": 258,
  "gputchr": 267,
  "gspoit": 336,
  "hex": 349,
  "iconchk": 317,
  "iconclr": 247,
  "iconset": 246,
  "if": 230,
  "ifcommands": 307,
  "inkey": 347,
  "input": 241,
  "instr": 335,
  "key": 216,
  "label": 207,
  "labelacc": 208,
  "left": 352,
  "len": 334,
  "line": 206,
  "linput": 242,
  "load": 248,
  "locate": 238,
  "log": 324,
  "mid": 350,
  "mmllist": 304,
  "next": 229,
  "numarray": 209,
  "number": 356,
  "numberfunction": 312,
  "numvariable": 362,
  "on": 222,
  "onargs": 308,
  "pi": 326,
  "pnlstr": 245,
  "pnltype": 244,
  "pow": 325,
  "print": 213,
  "printargs": 311,
  "program": 205,
  "rad": 327,
  "read": 231,
  "readargs": 306,
  "readnumvar": 354,
  "readstrvar": 357,
  "recvfile": 252,
  "rename": 251,
  "restore": 233,
  "return": 225,
  "right": 351,
  "rnd": 319,
  "rsort": 219,
  "save": 249,
  "sendfile": 253,
  "sgn": 321,
  "sin": 329,
  "sort": 218,
  "sortargs": 309,
  "spangle": 281,
  "spanim": 280,
  "spchk": 337,
  "spchr": 279,
  "spclr": 276,
  "spcol": 285,
  "spcolvec": 286,
  "spgetv": 338,
  "sphit": 339,
  "sphitrc": 341,
  "sphitsp": 340,
  "sphome": 277,
  "spofs": 278,
  "sppage": 274,
  "spread": 283,
  "spscale": 282,
  "spset": 275,
  "spsetv": 284,
  "sqr": 322,
  "stop": 226,
  "str": 346,
  "strarray": 210,
  "string": 359,
  "stringfunction": 345,
  "strvariable": 361,
  "subst": 353,
  "swap": 217,
  "tan": 331,
  "tmread": 234,
  "val": 313,
  "variable": 360,
  "visible": 240,
  "vsync": 220,
  "wait": 221,
  "writenumvar": 355,
  "writestrvar": 358
},
terminals_: {
  1: "EOF",
  2: "error",
  3: ":",
  4: "(",
  5: ")",
  6: "[",
  7: "]",
  8: ",",
  9: "=",
  10: "?",
  11: ";",
  12: "-",
  13: "+",
  14: "*",
  15: "/",
  16: "%",
  17: ">",
  18: "<",
  19: "!",
  20: "COMMENT",
  21: "ENDL",
  22: "REM",
  23: "LABEL",
  24: "NUMVAR",
  25: "STRVAR",
  26: "PRINT",
  27: "DIM",
  28: "CLEAR",
  29: "KEY",
  30: "SWAP",
  31: "SORT",
  32: "RSORT",
  33: "VSYNC",
  34: "WAIT",
  35: "ON",
  36: "GOTO",
  37: "GOSUB",
  38: "RETURN",
  39: "STOP",
  40: "END",
  41: "FOR",
  42: "TO",
  43: "STEP",
  44: "NEXT",
  45: "IF",
  46: "THEN",
  47: "ELSE",
  48: "READ",
  49: "DATA",
  50: "RESTORE",
  51: "TMREAD",
  52: "DTREAD",
  53: "CLS",
  54: "COLOR",
  55: "LOCATE",
  56: "ACLS",
  57: "VISIBLE",
  58: "INPUT",
  59: "LINPUT",
  60: "BREPEAT",
  61: "PNLTYPE",
  62: "PNLSTR",
  63: "ICONSET",
  64: "ICONCLR",
  65: "LOAD",
  66: "SAVE",
  67: "DELETE",
  68: "RENAME",
  69: "RECVFILE",
  70: "SENDFILE",
  71: "EXEC",
  72: "GPAGE",
  73: "GCOLOR",
  74: "GCLS",
  75: "GPSET",
  76: "GPAINT",
  77: "GLINE",
  78: "GBOX",
  79: "GFILL",
  80: "GCIRCLE",
  81: "GPRIO",
  82: "GDRAWMD",
  83: "GCOPY",
  84: "GPUTCHR",
  85: "COLINIT",
  86: "COLSET",
  87: "COLREAD",
  88: "CHRINIT",
  89: "CHRSET",
  90: "CHRREAD",
  91: "SPPAGE",
  92: "SPSET",
  93: "SPCLR",
  94: "SPHOME",
  95: "SPOFS",
  96: "SPCHR",
  97: "SPANIM",
  98: "SPANGLE",
  99: "SPSCALE",
  100: "SPREAD",
  101: "SPSETV",
  102: "SPCOL",
  103: "SPCOLVEC",
  104: "BGPAGE",
  105: "BGCLR",
  106: "BGCLIP",
  107: "BGOFS",
  108: "BGPUT",
  109: "BGFILL",
  110: "BGREAD",
  111: "BGCOPY",
  112: "BEEP",
  113: "BGMPLAY",
  114: "BGMSTOP",
  115: "BGMVOL",
  116: "BGMSET",
  117: "BGMSETD",
  118: "BGMCLEAR",
  119: "BGMSETV",
  120: "BGMPRG",
  121: "VAL",
  122: "CHKCHR",
  123: "BUTTON",
  124: "BTRIG",
  125: "ICONCHK",
  126: "FLOOR",
  127: "RND",
  128: "ABS",
  129: "SGN",
  130: "SQR",
  131: "EXP",
  132: "LOG",
  133: "POW",
  134: "PI",
  135: "RAD",
  136: "DEG",
  137: "SIN",
  138: "COS",
  139: "TAN",
  140: "ATAN",
  141: "ASC",
  142: "LEN",
  143: "INSTR",
  144: "GSPOIT",
  145: "SPCHK",
  146: "SPGETV",
  147: "SPHIT",
  148: "SPHITSP",
  149: "SPHITRC",
  150: "BGCHK",
  151: "BGMCHK",
  152: "BGMGETV",
  153: "STR$",
  154: "INKEY$",
  155: "CHR$",
  156: "HEX$",
  157: "MID$",
  158: "RIGHT$",
  159: "LEFT$",
  160: "SUBST$",
  161: "CSRX",
  162: "CSRY",
  163: "FREEMEM",
  164: "VERSION",
  165: "ERR",
  166: "ERL",
  167: "RESULT",
  168: "TCHX",
  169: "TCHY",
  170: "TCHST",
  171: "TCHTIME",
  172: "MAINCNTH",
  173: "MAINCNTL",
  174: "TRUE",
  175: "FALSE",
  176: "CANCEL",
  177: "FUNCNO",
  178: "FREEVAR",
  179: "KEYBOARD",
  180: "SPHITNO",
  181: "SPHITX",
  182: "SPHITY",
  183: "SPHITT",
  184: "TABSTEP",
  185: "ICONPUSE",
  186: "ICONPAGE",
  187: "SYSBEEP",
  188: "NUMB10",
  189: "NUMB2",
  190: "NUMB16",
  191: "AND",
  192: "OR",
  193: "XOR",
  194: "==",
  195: "!=",
  196: ">=",
  197: "<=",
  198: "NOT",
  199: "TIME$",
  200: "DATE$",
  201: "PRGNAME$",
  202: "PACKAGE$",
  203: "MEM$",
  204: "STRING"
},
TERROR: 2,
    EOF: 1,

    // internals: defined here so the object *structure* doesn't get modified by parse() et al,
    // thus helping JIT compilers like Chrome V8.
    originalQuoteName: null,
    originalParseError: null,
    cleanupAfterParse: null,
    constructParseErrorInfo: null,
    yyMergeLocationInfo: null,

    __reentrant_call_depth: 0,      // INTERNAL USE ONLY
    __error_infos: [],              // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup
    __error_recovery_infos: [],     // INTERNAL USE ONLY: the set of parseErrorInfo objects created since the last cleanup

    // APIs which will be set up depending on user action code analysis:
    //yyRecovering: 0,
    //yyErrOk: 0,
    //yyClearIn: 0,

    // Helper APIs
    // -----------

    // Helper function which can be overridden by user code later on: put suitable quotes around
    // literal IDs in a description string.
    quoteName: function parser_quoteName(id_str) {
        return '"' + id_str + '"';
    },

    // Return the name of the given symbol (terminal or non-terminal) as a string, when available.
    //
    // Return NULL when the symbol is unknown to the parser.
    getSymbolName: function parser_getSymbolName(symbol) {
        if (this.terminals_[symbol]) {
            return this.terminals_[symbol];
        }

        // Otherwise... this might refer to a RULE token i.e. a non-terminal: see if we can dig that one up.
        //
        // An example of this may be where a rule's action code contains a call like this:
        //
        //      parser.getSymbolName(#$)
        //
        // to obtain a human-readable name of the current grammar rule.
        var s = this.symbols_;
        for (var key in s) {
            if (s[key] === symbol) {
                return key;
            }
        }
        return null;
    },

    // Return a more-or-less human-readable description of the given symbol, when available,
    // or the symbol itself, serving as its own 'description' for lack of something better to serve up.
    //
    // Return NULL when the symbol is unknown to the parser.
    describeSymbol: function parser_describeSymbol(symbol) {
        if (symbol !== this.EOF && this.terminal_descriptions_ && this.terminal_descriptions_[symbol]) {
            return this.terminal_descriptions_[symbol];
        }
        else if (symbol === this.EOF) {
            return 'end of input';
        }
        var id = this.getSymbolName(symbol);
        if (id) {
            return this.quoteName(id);
        }
        return null;
    },

    // Produce a (more or less) human-readable list of expected tokens at the point of failure.
    //
    // The produced list may contain token or token set descriptions instead of the tokens
    // themselves to help turning this output into something that easier to read by humans
    // unless `do_not_describe` parameter is set, in which case a list of the raw, *numeric*,
    // expected terminals and nonterminals is produced.
    //
    // The returned list (array) will not contain any duplicate entries.
    collect_expected_token_set: function parser_collect_expected_token_set(state, do_not_describe) {
        var TERROR = this.TERROR;
        var tokenset = [];
        var check = {};
        // Has this (error?) state been outfitted with a custom expectations description text for human consumption?
        // If so, use that one instead of the less palatable token set.
        if (!do_not_describe && this.state_descriptions_ && this.state_descriptions_[state]) {
            return [
                this.state_descriptions_[state]
            ];
        }
        for (var p in this.table[state]) {
            p = +p;
            if (p !== TERROR) {
                var d = do_not_describe ? p : this.describeSymbol(p);
                if (d && !check[d]) {
                    tokenset.push(d);
                    check[d] = true;        // Mark this token description as already mentioned to prevent outputting duplicate entries.
                }
            }
        }
        return tokenset;
    },
productions_: bp({
  pop: u([
  s,
  [205, 12],
  s,
  [206, 3],
  207,
  208,
  208,
  s,
  [209, 4],
  s,
  [210, 4],
  s,
  [211, 6],
  s,
  [212, 91],
  213,
  s,
  [213, 10, 1],
  s,
  [222, 7, 1],
  228,
  229,
  229,
  s,
  [230, 10],
  s,
  [231, 7, 1],
  s,
  [237, 5, 1],
  241,
  242,
  242,
  243,
  243,
  244,
  245,
  245,
  246,
  247,
  247,
  248,
  248,
  249,
  249,
  250,
  251,
  s,
  [251, 5, 1],
  255,
  256,
  257,
  257,
  258,
  258,
  259,
  259,
  260,
  260,
  261,
  261,
  262,
  262,
  s,
  [263, 4],
  264,
  265,
  266,
  s,
  [266, 10, 1],
  275,
  276,
  276,
  277,
  278,
  278,
  279,
  279,
  280,
  280,
  281,
  281,
  282,
  282,
  s,
  [283, 4],
  284,
  285,
  s,
  [285, 4, 1],
  288,
  289,
  290,
  290,
  291,
  291,
  292,
  292,
  293,
  293,
  294,
  s,
  [295, 5],
  s,
  [296, 4],
  s,
  [297, 3],
  298,
  s,
  [298, 4, 1],
  s,
  [301, 4, 1],
  304,
  s,
  [305, 4],
  s,
  [306, 4],
  s,
  [307, 6],
  308,
  308,
  s,
  [309, 4],
  s,
  [310, 4],
  s,
  [311, 6],
  s,
  [312, 32],
  313,
  314,
  315,
  s,
  [315, 18, 1],
  s,
  [332, 8, 1],
  339,
  340,
  341,
  341,
  342,
  343,
  343,
  344,
  s,
  [345, 8],
  s,
  [346, 4, 1],
  s,
  [349, 6, 1],
  s,
  [354, 22],
  s,
  [355, 4],
  s,
  [356, 32],
  s,
  [357, 4],
  358,
  s,
  [359, 9],
  s,
  [360, 4],
  361,
  361,
  362,
  362
]),
  rule: u([
  1,
  1,
  2,
  2,
  s,
  [3, 8],
  s,
  [1, 6],
  4,
  4,
  6,
  6,
  c,
  [4, 4],
  c,
  [20, 12],
  s,
  [1, 85],
  s,
  [2, 3],
  c,
  [109, 5],
  2,
  2,
  4,
  4,
  c,
  [11, 3],
  1,
  1,
  6,
  8,
  1,
  c,
  [11, 3],
  c,
  [19, 4],
  s,
  [6, 4],
  s,
  [2, 3],
  10,
  10,
  c,
  [17, 4],
  1,
  12,
  2,
  4,
  2,
  4,
  2,
  6,
  2,
  6,
  8,
  4,
  c,
  [53, 3],
  c,
  [12, 4],
  c,
  [3, 4],
  2,
  c,
  [18, 3],
  c,
  [31, 3],
  6,
  s,
  [4, 4, 2],
  8,
  10,
  8,
  10,
  s,
  [6, 4, 2],
  2,
  2,
  14,
  16,
  12,
  4,
  6,
  12,
  c,
  [43, 3],
  2,
  12,
  16,
  1,
  2,
  6,
  c,
  [51, 3],
  12,
  c,
  [4, 3],
  8,
  s,
  [4, 6, 2],
  6,
  c,
  [3, 3],
  c,
  [52, 3],
  8,
  6,
  8,
  14,
  8,
  18,
  12,
  16,
  10,
  14,
  c,
  [64, 4],
  8,
  c,
  [4, 3],
  c,
  [73, 4],
  c,
  [123, 4],
  c,
  [50, 3],
  12,
  1,
  c,
  [244, 3],
  c,
  [248, 4],
  c,
  [252, 5],
  3,
  3,
  2,
  c,
  [16, 10],
  0,
  s,
  [2, 3],
  c,
  [274, 34],
  4,
  6,
  3,
  4,
  3,
  3,
  s,
  [4, 7],
  c,
  [12, 3],
  c,
  [8, 6],
  c,
  [342, 5],
  c,
  [172, 3],
  6,
  12,
  16,
  4,
  3,
  4,
  6,
  c,
  [45, 9],
  c,
  [32, 3],
  6,
  8,
  6,
  6,
  10,
  c,
  [300, 32],
  s,
  [3, 20],
  c,
  [142, 3],
  s,
  [1, 11],
  c,
  [429, 15]
])
}),
performAction: function parser__PerformAction(yystate /* action[1] */, yysp, yyvstack) {

          /* this == yyval */

          // the JS engine itself can go and remove these statements when `yy` turns out to be unused in any action code!
          var yy = this.yy;
          var yyparser = yy.parser;
          var yylexer = yy.lexer;

          

          switch (yystate) {
case 0:
    /*! Production::    $accept : program $end */

    // default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,-,-,-,-):
    this.$ = yyvstack[yysp - 1];
    // END of default action (generated by JISON mode classic/merge :: 1,VT,VA,-,-,-,-,-,-)
    break;

case 1:
    /*! Production::    program : line */
case 275:
    /*! Production::    mmllist : string */
case 297:
    /*! Production::    dimargs : numarray */
case 298:
    /*! Production::    dimargs : strarray */

    this.$ = [ yyvstack[yysp] ];
    break;

case 2:
    /*! Production::    program : COMMENT */
case 287:
    /*! Production::    ifcommands : ":" */

    this.$ = [];
    break;

case 3:
    /*! Production::    program : program COMMENT */
case 4:
    /*! Production::    program : program ":" */
case 290:
    /*! Production::    ifcommands : ifcommands ":" */
case 447:
    /*! Production::    number : "(" number ")" */
case 461:
    /*! Production::    string : "(" string ")" */

    this.$ = yyvstack[yysp - 1];
    break;

case 5:
    /*! Production::    program : program ENDL COMMENT */
case 8:
    /*! Production::    program : program ENDL REM */
case 9:
    /*! Production::    program : program ":" REM */

    this.$ = yyvstack[yysp - 2];
    break;

case 6:
    /*! Production::    program : program ":" line */
case 7:
    /*! Production::    program : program ENDL line */

    this.$ = yyvstack[yysp - 2].concat(yyvstack[yysp]);
    break;

case 10:
    /*! Production::    program : program ENDL EOF */

    // default action (generated by JISON mode classic/merge :: 3,VT,VA,-,-,-,-,-,-):
    this.$ = yyvstack[yysp - 2];
    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,-,-,-,-,-,-)
    
    
    return yyvstack[yysp - 2];
    break;

case 11:
    /*! Production::    program : program error ENDL */

    this.$ = yyvstack[yysp - 2].concat([{ type: "error", err: yyvstack[yysp - 1] }]);
    break;

case 12:
    /*! Production::    program : program error EOF */

    // default action (generated by JISON mode classic/merge :: 3,VT,VA,-,-,-,-,-,-):
    this.$ = yyvstack[yysp - 2];
    // END of default action (generated by JISON mode classic/merge :: 3,VT,VA,-,-,-,-,-,-)
    
    
    return yyvstack[yysp - 2].concat([{ type: "error", err: yyvstack[yysp - 1] }]);
    break;

case 13:
    /*! Production::    line : command */
case 14:
    /*! Production::    line : declare */
case 15:
    /*! Production::    line : label */
case 277:
    /*! Production::    dataargs : number */
case 278:
    /*! Production::    dataargs : string */
case 281:
    /*! Production::    readargs : numvariable */
case 282:
    /*! Production::    readargs : strvariable */
case 285:
    /*! Production::    ifcommands : declare */
case 286:
    /*! Production::    ifcommands : command */
case 291:
    /*! Production::    onargs : labelacc */
case 293:
    /*! Production::    sortargs : STRVAR */
case 294:
    /*! Production::    sortargs : NUMVAR */

    this.$ = [yyvstack[yysp]];
    break;

case 16:
    /*! Production::    label : LABEL */

    this.$ = { type: "label", name: yyvstack[yysp].substr(1) };
    break;

case 17:
    /*! Production::    labelacc : label */
case 18:
    /*! Production::    labelacc : string */
case 33:
    /*! Production::    command : print */
case 34:
    /*! Production::    command : dim */
case 35:
    /*! Production::    command : clear */
case 36:
    /*! Production::    command : key */
case 37:
    /*! Production::    command : swap */
case 38:
    /*! Production::    command : sort */
case 39:
    /*! Production::    command : rsort */
case 40:
    /*! Production::    command : vsync */
case 41:
    /*! Production::    command : wait */
case 42:
    /*! Production::    command : on */
case 43:
    /*! Production::    command : goto */
case 44:
    /*! Production::    command : gosub */
case 45:
    /*! Production::    command : return */
case 46:
    /*! Production::    command : stop */
case 47:
    /*! Production::    command : end */
case 48:
    /*! Production::    command : for */
case 49:
    /*! Production::    command : next */
case 50:
    /*! Production::    command : if */
case 51:
    /*! Production::    command : read */
case 52:
    /*! Production::    command : data */
case 53:
    /*! Production::    command : restore */
case 54:
    /*! Production::    command : tmread */
case 55:
    /*! Production::    command : dtread */
case 56:
    /*! Production::    command : cls */
case 57:
    /*! Production::    command : color */
case 58:
    /*! Production::    command : locate */
case 59:
    /*! Production::    command : acls */
case 60:
    /*! Production::    command : visible */
case 61:
    /*! Production::    command : input */
case 62:
    /*! Production::    command : linput */
case 63:
    /*! Production::    command : brepeat */
case 64:
    /*! Production::    command : pnltype */
case 65:
    /*! Production::    command : pnlstr */
case 66:
    /*! Production::    command : iconset */
case 67:
    /*! Production::    command : iconclr */
case 68:
    /*! Production::    command : load */
case 69:
    /*! Production::    command : save */
case 70:
    /*! Production::    command : delete */
case 71:
    /*! Production::    command : rename */
case 72:
    /*! Production::    command : recvfile */
case 73:
    /*! Production::    command : sendfile */
case 74:
    /*! Production::    command : exec */
case 75:
    /*! Production::    command : gpage */
case 76:
    /*! Production::    command : gcolor */
case 77:
    /*! Production::    command : gcls */
case 78:
    /*! Production::    command : gpset */
case 79:
    /*! Production::    command : gpaint */
case 80:
    /*! Production::    command : gline */
case 81:
    /*! Production::    command : gbox */
case 82:
    /*! Production::    command : gfill */
case 83:
    /*! Production::    command : gcircle */
case 84:
    /*! Production::    command : gprio */
case 85:
    /*! Production::    command : gdrawmd */
case 86:
    /*! Production::    command : gcopy */
case 87:
    /*! Production::    command : gputchr */
case 88:
    /*! Production::    command : colinit */
case 89:
    /*! Production::    command : colset */
case 90:
    /*! Production::    command : colread */
case 91:
    /*! Production::    command : chrinit */
case 92:
    /*! Production::    command : chrset */
case 93:
    /*! Production::    command : chrread */
case 94:
    /*! Production::    command : sppage */
case 95:
    /*! Production::    command : spset */
case 96:
    /*! Production::    command : spclr */
case 97:
    /*! Production::    command : sphome */
case 98:
    /*! Production::    command : spofs */
case 99:
    /*! Production::    command : spchr */
case 100:
    /*! Production::    command : spanim */
case 101:
    /*! Production::    command : spangle */
case 102:
    /*! Production::    command : spscale */
case 103:
    /*! Production::    command : spread */
case 104:
    /*! Production::    command : spsetv */
case 105:
    /*! Production::    command : spcol */
case 106:
    /*! Production::    command : spcolvec */
case 107:
    /*! Production::    command : bgpage */
case 108:
    /*! Production::    command : bgclr */
case 109:
    /*! Production::    command : bgclip */
case 110:
    /*! Production::    command : bgofs */
case 111:
    /*! Production::    command : bgput */
case 112:
    /*! Production::    command : bgfill */
case 113:
    /*! Production::    command : bgread */
case 114:
    /*! Production::    command : bgcopy */
case 115:
    /*! Production::    command : beep */
case 116:
    /*! Production::    command : bgmplay */
case 117:
    /*! Production::    command : bgmstop */
case 118:
    /*! Production::    command : bgmvol */
case 119:
    /*! Production::    command : bgmset */
case 120:
    /*! Production::    command : bgmsetd */
case 121:
    /*! Production::    command : bgmclear */
case 122:
    /*! Production::    command : bgmsetv */
case 123:
    /*! Production::    command : bgmprg */
case 307:
    /*! Production::    numberfunction : val */
case 308:
    /*! Production::    numberfunction : chkchr */
case 309:
    /*! Production::    numberfunction : button */
case 310:
    /*! Production::    numberfunction : btrig */
case 311:
    /*! Production::    numberfunction : iconchk */
case 312:
    /*! Production::    numberfunction : floor */
case 313:
    /*! Production::    numberfunction : rnd */
case 314:
    /*! Production::    numberfunction : abs */
case 315:
    /*! Production::    numberfunction : sgn */
case 316:
    /*! Production::    numberfunction : sqr */
case 317:
    /*! Production::    numberfunction : exp */
case 318:
    /*! Production::    numberfunction : log */
case 319:
    /*! Production::    numberfunction : pow */
case 320:
    /*! Production::    numberfunction : pi */
case 321:
    /*! Production::    numberfunction : rad */
case 322:
    /*! Production::    numberfunction : deg */
case 323:
    /*! Production::    numberfunction : sin */
case 324:
    /*! Production::    numberfunction : cos */
case 325:
    /*! Production::    numberfunction : tan */
case 326:
    /*! Production::    numberfunction : atan */
case 327:
    /*! Production::    numberfunction : asc */
case 328:
    /*! Production::    numberfunction : len */
case 329:
    /*! Production::    numberfunction : instr */
case 330:
    /*! Production::    numberfunction : gspoit */
case 331:
    /*! Production::    numberfunction : spchk */
case 332:
    /*! Production::    numberfunction : spgetv */
case 333:
    /*! Production::    numberfunction : sphit */
case 334:
    /*! Production::    numberfunction : sphitsp */
case 335:
    /*! Production::    numberfunction : sphitrc */
case 336:
    /*! Production::    numberfunction : bgchk */
case 337:
    /*! Production::    numberfunction : bgmchk */
case 338:
    /*! Production::    numberfunction : bgmgetv */
case 376:
    /*! Production::    stringfunction : str */
case 377:
    /*! Production::    stringfunction : inkey */
case 378:
    /*! Production::    stringfunction : chr */
case 379:
    /*! Production::    stringfunction : hex */
case 380:
    /*! Production::    stringfunction : mid */
case 381:
    /*! Production::    stringfunction : right */
case 382:
    /*! Production::    stringfunction : left */
case 383:
    /*! Production::    stringfunction : subst */
case 448:
    /*! Production::    number : numarray */
case 449:
    /*! Production::    number : numberfunction */
case 450:
    /*! Production::    number : readnumvar */
case 451:
    /*! Production::    number : writenumvar */
case 462:
    /*! Production::    string : strarray */
case 463:
    /*! Production::    string : stringfunction */
case 464:
    /*! Production::    string : readstrvar */
case 465:
    /*! Production::    string : writestrvar */
case 468:
    /*! Production::    variable : numarray */
case 469:
    /*! Production::    variable : strarray */
case 471:
    /*! Production::    strvariable : strarray */
case 473:
    /*! Production::    numvariable : numarray */

    this.$ = yyvstack[yysp];
    break;

case 19:
    /*! Production::    numarray : NUMVAR "(" number ")" */
case 20:
    /*! Production::    numarray : NUMVAR "[" number "]" */
case 23:
    /*! Production::    strarray : STRVAR "(" number ")" */
case 24:
    /*! Production::    strarray : STRVAR "[" number "]" */

    this.$ = { type: "array", name: yyvstack[yysp - 3], indexes: [ yyvstack[yysp - 1] ] };
    break;

case 21:
    /*! Production::    numarray : NUMVAR "(" number "," number ")" */
case 22:
    /*! Production::    numarray : NUMVAR "[" number "," number "]" */
case 25:
    /*! Production::    strarray : STRVAR "(" number "," number ")" */
case 26:
    /*! Production::    strarray : STRVAR "[" number "," number "]" */

    this.$ = { type: "array", name: yyvstack[yysp - 5], indexes: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 27:
    /*! Production::    declare : STRVAR "=" string */
case 28:
    /*! Production::    declare : NUMVAR "=" number */
case 29:
    /*! Production::    declare : writestrvar "=" string */
case 30:
    /*! Production::    declare : writenumvar "=" number */

    this.$ = { type: "varassign", name: yyvstack[yysp - 2], value: yyvstack[yysp] };
    break;

case 31:
    /*! Production::    declare : strarray "=" string */
case 32:
    /*! Production::    declare : numarray "=" number */

    this.$ = { type: "arrassign", access: yyvstack[yysp - 2], value: yyvstack[yysp] };
    break;

case 124:
    /*! Production::    print : PRINT printargs */
case 125:
    /*! Production::    print : "?" printargs */

    this.$ = { type: "com", name: "print", args: yyvstack[yysp] };
    break;

case 126:
    /*! Production::    dim : DIM dimargs */

    this.$ = { type: "com", name: "dim", args: yyvstack[yysp] };
    break;

case 127:
    /*! Production::    clear : CLEAR */

    this.$ = { type: "com", name: "clear", args: [] };
    break;

case 128:
    /*! Production::    key : KEY number "," string */

    this.$ = { type: "com", name: "key", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 129:
    /*! Production::    swap : SWAP variable "," variable */

    this.$ = { type: "com", name: "swap", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 130:
    /*! Production::    sort : SORT number "," number "," sortargs */

    this.$ = { type: "com", name: "sort", args: [yyvstack[yysp - 4], yyvstack[yysp - 2]].concat(yyvstack[yysp]) };
    break;

case 131:
    /*! Production::    rsort : RSORT number "," number "," sortargs */

    this.$ = { type: "com", name: "rsort", args: [yyvstack[yysp - 4], yyvstack[yysp - 2]].concat(yyvstack[yysp - 1]) };
    break;

case 132:
    /*! Production::    vsync : VSYNC number */

    this.$ = { type: "com", name: "vsync", args: [yyvstack[yysp]] };
    break;

case 133:
    /*! Production::    wait : WAIT number */

    this.$ = { type: "com", name: "wait", args: [yyvstack[yysp]] };
    break;

case 134:
    /*! Production::    on : ON number GOTO onargs */
case 135:
    /*! Production::    on : ON number GOSUB onargs */

    this.$ = { type: "com", name: "on", args: [yyvstack[yysp - 2], yyvstack[yysp - 1], yyvstack[yysp]] };
    break;

case 136:
    /*! Production::    goto : GOTO labelacc */

    this.$ = { type: "com", name: "goto", args: [yyvstack[yysp]] };
    break;

case 137:
    /*! Production::    gosub : GOSUB labelacc */

    this.$ = { type: "com", name: "gosub", args: [yyvstack[yysp]] };
    break;

case 138:
    /*! Production::    return : RETURN */

    this.$ = { type: "com", name: "return", args: [] };
    break;

case 139:
    /*! Production::    stop : STOP */

    this.$ = { type: "com", name: "stop", args: [] };
    break;

case 140:
    /*! Production::    end : END */

    this.$ = { type: "com", name: "end", args: [] };
    break;

case 141:
    /*! Production::    for : FOR numvariable "=" number TO number */

    this.$ = { type: "com", name: "for", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 142:
    /*! Production::    for : FOR numvariable "=" number TO number STEP number */

    this.$ = { type: "com", name: "for", args: [yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 143:
    /*! Production::    next : NEXT */

    this.$ = { type: "com", name: "next", args: [] };
    break;

case 144:
    /*! Production::    next : NEXT numvariable */

    this.$ = { type: "com", name: "next", args: [yyvstack[yysp]] };
    break;

case 145:
    /*! Production::    if : IF number THEN ifcommands */

    this.$ = { type: "com", name: "if", iftype: "command", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 146:
    /*! Production::    if : IF number THEN labelacc */
case 147:
    /*! Production::    if : IF number GOTO labelacc */

    this.$ = { type: "com", name: "if", iftype: "goto", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 148:
    /*! Production::    if : IF number GOSUB labelacc */

    this.$ = { type: "com", name: "if", iftype: "gosub", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 149:
    /*! Production::    if : IF number THEN ifcommands ELSE ifcommands */

    this.$ = { type: "com", name: "if", iftype: "command2", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 150:
    /*! Production::    if : IF number THEN labelacc ELSE ifcommands */
case 151:
    /*! Production::    if : IF number GOTO labelacc ELSE ifcommands */

    this.$ = { type: "com", name: "if", iftype: "goto1", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 152:
    /*! Production::    if : IF number GOSUB labelacc ELSE ifcommands */

    this.$ = { type: "com", name: "if", iftype: "gosub1", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 153:
    /*! Production::    if : IF number GOTO labelacc ELSE labelacc */

    this.$ = { type: "com", name: "if", iftype: "goto2", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 154:
    /*! Production::    if : IF number GOSUB labelacc ELSE labelacc */

    this.$ = { type: "com", name: "if", iftype: "gosub2", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 155:
    /*! Production::    read : READ readargs */

    this.$ = { type: "com", name: "read", args: yyvstack[yysp] };
    break;

case 156:
    /*! Production::    data : DATA dataargs */

    this.$ = { type: "com", name: "data", args: yyvstack[yysp] };
    break;

case 157:
    /*! Production::    restore : RESTORE labelacc */

    this.$ = { type: "com", name: "restore", args: [yyvstack[yysp]] };
    break;

case 158:
    /*! Production::    tmread : TMREAD "(" string ")" "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "tmread", args: [yyvstack[yysp - 7], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 159:
    /*! Production::    dtread : DTREAD "(" string ")" "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "dtread", args: [yyvstack[yysp - 7], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 160:
    /*! Production::    cls : CLS */

    this.$ = { type: "com", name: "cls", args: [] };
    break;

case 161:
    /*! Production::    color : COLOR number */

    this.$ = { type: "com", name: "color", args: [yyvstack[yysp]] };
    break;

case 162:
    /*! Production::    color : COLOR number "," number */

    this.$ = { type: "com", name: "color", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 163:
    /*! Production::    locate : LOCATE number "," number */

    this.$ = { type: "com", name: "locate", args: [yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 164:
    /*! Production::    acls : ACLS */

    this.$ = { type: "com", name: "acls", args: [] };
    break;

case 165:
    /*! Production::    visible : VISIBLE number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "visible", args: [yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 166:
    /*! Production::    input : INPUT readargs */

    this.$ = { type: "com", name: "input", args: [null].concat(yyvstack[yysp]) };
    break;

case 167:
    /*! Production::    input : INPUT string ";" readargs */

    this.$ = { type: "com", name: "input", args: [yyvstack[yysp - 2]].concat(yyvstack[yysp]) };
    break;

case 168:
    /*! Production::    linput : LINPUT strvariable */

    this.$ = { type: "com", name: "linput", args: [null].concat(yyvstack[yysp]) };
    break;

case 169:
    /*! Production::    linput : LINPUT string ";" readargs */

    this.$ = { type: "com", name: "linput", args: [yyvstack[yysp - 2]].concat(yyvstack[yysp]) };
    break;

case 170:
    /*! Production::    brepeat : BREPEAT number */

    this.$ = { type: "com", name: "brepeat", args: [ yyvstack[yysp] ] };
    break;

case 171:
    /*! Production::    brepeat : BREPEAT number "," number "," number */

    this.$ = { type: "com", name: "brepeat", args: [yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp]] };
    break;

case 172:
    /*! Production::    pnltype : PNLTYPE string */

    this.$ = { type: "com", name: "pnltype", args: [ yyvstack[yysp] ] };
    break;

case 173:
    /*! Production::    pnlstr : PNLSTR number "," number "," string */

    this.$ = { type: "com", name: "pnlstr", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 174:
    /*! Production::    pnlstr : PNLSTR number "," number "," string "," number */

    this.$ = { type: "com", name: "pnlstr", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 175:
    /*! Production::    iconset : ICONSET number "," number */

    this.$ = { type: "com", name: "iconset", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 176:
    /*! Production::    iconclr : ICONCLR */

    this.$ = { type: "com", name: "iconclr", args: [] };
    break;

case 177:
    /*! Production::    iconclr : ICONCLR number */

    this.$ = { type: "com", name: "iconclr", args: [ yyvstack[yysp] ] };
    break;

case 178:
    /*! Production::    load : LOAD string */

    this.$ = { type: "com", name: "load", args: [ yyvstack[yysp] ] };
    break;

case 179:
    /*! Production::    load : LOAD string "," number */

    this.$ = { type: "com", name: "load", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 180:
    /*! Production::    save : SAVE string */

    this.$ = { type: "com", name: "save", args: [ yyvstack[yysp] ] };
    break;

case 181:
    /*! Production::    save : SAVE string "," string */

    this.$ = { type: "com", name: "save", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 182:
    /*! Production::    delete : DELETE string */

    this.$ = { type: "com", name: "delete", args: [ yyvstack[yysp] ] };
    break;

case 183:
    /*! Production::    rename : RENAME string */

    this.$ = { type: "com", name: "rename", args: [ yyvstack[yysp] ] };
    break;

case 184:
    /*! Production::    rename : RENAME string "," string */

    this.$ = { type: "com", name: "rename", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 185:
    /*! Production::    recvfile : RECVFILE string */

    this.$ = { type: "com", name: "recvfile", args: [ yyvstack[yysp] ] };
    break;

case 186:
    /*! Production::    sendfile : SENDFILE string */

    this.$ = { type: "com", name: "sendfile", args: [ yyvstack[yysp] ] };
    break;

case 187:
    /*! Production::    exec : EXEC string */

    this.$ = { type: "com", name: "exec", args: [ yyvstack[yysp] ] };
    break;

case 188:
    /*! Production::    gpage : GPAGE number */

    this.$ = { type: "com", name: "gpage", args: [ yyvstack[yysp] ] };
    break;

case 189:
    /*! Production::    gpage : GPAGE number "," number "," number */
case 194:
    /*! Production::    gpset : GPSET number "," number "," number */

    this.$ = { type: "com", name: "gpage", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 190:
    /*! Production::    gcolor : GCOLOR number */

    this.$ = { type: "com", name: "gcolor", args: [ yyvstack[yysp] ] };
    break;

case 191:
    /*! Production::    gcls : GCLS */

    this.$ = { type: "com", name: "gcls", args: [] };
    break;

case 192:
    /*! Production::    gcls : GCLS number */

    this.$ = { type: "com", name: "gcls", args: [ yyvstack[yysp] ] };
    break;

case 193:
    /*! Production::    gpset : GPSET number "," number */

    this.$ = { type: "com", name: "gpset", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 195:
    /*! Production::    gpaint : GPAINT number "," number */

    this.$ = { type: "com", name: "gpaint", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 196:
    /*! Production::    gpaint : GPAINT number "," number "," number */

    this.$ = { type: "com", name: "gpaint", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 197:
    /*! Production::    gline : GLINE number "," number "," number "," number */

    this.$ = { type: "com", name: "gline", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 198:
    /*! Production::    gline : GLINE number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gline", args: [ yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 199:
    /*! Production::    gbox : GBOX number "," number "," number "," number */

    this.$ = { type: "com", name: "gbox", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 200:
    /*! Production::    gbox : GBOX number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gbox", args: [ yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 201:
    /*! Production::    gfill : GFILL number "," number "," number "," number */

    this.$ = { type: "com", name: "gfill", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 202:
    /*! Production::    gfill : GFILL number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gfill", args: [ yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 203:
    /*! Production::    gcircle : GCIRCLE number "," number "," number */

    this.$ = { type: "com", name: "gcircle", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 204:
    /*! Production::    gcircle : GCIRCLE number "," number "," number "," number */

    this.$ = { type: "com", name: "gcircle", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 205:
    /*! Production::    gcircle : GCIRCLE number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gcircle", args: [ yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 206:
    /*! Production::    gcircle : GCIRCLE number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gcircle", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 207:
    /*! Production::    gprio : GPRIO number */

    this.$ = { type: "com", name: "gprio", args: [ yyvstack[yysp] ] };
    break;

case 208:
    /*! Production::    gdrawmd : GDRAWMD number */

    this.$ = { type: "com", name: "gdrawmd", args: [ yyvstack[yysp] ] };
    break;

case 209:
    /*! Production::    gcopy : GCOPY number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gcopy", args: [ yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 210:
    /*! Production::    gcopy : GCOPY number "," number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "gcopy", args: [ yyvstack[yysp - 14], yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 211:
    /*! Production::    gputchr : GPUTCHR number "," number "," string "," number "," number "," number */

    this.$ = { type: "com", name: "gputchr", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 212:
    /*! Production::    colinit : COLINIT string "," number */

    this.$ = { type: "com", name: "colinit", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 213:
    /*! Production::    colset : COLSET string "," number "," string */

    this.$ = { type: "com", name: "colset", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 214:
    /*! Production::    colread : COLREAD "(" string "," number ")" "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "colread", args: [ yyvstack[yysp - 9], yyvstack[yysp - 7], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 215:
    /*! Production::    chrinit : CHRINIT string */

    this.$ = { type: "com", name: "chrinit", args: [ yyvstack[yysp] ] };
    break;

case 216:
    /*! Production::    chrset : CHRSET string "," number "," string */

    this.$ = { type: "com", name: "chrset", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 217:
    /*! Production::    chrread : CHRREAD "(" string "," number ")" "," strvariable */

    this.$ = { type: "com", name: "chrread", args: [ yyvstack[yysp - 5], yyvstack[yysp - 3], yyvstack[yysp] ] };
    break;

case 218:
    /*! Production::    sppage : SPPAGE number */

    this.$ = { type: "com", name: "sppage", args: [ yyvstack[yysp] ] };
    break;

case 219:
    /*! Production::    spset : SPSET number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "spset", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 220:
    /*! Production::    spset : SPSET number "," number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "spset", args: [ yyvstack[yysp - 14], yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 221:
    /*! Production::    spclr : SPCLR */

    this.$ = { type: "com", name: "spclr", args: [] };
    break;

case 222:
    /*! Production::    spclr : SPCLR number */

    this.$ = { type: "com", name: "spclr", args: [ yyvstack[yysp] ] };
    break;

case 223:
    /*! Production::    sphome : SPHOME number "," number "," number */

    this.$ = { type: "com", name: "sphome", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 224:
    /*! Production::    spofs : SPOFS number "," number "," number */

    this.$ = { type: "com", name: "spofs", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 225:
    /*! Production::    spofs : SPOFS number "," number "," number "," number */

    this.$ = { type: "com", name: "spofs", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 226:
    /*! Production::    spchr : SPCHR number "," number */

    this.$ = { type: "com", name: "spchr", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 227:
    /*! Production::    spchr : SPCHR number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "spchr", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 228:
    /*! Production::    spanim : SPANIM number "," number "," number */

    this.$ = { type: "com", name: "spanim", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 229:
    /*! Production::    spanim : SPANIM number "," number "," number "," number */

    this.$ = { type: "com", name: "spanim", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 230:
    /*! Production::    spangle : SPANGLE number "," number */

    this.$ = { type: "com", name: "spangle", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 231:
    /*! Production::    spangle : SPANGLE number "," number "," number "," number */

    this.$ = { type: "com", name: "spangle", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2] ] };
    break;

case 232:
    /*! Production::    spscale : SPSCALE number "," number */

    this.$ = { type: "com", name: "spscale", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 233:
    /*! Production::    spscale : SPSCALE number "," number "," number */

    this.$ = { type: "com", name: "spscale", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 234:
    /*! Production::    spread : SPREAD "(" number ")" "," numvariable "," numvariable */

    this.$ = { type: "com", name: "spread", args: [ yyvstack[yysp - 5], yyvstack[yysp - 2] ] };
    break;

case 235:
    /*! Production::    spread : SPREAD "(" number ")" "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "spread", args: [ yyvstack[yysp - 7], yyvstack[yysp - 4], yyvstack[yysp - 2] ] };
    break;

case 236:
    /*! Production::    spread : SPREAD "(" number ")" "," numvariable "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "spread", args: [ yyvstack[yysp - 9], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2] ] };
    break;

case 237:
    /*! Production::    spread : SPREAD "(" number ")" "," numvariable "," numvariable "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "spread", args: [ yyvstack[yysp - 11], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2] ] };
    break;

case 238:
    /*! Production::    spsetv : SPSETV number "," number "," number */

    this.$ = { type: "com", name: "spsetv", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 239:
    /*! Production::    spcol : SPCOL number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "spcol", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 240:
    /*! Production::    spcol : SPCOL number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "spcol", args: [ yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 241:
    /*! Production::    spcolvec : SPCOLVEC number "," number "," number */

    this.$ = { type: "com", name: "spcolvec", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 242:
    /*! Production::    bgpage : BGPAGE number */

    this.$ = { type: "com", name: "bgpage", args: [ yyvstack[yysp] ] };
    break;

case 243:
    /*! Production::    bgclr : BGCLR */

    this.$ = { type: "com", name: "bgclr", args: [] };
    break;

case 244:
    /*! Production::    bgclr : BGCLR number */

    this.$ = { type: "com", name: "bgclr", args: [ yyvstack[yysp] ] };
    break;

case 245:
    /*! Production::    bgclip : BGCLIP number "," number "," number "," number */

    this.$ = { type: "com", name: "bgclip", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 246:
    /*! Production::    bgofs : BGOFS number "," number "," number */

    this.$ = { type: "com", name: "bgofs", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 247:
    /*! Production::    bgofs : BGOFS number "," number "," number "," number */

    this.$ = { type: "com", name: "bgofs", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 248:
    /*! Production::    bgput : BGPUT number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "bgput", args: [ yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 249:
    /*! Production::    bgput : BGPUT number "," number "," number "," number */

    this.$ = { type: "com", name: "bgput", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 250:
    /*! Production::    bgfill : BGFILL number "," number "," number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "bgfill", args: [ yyvstack[yysp - 16], yyvstack[yysp - 14], yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 251:
    /*! Production::    bgfill : BGFILL number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "bgfill", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 252:
    /*! Production::    bgread : BGREAD "(" number "," number "," number ")" "," numvariable "," numvariable "," numvariable "," numvariable */

    this.$ = { type: "com", name: "bgread", args: [ yyvstack[yysp - 13], yyvstack[yysp - 11], yyvstack[yysp - 9], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 253:
    /*! Production::    bgread : BGREAD "(" number "," number "," number ")" "," strvariable */

    this.$ = { type: "com", name: "bgread", args: [ yyvstack[yysp - 7], yyvstack[yysp - 5], yyvstack[yysp - 3], yyvstack[yysp] ] };
    break;

case 254:
    /*! Production::    bgcopy : BGCOPY number "," number "," number "," number "," number "," number "," number */

    this.$ = { type: "com", name: "bgcopy", args: [ yyvstack[yysp - 12], yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 255:
    /*! Production::    beep : BEEP */

    this.$ = { type: "com", name: "beep", args: [] };
    break;

case 256:
    /*! Production::    beep : BEEP number */

    this.$ = { type: "com", name: "beep", args: [ yyvstack[yysp] ] };
    break;

case 257:
    /*! Production::    beep : BEEP number "," number */

    this.$ = { type: "com", name: "beep", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 258:
    /*! Production::    beep : BEEP number "," number "," number */

    this.$ = { type: "com", name: "beep", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 259:
    /*! Production::    beep : BEEP number "," number "," number "," number */

    this.$ = { type: "com", name: "beep", args: [ yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 260:
    /*! Production::    bgmplay : BGMPLAY number */
case 263:
    /*! Production::    bgmplay : BGMPLAY mmllist */

    this.$ = { type: "com", name: "bgmplay", args: [ yyvstack[yysp] ] };
    break;

case 261:
    /*! Production::    bgmplay : BGMPLAY number "," number */

    this.$ = { type: "com", name: "bgmplay", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 262:
    /*! Production::    bgmplay : BGMPLAY number "," number "," number */

    this.$ = { type: "com", name: "bgmplay", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 264:
    /*! Production::    bgmstop : BGMSTOP */

    this.$ = { type: "com", name: "bgmstop", args: [] };
    break;

case 265:
    /*! Production::    bgmstop : BGMSTOP number */

    this.$ = { type: "com", name: "bgmstop", args: [ yyvstack[yysp] ] };
    break;

case 266:
    /*! Production::    bgmstop : BGMSTOP number "," number */

    this.$ = { type: "com", name: "bgmstop", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 267:
    /*! Production::    bgmvol : BGMVOL number */

    this.$ = { type: "com", name: "bgmvol", args: [ yyvstack[yysp] ] };
    break;

case 268:
    /*! Production::    bgmvol : BGMVOL number "," number */

    this.$ = { type: "com", name: "bgmvol", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 269:
    /*! Production::    bgmset : BGMSET number "," mmllist */

    this.$ = { type: "com", name: "bgmset", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 270:
    /*! Production::    bgmsetd : BGMSETD number "," labelacc */

    this.$ = { type: "com", name: "bgmsetd", args: [ yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 271:
    /*! Production::    bgmclear : BGMCLEAR */

    this.$ = { type: "com", name: "bgmclear", args: [] };
    break;

case 272:
    /*! Production::    bgmclear : BGMCLEAR number */

    this.$ = { type: "com", name: "bgmclear", args: [ yyvstack[yysp] ] };
    break;

case 273:
    /*! Production::    bgmsetv : BGMSETV number "," number "," number */

    this.$ = { type: "com", name: "bgmsetv", args: [ yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 274:
    /*! Production::    bgmprg : BGMPRG number "," number "," number "," number "," number "," string */

    this.$ = { type: "com", name: "bgmprg", args: [ yyvstack[yysp - 10], yyvstack[yysp - 8], yyvstack[yysp - 6], yyvstack[yysp - 4], yyvstack[yysp - 2], yyvstack[yysp] ] };
    break;

case 276:
    /*! Production::    mmllist : mmllist "," string */
case 279:
    /*! Production::    dataargs : dataargs "," number */
case 280:
    /*! Production::    dataargs : dataargs "," string */
case 283:
    /*! Production::    readargs : readargs "," numvariable */
case 284:
    /*! Production::    readargs : readargs "," strvariable */
case 288:
    /*! Production::    ifcommands : ifcommands ":" declare */
case 289:
    /*! Production::    ifcommands : ifcommands ":" command */
case 292:
    /*! Production::    onargs : onargs "," labelacc */
case 295:
    /*! Production::    sortargs : sortargs "," STRVAR */
case 296:
    /*! Production::    sortargs : sortargs "," NUMVAR */
case 299:
    /*! Production::    dimargs : dimargs "," strarray */
case 300:
    /*! Production::    dimargs : dimargs "," numarray */

    this.$ = yyvstack[yysp - 2].concat([yyvstack[yysp]]);
    break;

case 301:
    /*! Production::    printargs : %epsilon */

    this.$ = { newline: true, args: [] };
    break;

case 302:
    /*! Production::    printargs : printargs ";" */

    yyvstack[yysp - 1].newline = false; this.$ = yyvstack[yysp - 1];
    break;

case 303:
    /*! Production::    printargs : printargs number */
case 304:
    /*! Production::    printargs : printargs string */

    yyvstack[yysp - 1].newline = true; this.$ = yyvstack[yysp - 1]; this.$.args = yyvstack[yysp - 1].args.concat([
    {
        value: yyvstack[yysp],
        tab: false
    }]);
    break;

case 305:
    /*! Production::    printargs : printargs "," number */
case 306:
    /*! Production::    printargs : printargs "," string */

    yyvstack[yysp - 2].newline = true; this.$ = yyvstack[yysp - 2]; this.$.args = yyvstack[yysp - 2].args.concat([
    {
        value: yyvstack[yysp],
        tab: true
    }]);
    break;

case 339:
    /*! Production::    val : VAL "(" string ")" */

    this.$ = { type: "func", name: "val", args: [ yyvstack[yysp - 1] ] };
    break;

case 340:
    /*! Production::    chkchr : CHKCHR "(" number "," number ")" */

    this.$ = { type: "func", name: "chkchr", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 341:
    /*! Production::    button : BUTTON "(" ")" */

    this.$ = { type: "func", name: "button", args: [] };
    break;

case 342:
    /*! Production::    button : BUTTON "(" number ")" */

    this.$ = { type: "func", name: "button", args: [ yyvstack[yysp - 1] ] };
    break;

case 343:
    /*! Production::    btrig : BTRIG "(" ")" */

    this.$ = { type: "func", name: "btrig", args: [] };
    break;

case 344:
    /*! Production::    iconchk : ICONCHK "(" ")" */

    this.$ = { type: "func", name: "iconchk", args: [] };
    break;

case 345:
    /*! Production::    floor : FLOOR "(" number ")" */

    this.$ = { type: "func", name: "floor", args: [ yyvstack[yysp - 1] ] };
    break;

case 346:
    /*! Production::    rnd : RND "(" number ")" */

    this.$ = { type: "func", name: "rnd", args: [ yyvstack[yysp - 1] ] };
    break;

case 347:
    /*! Production::    abs : ABS "(" number ")" */

    this.$ = { type: "func", name: "abs", args: [ yyvstack[yysp - 1] ] };
    break;

case 348:
    /*! Production::    sgn : SGN "(" number ")" */

    this.$ = { type: "func", name: "sgn", args: [ yyvstack[yysp - 1] ] };
    break;

case 349:
    /*! Production::    sqr : SQR "(" number ")" */

    this.$ = { type: "func", name: "sqr", args: [ yyvstack[yysp - 1] ] };
    break;

case 350:
    /*! Production::    exp : EXP "(" number ")" */

    this.$ = { type: "func", name: "exp", args: [ yyvstack[yysp - 1] ] };
    break;

case 351:
    /*! Production::    log : LOG "(" number ")" */

    this.$ = { type: "func", name: "log", args: [ yyvstack[yysp - 1] ] };
    break;

case 352:
    /*! Production::    pow : POW "(" number "," number ")" */

    this.$ = { type: "func", name: "pow", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 353:
    /*! Production::    pi : PI "(" ")" */

    this.$ = { type: "func", name: "pi", args: [] };
    break;

case 354:
    /*! Production::    rad : RAD "(" number ")" */

    this.$ = { type: "func", name: "rad", args: [ yyvstack[yysp - 1] ] };
    break;

case 355:
    /*! Production::    deg : DEG "(" number ")" */

    this.$ = { type: "func", name: "deg", args: [ yyvstack[yysp - 1] ] };
    break;

case 356:
    /*! Production::    sin : SIN "(" number ")" */

    this.$ = { type: "func", name: "sin", args: [ yyvstack[yysp - 1] ] };
    break;

case 357:
    /*! Production::    cos : COS "(" number ")" */

    this.$ = { type: "func", name: "cos", args: [ yyvstack[yysp - 1] ] };
    break;

case 358:
    /*! Production::    tan : TAN "(" number ")" */

    this.$ = { type: "func", name: "tan", args: [ yyvstack[yysp - 1] ] };
    break;

case 359:
    /*! Production::    atan : ATAN "(" number ")" */

    this.$ = { type: "func", name: "atan", args: [ yyvstack[yysp - 1] ] };
    break;

case 360:
    /*! Production::    atan : ATAN "(" number "," number ")" */

    this.$ = { type: "func", name: "atan", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 361:
    /*! Production::    asc : ASC "(" string ")" */

    this.$ = { type: "func", name: "asc", args: [ yyvstack[yysp - 1] ] };
    break;

case 362:
    /*! Production::    len : LEN "(" string ")" */

    this.$ = { type: "func", name: "len", args: [ yyvstack[yysp - 1] ] };
    break;

case 363:
    /*! Production::    instr : INSTR "(" string "," string ")" */

    this.$ = { type: "func", name: "instr", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 364:
    /*! Production::    gspoit : GSPOIT "(" number "," number ")" */

    this.$ = { type: "func", name: "gspoit", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 365:
    /*! Production::    spchk : SPCHK "(" number ")" */

    this.$ = { type: "func", name: "spchk", args: [ yyvstack[yysp - 1] ] };
    break;

case 366:
    /*! Production::    spgetv : SPGETV "(" number "," number ")" */

    this.$ = { type: "func", name: "spgetv", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 367:
    /*! Production::    sphit : SPHIT "(" number ")" */

    this.$ = { type: "func", name: "sphit", args: [ yyvstack[yysp - 1] ] };
    break;

case 368:
    /*! Production::    sphit : SPHIT "(" number "," number ")" */

    this.$ = { type: "func", name: "sphit", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 369:
    /*! Production::    sphitsp : SPHITSP "(" number "," number ")" */

    this.$ = { type: "func", name: "sphitsp", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 370:
    /*! Production::    sphitrc : SPHITRC "(" number "," number "," number "," number "," number ")" */

    this.$ = { type: "func", name: "sphitrc", args: [ yyvstack[yysp - 9], yyvstack[yysp - 7], yyvstack[yysp - 5], yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 371:
    /*! Production::    sphitrc : SPHITRC "(" number "," number "," number "," number "," number "," number "," number ")" */

    this.$ = { type: "func", name: "sphitrc", args: [ yyvstack[yysp - 13], yyvstack[yysp - 11], yyvstack[yysp - 9], yyvstack[yysp - 7], yyvstack[yysp - 5], yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 372:
    /*! Production::    bgchk : BGCHK "(" number ")" */

    this.$ = { type: "func", name: "bgchk", args: [ yyvstack[yysp - 1] ] };
    break;

case 373:
    /*! Production::    bgmchk : BGMCHK "(" ")" */

    this.$ = { type: "func", name: "bgmchk", args: [] };
    break;

case 374:
    /*! Production::    bgmchk : BGMCHK "(" number ")" */

    this.$ = { type: "func", name: "bgmchk", args: [ yyvstack[yysp - 1] ] };
    break;

case 375:
    /*! Production::    bgmgetv : BGMGETV "(" number "," number ")" */

    this.$ = { type: "func", name: "bgmgetv", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 384:
    /*! Production::    str : "STR$" "(" number ")" */

    this.$ = { type: "func", name: "str", args: [ yyvstack[yysp - 1] ] };
    break;

case 385:
    /*! Production::    inkey : "INKEY$" "(" ")" */

    this.$ = { type: "func", name: "inkey", args: [ yyvstack[yysp] ] };
    break;

case 386:
    /*! Production::    chr : "CHR$" "(" number ")" */

    this.$ = { type: "func", name: "chr", args: [ yyvstack[yysp - 1] ] };
    break;

case 387:
    /*! Production::    hex : "HEX$" "(" number ")" */

    this.$ = { type: "func", name: "hex", args: [ yyvstack[yysp - 1] ] };
    break;

case 388:
    /*! Production::    hex : "HEX$" "(" number "," number ")" */

    this.$ = { type: "func", name: "hex", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 389:
    /*! Production::    mid : "MID$" "(" string "," number "," number ")" */

    this.$ = { type: "func", name: "mid", args: [ yyvstack[yysp - 5], yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 390:
    /*! Production::    right : "RIGHT$" "(" string "," number ")" */

    this.$ = { type: "func", name: "right", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 391:
    /*! Production::    left : "LEFT$" "(" string "," number ")" */

    this.$ = { type: "func", name: "left", args: [ yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 392:
    /*! Production::    subst : "SUBST$" "(" string "," number "," number "," string ")" */

    this.$ = { type: "func", name: "subst", args: [ yyvstack[yysp - 7], yyvstack[yysp - 5], yyvstack[yysp - 3], yyvstack[yysp - 1] ] };
    break;

case 393:
    /*! Production::    readnumvar : CSRX */
case 394:
    /*! Production::    readnumvar : CSRY */
case 395:
    /*! Production::    readnumvar : FREEMEM */
case 396:
    /*! Production::    readnumvar : VERSION */
case 397:
    /*! Production::    readnumvar : ERR */
case 398:
    /*! Production::    readnumvar : ERL */
case 399:
    /*! Production::    readnumvar : RESULT */
case 400:
    /*! Production::    readnumvar : TCHX */
case 401:
    /*! Production::    readnumvar : TCHY */
case 402:
    /*! Production::    readnumvar : TCHST */
case 403:
    /*! Production::    readnumvar : TCHTIME */
case 404:
    /*! Production::    readnumvar : MAINCNTH */
case 405:
    /*! Production::    readnumvar : MAINCNTL */
case 406:
    /*! Production::    readnumvar : TRUE */
case 407:
    /*! Production::    readnumvar : FALSE */
case 408:
    /*! Production::    readnumvar : CANCEL */
case 409:
    /*! Production::    readnumvar : FUNCNO */
case 410:
    /*! Production::    readnumvar : FREEVAR */
case 411:
    /*! Production::    readnumvar : KEYBOARD */
case 412:
    /*! Production::    readnumvar : SPHITNO */
case 413:
    /*! Production::    readnumvar : SPHITX */
case 414:
    /*! Production::    readnumvar : SPHITY */
case 415:
    /*! Production::    readnumvar : SPHITT */
case 416:
    /*! Production::    writenumvar : TABSTEP */
case 417:
    /*! Production::    writenumvar : ICONPUSE */
case 418:
    /*! Production::    writenumvar : ICONPAGE */
case 419:
    /*! Production::    writenumvar : SYSBEEP */

    this.$ = { type: "sysvarnum", name: yyvstack[yysp] };
    break;

case 420:
    /*! Production::    number : NUMB10 */

    this.$ = { type: "number", base: 10, value: yyvstack[yysp] };
    break;

case 421:
    /*! Production::    number : NUMB2 */

    this.$ = { type: "number", base: 2, value: yyvstack[yysp].substr(2) };
    break;

case 422:
    /*! Production::    number : NUMB16 */

    this.$ = { type: "number", base: 16, value: yyvstack[yysp].substr(2) };
    break;

case 423:
    /*! Production::    number : NUMVAR */
case 467:
    /*! Production::    variable : NUMVAR */

    this.$ = { type: "numvar", name: yyvstack[yysp] };
    break;

case 424:
    /*! Production::    number : "-" number */

    this.$ = { type: "minus", right: yyvstack[yysp] };
    break;

case 425:
    /*! Production::    number : number "+" number */

    this.$ = { type: "add", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 426:
    /*! Production::    number : number "-" number */

    this.$ = { type: "sub", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 427:
    /*! Production::    number : number "*" number */

    this.$ = { type: "mul", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 428:
    /*! Production::    number : number "/" number */

    this.$ = { type: "div", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 429:
    /*! Production::    number : number "%" number */

    this.$ = { type: "mod", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 430:
    /*! Production::    number : number AND number */

    this.$ = { type: "and", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 431:
    /*! Production::    number : number OR number */

    this.$ = { type: "or", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 432:
    /*! Production::    number : number XOR number */

    this.$ = { type: "xor", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 433:
    /*! Production::    number : number "==" number */

    this.$ = { type: "eq", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 434:
    /*! Production::    number : number "!=" number */

    this.$ = { type: "neq", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 435:
    /*! Production::    number : number ">" number */

    this.$ = { type: "gt", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 436:
    /*! Production::    number : number "<" number */

    this.$ = { type: "lt", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 437:
    /*! Production::    number : number ">=" number */

    this.$ = { type: "gte", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 438:
    /*! Production::    number : number "<=" number */

    this.$ = { type: "lte", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 439:
    /*! Production::    number : string "==" string */

    this.$ = { type: "streq", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 440:
    /*! Production::    number : string "!=" string */

    this.$ = { type: "strneq", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 441:
    /*! Production::    number : string ">" string */

    this.$ = { type: "strgt", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 442:
    /*! Production::    number : string "<" string */

    this.$ = { type: "strlt", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 443:
    /*! Production::    number : string ">=" string */

    this.$ = { type: "strgte", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 444:
    /*! Production::    number : string "<=" string */

    this.$ = { type: "strlte", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 445:
    /*! Production::    number : NOT number */

    this.$ = { type: "not", right: yyvstack[yysp] };
    break;

case 446:
    /*! Production::    number : "!" number */

    this.$ = { type: "invert", right: yyvstack[yysp] };
    break;

case 452:
    /*! Production::    readstrvar : "TIME$" */
case 453:
    /*! Production::    readstrvar : "DATE$" */
case 454:
    /*! Production::    readstrvar : "PRGNAME$" */
case 455:
    /*! Production::    readstrvar : "PACKAGE$" */
case 456:
    /*! Production::    writestrvar : "MEM$" */

    this.$ = { type: "sysvarstr", name: yyvstack[yysp] };
    break;

case 457:
    /*! Production::    string : STRING */

    this.$ = { type: "string", value: yyvstack[yysp] };
    break;

case 458:
    /*! Production::    string : STRVAR */
case 466:
    /*! Production::    variable : STRVAR */
case 470:
    /*! Production::    strvariable : STRVAR */
case 472:
    /*! Production::    numvariable : NUMVAR */

    this.$ = { type: "strvar", name: yyvstack[yysp] };
    break;

case 459:
    /*! Production::    string : string "+" string */

    this.$ = { type: "concat", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 460:
    /*! Production::    string : string "*" number */

    this.$ = { type: "repeat", left: yyvstack[yysp - 2], right: yyvstack[yysp] };
    break;

case 1110:       // === NO_ACTION[1] :: ensures that anyone (but us) using this new state will fail dramatically!
                // error recovery reduction action (action generated by jison,
                // using the user-specified `%code error_recovery_reduction` %{...%}
                // code chunk below.

                
                break;
            
}
},
table: bt({
  len: u([
  201,
  s,
  [5, 6],
  s,
  [6, 91],
  3,
  3,
  s,
  [1, 4],
  7,
  91,
  91,
  5,
  6,
  132,
  5,
  s,
  [132, 5],
  32,
  32,
  c,
  [23, 4],
  9,
  132,
  7,
  133,
  32,
  1,
  1,
  6,
  132,
  132,
  6,
  132,
  34,
  30,
  132,
  29,
  132,
  132,
  138,
  s,
  [29, 7],
  c,
  [10, 3],
  s,
  [132, 10],
  29,
  29,
  1,
  c,
  [3, 3],
  c,
  [19, 9],
  c,
  [10, 3],
  c,
  [12, 7],
  1,
  132,
  138,
  133,
  c,
  [9, 4],
  c,
  [4, 3],
  s,
  [111, 5],
  5,
  205,
  202,
  2,
  c,
  [59, 3],
  c,
  [51, 4],
  c,
  [77, 3],
  140,
  140,
  s,
  [7, 3],
  2,
  2,
  15,
  s,
  [110, 3],
  111,
  132,
  8,
  s,
  [132, 3],
  s,
  [110, 5],
  111,
  s,
  [110, 71],
  s,
  [1, 41],
  9,
  9,
  7,
  7,
  15,
  15,
  20,
  20,
  16,
  6,
  7,
  9,
  29,
  6,
  1,
  10,
  8,
  6,
  17,
  s,
  [7, 3],
  c,
  [21, 3],
  21,
  15,
  6,
  29,
  29,
  21,
  15,
  15,
  7,
  3,
  12,
  10,
  6,
  3,
  21,
  8,
  c,
  [37, 3],
  9,
  9,
  8,
  9,
  s,
  [8, 3],
  21,
  20,
  20,
  s,
  [15, 6],
  c,
  [8, 4],
  3,
  3,
  29,
  8,
  3,
  29,
  20,
  15,
  c,
  [19, 7],
  132,
  c,
  [23, 7],
  c,
  [10, 4],
  21,
  21,
  7,
  c,
  [4, 3],
  c,
  [16, 3],
  15,
  15,
  s,
  [5, 8],
  8,
  16,
  16,
  20,
  16,
  16,
  8,
  20,
  8,
  20,
  90,
  103,
  98,
  132,
  4,
  c,
  [270, 6],
  s,
  [132, 9],
  110,
  c,
  [351, 8],
  110,
  110,
  15,
  9,
  29,
  132,
  133,
  1,
  c,
  [332, 5],
  c,
  [341, 9],
  c,
  [363, 4],
  c,
  [50, 8],
  133,
  c,
  [20, 5],
  s,
  [29, 4],
  c,
  [434, 3],
  33,
  33,
  3,
  132,
  226,
  c,
  [436, 3],
  132,
  3,
  3,
  s,
  [132, 3],
  7,
  7,
  c,
  [43, 6],
  s,
  [132, 11],
  3,
  132,
  c,
  [25, 4],
  s,
  [132, 4],
  15,
  c,
  [8, 11],
  c,
  [34, 3],
  30,
  32,
  c,
  [412, 3],
  132,
  111,
  c,
  [4, 5],
  103,
  98,
  7,
  7,
  8,
  s,
  [110, 24],
  3,
  15,
  110,
  c,
  [426, 3],
  s,
  [15, 8],
  c,
  [9, 6],
  16,
  s,
  [3, 3],
  c,
  [7, 4],
  c,
  [17, 7],
  110,
  c,
  [17, 5],
  3,
  6,
  c,
  [307, 3],
  c,
  [339, 3],
  s,
  [6, 5],
  11,
  9,
  9,
  6,
  6,
  c,
  [331, 4],
  1,
  1,
  c,
  [277, 3],
  c,
  [361, 6],
  8,
  8,
  c,
  [277, 5],
  c,
  [320, 5],
  c,
  [293, 3],
  c,
  [305, 4],
  21,
  c,
  [18, 3],
  1,
  s,
  [15, 7],
  c,
  [311, 4],
  9,
  20,
  20,
  7,
  9,
  c,
  [72, 3],
  c,
  [107, 5],
  c,
  [536, 6],
  s,
  [110, 3],
  c,
  [9, 7],
  c,
  [7, 3],
  c,
  [289, 3],
  132,
  110,
  c,
  [562, 5],
  c,
  [20, 4],
  c,
  [226, 6],
  3,
  32,
  132,
  198,
  202,
  198,
  226,
  226,
  c,
  [259, 4],
  c,
  [251, 9],
  29,
  29,
  15,
  29,
  c,
  [242, 8],
  c,
  [258, 14],
  s,
  [111, 4],
  s,
  [15, 3],
  c,
  [192, 4],
  s,
  [15, 8],
  s,
  [7, 5],
  21,
  s,
  [6, 8],
  1,
  1,
  c,
  [496, 3],
  s,
  [20, 3],
  c,
  [159, 5],
  3,
  8,
  1,
  8,
  c,
  [16, 3],
  c,
  [168, 3],
  15,
  20,
  1,
  c,
  [492, 4],
  c,
  [193, 3],
  c,
  [169, 3],
  c,
  [30, 3],
  c,
  [157, 11],
  c,
  [3, 4],
  2,
  c,
  [387, 6],
  c,
  [147, 7],
  c,
  [120, 11],
  c,
  [118, 4],
  c,
  [100, 5],
  20,
  c,
  [89, 4],
  s,
  [21, 4],
  15,
  15,
  1,
  6,
  c,
  [74, 3],
  c,
  [235, 3],
  c,
  [4, 3],
  c,
  [290, 3],
  c,
  [270, 4],
  110,
  29,
  c,
  [63, 9],
  c,
  [8, 3],
  c,
  [11, 4],
  c,
  [893, 3],
  15,
  3,
  6,
  c,
  [41, 3],
  c,
  [36, 4],
  c,
  [37, 3],
  15,
  c,
  [324, 3],
  c,
  [57, 4],
  c,
  [44, 3],
  c,
  [38, 11],
  3,
  132,
  29,
  16,
  c,
  [141, 3],
  20,
  6,
  21,
  20,
  c,
  [365, 3],
  c,
  [332, 3],
  8,
  c,
  [30, 4],
  c,
  [26, 6],
  c,
  [172, 3],
  6,
  c,
  [28, 3],
  1,
  20,
  c,
  [48, 5],
  c,
  [669, 4],
  6,
  110,
  132,
  20
]),
  symbol: u([
  10,
  20,
  s,
  [23, 19, 1],
  44,
  45,
  s,
  [48, 73, 1],
  s,
  [184, 4, 1],
  203,
  205,
  206,
  207,
  s,
  [209, 95, 1],
  355,
  358,
  1,
  2,
  3,
  20,
  21,
  c,
  [5, 30],
  47,
  c,
  [6, 540],
  4,
  6,
  9,
  c,
  [3, 3],
  s,
  [9, 4],
  c,
  [16, 3],
  8,
  c,
  [23, 6],
  4,
  8,
  11,
  12,
  19,
  20,
  21,
  24,
  25,
  47,
  s,
  [121, 70, 1],
  s,
  [198, 7, 1],
  311,
  c,
  [91, 91],
  24,
  25,
  209,
  210,
  310,
  c,
  [210, 7],
  12,
  19,
  24,
  25,
  c,
  [94, 77],
  209,
  210,
  s,
  [312, 48, 1],
  c,
  [143, 4],
  360,
  c,
  [137, 132],
  c,
  [132, 529],
  23,
  25,
  c,
  [98, 8],
  c,
  [67, 6],
  207,
  208,
  210,
  c,
  [35, 9],
  c,
  [32, 35],
  c,
  [1089, 18],
  24,
  209,
  362,
  c,
  [9, 5],
  24,
  47,
  209,
  362,
  c,
  [891, 136],
  306,
  361,
  c,
  [139, 85],
  305,
  c,
  [366, 81],
  4,
  c,
  [1203, 138],
  c,
  [132, 132],
  c,
  [270, 139],
  24,
  c,
  [442, 15],
  c,
  [597, 3],
  c,
  [442, 12],
  c,
  [609, 3],
  c,
  [33, 15],
  c,
  [473, 13],
  361,
  c,
  [196, 133],
  c,
  [162, 28],
  c,
  [627, 267],
  c,
  [135, 3],
  c,
  [2194, 82],
  c,
  [431, 80],
  c,
  [29, 174],
  c,
  [605, 402],
  c,
  [2700, 660],
  c,
  [132, 660],
  c,
  [1780, 58],
  c,
  [59, 60],
  c,
  [1840, 1194],
  c,
  [529, 528],
  c,
  [1459, 667],
  c,
  [799, 354],
  304,
  c,
  [1070, 582],
  c,
  [534, 402],
  s,
  [1, 5, 1],
  7,
  8,
  9,
  s,
  [11, 11, 1],
  24,
  25,
  36,
  37,
  42,
  43,
  46,
  c,
  [418, 71],
  s,
  [191, 14, 1],
  c,
  [111, 447],
  c,
  [9320, 5],
  10,
  s,
  [20, 22, 1],
  c,
  [9556, 80],
  c,
  [9555, 100],
  10,
  20,
  c,
  [202, 200],
  21,
  c,
  [6567, 293],
  c,
  [5505, 426],
  c,
  [161, 292],
  c,
  [10086, 90],
  c,
  [140, 193],
  c,
  [10464, 7],
  c,
  [7, 11],
  4,
  6,
  4,
  6,
  8,
  c,
  [1833, 7],
  c,
  [1752, 7],
  c,
  [1856, 7],
  c,
  [1966, 110],
  c,
  [110, 218],
  6,
  c,
  [111, 105],
  c,
  [893, 132],
  13,
  14,
  17,
  18,
  c,
  [147, 4],
  c,
  [3679, 400],
  c,
  [977, 331],
  c,
  [1197, 326],
  c,
  [661, 555],
  c,
  [110, 7255],
  s,
  [4, 40],
  8,
  c,
  [151, 4],
  6,
  c,
  [19995, 8],
  c,
  [9, 8],
  c,
  [7, 11],
  c,
  [9536, 15],
  c,
  [9551, 18],
  c,
  [17, 7],
  c,
  [43, 3],
  c,
  [20, 27],
  c,
  [17, 7],
  36,
  37,
  c,
  [36, 10],
  c,
  [106, 14],
  13,
  14,
  c,
  [9648, 4],
  c,
  [10110, 28],
  c,
  [51, 6],
  c,
  [20169, 4],
  c,
  [167, 3],
  9,
  c,
  [55, 7],
  c,
  [8, 7],
  c,
  [6, 3],
  c,
  [98, 9],
  46,
  c,
  [99, 10],
  c,
  [206, 18],
  c,
  [229, 23],
  c,
  [7, 4],
  c,
  [200, 20],
  c,
  [151, 3],
  c,
  [18, 5],
  c,
  [179, 10],
  c,
  [15880, 58],
  c,
  [100, 21],
  c,
  [350, 33],
  c,
  [158, 4],
  11,
  13,
  14,
  c,
  [184, 6],
  c,
  [9, 3],
  c,
  [173, 7],
  c,
  [10, 9],
  c,
  [31, 9],
  c,
  [192, 21],
  c,
  [38, 5],
  c,
  [450, 53],
  c,
  [401, 6],
  c,
  [9, 12],
  c,
  [17, 25],
  c,
  [33, 17],
  c,
  [530, 37],
  c,
  [20, 20],
  c,
  [170, 30],
  c,
  [15, 60],
  c,
  [130, 71],
  13,
  14,
  c,
  [3, 3],
  c,
  [486, 32],
  c,
  [373, 6],
  c,
  [40, 34],
  c,
  [125, 32],
  c,
  [290, 110],
  c,
  [9676, 132],
  c,
  [467, 116],
  c,
  [277, 176],
  c,
  [1195, 25],
  c,
  [21, 21],
  c,
  [947, 9],
  c,
  [1223, 12],
  c,
  [64, 39],
  c,
  [383, 50],
  c,
  [50, 33],
  c,
  [22221, 32],
  c,
  [5, 8],
  c,
  [835, 5],
  5,
  c,
  [64, 15],
  7,
  c,
  [130, 35],
  c,
  [52, 35],
  c,
  [1191, 8],
  c,
  [1328, 25],
  c,
  [28, 23],
  c,
  [11499, 87],
  c,
  [90, 7],
  c,
  [2069, 11],
  c,
  [2174, 89],
  c,
  [103, 5],
  c,
  [101, 78],
  c,
  [11169, 143],
  c,
  [21023, 4],
  c,
  [13077, 690],
  c,
  [132, 1187],
  c,
  [4285, 111],
  c,
  [21805, 334],
  c,
  [4840, 220],
  5,
  c,
  [3040, 14],
  5,
  c,
  [13731, 9],
  c,
  [2566, 161],
  5,
  c,
  [133, 131],
  5,
  5,
  c,
  [2041, 1056],
  c,
  [1057, 794],
  c,
  [24413, 350],
  c,
  [132, 661],
  c,
  [2995, 132],
  c,
  [2201, 530],
  c,
  [4310, 115],
  c,
  [28418, 270],
  c,
  [27656, 19],
  308,
  c,
  [28023, 32],
  c,
  [33, 13],
  c,
  [4278, 3],
  c,
  [201, 132],
  3,
  4,
  10,
  c,
  [20250, 94],
  c,
  [192, 8],
  c,
  [169, 4],
  c,
  [266, 8],
  c,
  [20263, 95],
  307,
  c,
  [228, 9],
  355,
  c,
  [28449, 67],
  c,
  [760, 4],
  c,
  [28286, 86],
  c,
  [1279, 49],
  13,
  14,
  c,
  [566, 135],
  c,
  [132, 264],
  c,
  [28827, 7],
  c,
  [28834, 91],
  c,
  [3631, 503],
  c,
  [7975, 1451],
  c,
  [11254, 4],
  c,
  [135, 266],
  c,
  [6996, 793],
  c,
  [11877, 146],
  c,
  [2001, 793],
  c,
  [939, 411],
  c,
  [3893, 293],
  c,
  [293, 16],
  304,
  c,
  [5359, 44],
  c,
  [26929, 375],
  c,
  [243, 865],
  c,
  [14192, 197],
  c,
  [16066, 17],
  c,
  [14525, 8],
  c,
  [19016, 2637],
  c,
  [9317, 3],
  c,
  [28482, 125],
  c,
  [5932, 15],
  c,
  [14539, 236],
  c,
  [15, 89],
  c,
  [465, 140],
  c,
  [15, 61],
  c,
  [201, 15],
  c,
  [10004, 6],
  c,
  [18853, 4],
  c,
  [255, 44],
  c,
  [70, 16],
  c,
  [15, 30],
  c,
  [656, 125],
  c,
  [201, 31],
  c,
  [471, 140],
  c,
  [19258, 21],
  c,
  [3, 6],
  c,
  [19638, 6],
  c,
  [19706, 37],
  c,
  [7, 14],
  c,
  [35, 7],
  42,
  c,
  [20036, 16],
  c,
  [6, 24],
  c,
  [40187, 3],
  c,
  [3860, 8],
  c,
  [9, 18],
  c,
  [6, 12],
  c,
  [19978, 47],
  8,
  c,
  [20277, 4],
  c,
  [19068, 52],
  c,
  [20314, 84],
  c,
  [19841, 16],
  c,
  [18991, 57],
  c,
  [19837, 110],
  c,
  [19305, 162],
  c,
  [19729, 180],
  c,
  [470, 33],
  c,
  [527, 43],
  c,
  [528, 90],
  c,
  [19813, 208],
  c,
  [19510, 28],
  c,
  [19862, 30],
  c,
  [1157, 9],
  c,
  [1653, 45],
  7,
  c,
  [30, 44],
  c,
  [17338, 111],
  c,
  [30226, 686],
  c,
  [22635, 326],
  c,
  [1012, 791],
  c,
  [792, 352],
  c,
  [19320, 271],
  c,
  [242, 374],
  c,
  [33159, 484],
  c,
  [2273, 462],
  c,
  [11879, 660],
  24,
  25,
  309,
  c,
  [3, 3],
  c,
  [11151, 164],
  3,
  10,
  c,
  [37180, 98],
  c,
  [16915, 96],
  c,
  [46936, 5],
  c,
  [37586, 3],
  c,
  [202, 20],
  s,
  [47, 74, 1],
  c,
  [203, 100],
  355,
  358,
  c,
  [400, 198],
  c,
  [17530, 226],
  c,
  [226, 226],
  c,
  [46123, 3],
  c,
  [3, 3],
  c,
  [12958, 558],
  c,
  [21596, 849],
  c,
  [15451, 16],
  c,
  [44, 44],
  c,
  [1041, 923],
  c,
  [2393, 268],
  c,
  [16422, 1071],
  c,
  [42996, 707],
  c,
  [12053, 46],
  c,
  [12037, 3],
  c,
  [12316, 74],
  c,
  [45, 90],
  c,
  [31647, 24],
  c,
  [7, 14],
  c,
  [10559, 9],
  43,
  c,
  [10560, 11],
  c,
  [51971, 45],
  s,
  [8, 3],
  c,
  [31473, 46],
  c,
  [31422, 102],
  c,
  [11651, 37],
  c,
  [12076, 5],
  c,
  [11734, 6],
  c,
  [9, 9],
  c,
  [206, 39],
  c,
  [11273, 53],
  c,
  [11704, 36],
  c,
  [31417, 70],
  c,
  [11906, 51],
  c,
  [11303, 171],
  c,
  [12316, 55],
  c,
  [10934, 1229],
  c,
  [352, 484],
  24,
  25,
  c,
  [4893, 135],
  c,
  [4896, 927],
  c,
  [1062, 135],
  25,
  210,
  c,
  [53690, 134],
  c,
  [6621, 1190],
  c,
  [8223, 411],
  c,
  [17632, 45],
  c,
  [5460, 26],
  c,
  [16363, 10],
  c,
  [5205, 56],
  c,
  [21, 63],
  c,
  [5426, 31],
  c,
  [16155, 21],
  c,
  [5248, 55],
  c,
  [16267, 27],
  c,
  [62, 59],
  c,
  [210, 33],
  c,
  [17162, 182],
  c,
  [14280, 139],
  c,
  [3549, 930],
  c,
  [927, 267],
  c,
  [1194, 399],
  c,
  [30126, 138],
  c,
  [2613, 148],
  c,
  [19849, 8],
  c,
  [2406, 41],
  c,
  [2329, 77],
  c,
  [2344, 30],
  c,
  [2755, 22],
  c,
  [19045, 46],
  c,
  [18777, 36],
  c,
  [16180, 638],
  c,
  [1982, 799],
  c,
  [399, 135],
  c,
  [13123, 29],
  c,
  [40596, 70],
  c,
  [55, 23],
  c,
  [41295, 47],
  c,
  [21695, 25],
  c,
  [9596, 37],
  c,
  [40233, 26],
  c,
  [1694, 503],
  c,
  [1295, 534],
  c,
  [10823, 54],
  c,
  [11098, 43],
  c,
  [3015, 19],
  c,
  [36, 17],
  c,
  [2757, 531],
  c,
  [23805, 18],
  c,
  [1929, 55],
  c,
  [1780, 245],
  c,
  [283, 20]
]),
  type: u([
  s,
  [2, 101],
  s,
  [0, 100],
  1,
  s,
  [2, 682],
  0,
  c,
  [91, 93],
  s,
  [0, 3],
  c,
  [968, 138],
  c,
  [143, 87],
  c,
  [137, 52],
  c,
  [132, 543],
  c,
  [32, 64],
  c,
  [34, 4],
  c,
  [9, 16],
  c,
  [891, 130],
  c,
  [139, 134],
  c,
  [334, 52],
  c,
  [802, 335],
  c,
  [808, 88],
  c,
  [34, 18],
  c,
  [334, 162],
  c,
  [1429, 359],
  c,
  [431, 101],
  c,
  [29, 174],
  c,
  [1232, 403],
  c,
  [132, 1319],
  c,
  [1780, 59],
  c,
  [1839, 124],
  c,
  [1840, 1195],
  c,
  [529, 530],
  c,
  [1195, 798],
  c,
  [403, 188],
  c,
  [1070, 617],
  c,
  [402, 408],
  c,
  [8773, 579],
  s,
  [0, 98],
  c,
  [202, 220],
  c,
  [5505, 718],
  c,
  [8022, 359],
  c,
  [140, 288],
  c,
  [2157, 523],
  c,
  [9682, 354],
  c,
  [3277, 716],
  s,
  [2, 8002],
  c,
  [8681, 163],
  c,
  [15880, 125],
  c,
  [678, 430],
  c,
  [526, 240],
  c,
  [9676, 277],
  c,
  [9953, 812],
  c,
  [21023, 54],
  c,
  [13077, 705],
  c,
  [132, 1254],
  c,
  [3941, 102],
  c,
  [21805, 343],
  c,
  [4683, 273],
  c,
  [18113, 267],
  c,
  [2041, 1057],
  c,
  [22604, 784],
  c,
  [1804, 1416],
  c,
  [1673, 286],
  c,
  [28418, 299],
  c,
  [33, 66],
  c,
  [4648, 233],
  s,
  [0, 111],
  c,
  [28449, 66],
  c,
  [21846, 540],
  c,
  [28834, 144],
  c,
  [26235, 471],
  c,
  [7975, 1520],
  c,
  [135, 267],
  c,
  [9037, 807],
  c,
  [939, 1269],
  c,
  [293, 306],
  c,
  [33474, 115],
  c,
  [23652, 375],
  c,
  [243, 972],
  c,
  [20540, 4404],
  c,
  [6636, 266],
  c,
  [508, 376],
  c,
  [968, 460],
  c,
  [1980, 1012],
  c,
  [792, 931],
  c,
  [8759, 337],
  c,
  [242, 374],
  c,
  [33159, 484],
  c,
  [2273, 462],
  c,
  [11879, 580],
  c,
  [3, 6],
  c,
  [11151, 244],
  c,
  [16917, 116],
  c,
  [17120, 202],
  c,
  [400, 303],
  c,
  [17530, 138],
  c,
  [226, 210],
  c,
  [3, 6],
  c,
  [12958, 572],
  c,
  [44200, 851],
  c,
  [27779, 124],
  c,
  [1041, 843],
  c,
  [26398, 1023],
  c,
  [27073, 704],
  c,
  [11811, 1321],
  c,
  [1103, 1308],
  c,
  [352, 486],
  c,
  [7289, 336],
  c,
  [5955, 780],
  c,
  [6621, 1407],
  c,
  [6093, 887],
  c,
  [33774, 190],
  c,
  [3549, 930],
  c,
  [3018, 667],
  c,
  [2613, 626],
  c,
  [16180, 638],
  c,
  [1982, 717],
  c,
  [14281, 245],
  c,
  [16796, 651],
  c,
  [1961, 615],
  c,
  [2757, 664],
  c,
  [717, 256]
]),
  state: u([
  1,
  2,
  6,
  103,
  102,
  5,
  4,
  s,
  [7, 91, 1],
  101,
  100,
  216,
  217,
  219,
  220,
  218,
  233,
  239,
  234,
  s,
  [243, 32, 1],
  240,
  s,
  [298, 8, 1],
  235,
  236,
  223,
  241,
  242,
  229,
  353,
  354,
  350,
  c,
  [53, 46],
  355,
  c,
  [53, 3],
  c,
  [50, 46],
  356,
  c,
  [50, 49],
  357,
  c,
  [50, 49],
  358,
  c,
  [50, 49],
  359,
  c,
  [50, 3],
  361,
  360,
  239,
  c,
  [18, 9],
  241,
  242,
  362,
  361,
  364,
  c,
  [15, 13],
  367,
  365,
  367,
  368,
  c,
  [84, 46],
  369,
  c,
  [84, 3],
  367,
  374,
  370,
  372,
  371,
  233,
  239,
  375,
  c,
  [56, 44],
  376,
  241,
  242,
  377,
  361,
  378,
  c,
  [125, 13],
  c,
  [121, 46],
  381,
  c,
  [255, 49],
  382,
  c,
  [50, 49],
  383,
  c,
  [221, 4],
  387,
  384,
  c,
  [165, 11],
  385,
  372,
  371,
  387,
  c,
  [15, 11],
  389,
  388,
  c,
  [81, 46],
  390,
  c,
  [81, 3],
  c,
  [244, 12],
  391,
  c,
  [63, 46],
  392,
  c,
  [194, 49],
  393,
  c,
  [50, 49],
  394,
  c,
  [163, 15],
  395,
  c,
  [13, 12],
  396,
  c,
  [13, 12],
  397,
  c,
  [13, 12],
  398,
  c,
  [13, 12],
  399,
  c,
  [13, 12],
  400,
  c,
  [13, 12],
  401,
  c,
  [141, 46],
  402,
  c,
  [191, 49],
  403,
  c,
  [50, 49],
  404,
  c,
  [50, 49],
  405,
  c,
  [50, 49],
  406,
  c,
  [50, 49],
  407,
  c,
  [50, 49],
  408,
  c,
  [50, 49],
  409,
  c,
  [50, 49],
  410,
  c,
  [50, 49],
  411,
  c,
  [50, 49],
  412,
  c,
  [50, 49],
  413,
  c,
  [50, 49],
  414,
  c,
  [741, 15],
  415,
  c,
  [13, 12],
  416,
  c,
  [13, 12],
  418,
  c,
  [13, 12],
  419,
  c,
  [102, 46],
  421,
  c,
  [152, 49],
  422,
  c,
  [50, 49],
  423,
  c,
  [50, 49],
  424,
  c,
  [50, 49],
  425,
  c,
  [50, 49],
  426,
  c,
  [50, 49],
  427,
  c,
  [50, 49],
  428,
  c,
  [50, 49],
  429,
  c,
  [50, 49],
  431,
  c,
  [50, 49],
  432,
  c,
  [50, 49],
  433,
  c,
  [50, 49],
  434,
  c,
  [50, 49],
  435,
  c,
  [50, 49],
  436,
  c,
  [50, 49],
  437,
  c,
  [50, 49],
  438,
  c,
  [50, 49],
  439,
  c,
  [50, 49],
  441,
  c,
  [50, 49],
  442,
  c,
  [50, 5],
  444,
  c,
  [51, 44],
  443,
  241,
  242,
  445,
  c,
  [101, 46],
  446,
  c,
  [151, 49],
  447,
  c,
  [50, 49],
  448,
  c,
  [50, 49],
  449,
  c,
  [50, 49],
  450,
  c,
  [50, 49],
  451,
  c,
  [50, 49],
  452,
  c,
  [50, 3],
  453,
  c,
  [3150, 98],
  456,
  c,
  [99, 98],
  c,
  [1612, 12],
  461,
  c,
  [261, 46],
  462,
  c,
  [311, 49],
  463,
  c,
  [50, 49],
  464,
  c,
  [50, 49],
  465,
  c,
  [50, 49],
  466,
  c,
  [1914, 15],
  467,
  c,
  [63, 46],
  468,
  c,
  [63, 15],
  469,
  c,
  [63, 46],
  470,
  c,
  [176, 49],
  472,
  241,
  242,
  473,
  c,
  [50, 96],
  491,
  c,
  [150, 49],
  500,
  c,
  [50, 49],
  501,
  c,
  [50, 49],
  502,
  241,
  242,
  503,
  c,
  [363, 12],
  549,
  c,
  [13, 12],
  556,
  c,
  [13, 12],
  557,
  c,
  [13, 12],
  580,
  c,
  [13, 12],
  582,
  c,
  [115, 46],
  590,
  c,
  [165, 49],
  598,
  c,
  [50, 49],
  617,
  241,
  242,
  618,
  620,
  619,
  c,
  [165, 12],
  621,
  c,
  [65, 46],
  622,
  c,
  [115, 49],
  623,
  c,
  [50, 49],
  624,
  c,
  [50, 49],
  625,
  c,
  [50, 49],
  626,
  c,
  [50, 49],
  627,
  c,
  [50, 49],
  628,
  c,
  [50, 49],
  629,
  c,
  [50, 49],
  630,
  c,
  [50, 49],
  631,
  c,
  [50, 49],
  632,
  c,
  [50, 49],
  633,
  c,
  [50, 49],
  634,
  c,
  [50, 49],
  635,
  c,
  [1293, 15],
  636,
  c,
  [13, 12],
  637,
  c,
  [13, 12],
  638,
  c,
  [13, 12],
  639,
  c,
  [13, 12],
  640,
  c,
  [13, 12],
  641,
  c,
  [13, 12],
  642,
  c,
  [141, 46],
  643,
  c,
  [141, 15],
  646,
  c,
  [63, 46],
  647,
  c,
  [254, 49],
  649,
  c,
  [50, 49],
  652,
  c,
  [50, 49],
  653,
  c,
  [50, 49],
  654,
  c,
  [50, 49],
  655,
  c,
  [50, 49],
  656,
  c,
  [50, 49],
  657,
  c,
  [50, 49],
  658,
  c,
  [50, 49],
  659,
  c,
  [50, 49],
  661,
  c,
  [50, 49],
  662,
  c,
  [50, 49],
  663,
  c,
  [50, 49],
  664,
  c,
  [50, 49],
  665,
  c,
  [50, 49],
  666,
  c,
  [813, 15],
  667,
  c,
  [13, 12],
  668,
  c,
  [13, 12],
  669,
  c,
  [89, 46],
  670,
  c,
  [139, 49],
  671,
  c,
  [50, 49],
  672,
  c,
  [50, 49],
  673,
  c,
  [50, 49],
  674,
  c,
  [50, 49],
  675,
  c,
  [50, 49],
  676,
  c,
  [50, 49],
  678,
  c,
  [50, 49],
  679,
  c,
  [50, 49],
  680,
  c,
  [50, 49],
  682,
  c,
  [50, 49],
  683,
  c,
  [639, 15],
  684,
  c,
  [13, 12],
  685,
  c,
  [13, 12],
  686,
  c,
  [13, 12],
  687,
  353,
  354,
  688,
  c,
  [105, 46],
  689,
  c,
  [155, 49],
  690,
  c,
  [6308, 4],
  692,
  239,
  691,
  c,
  [6309, 13],
  692,
  239,
  693,
  c,
  [6185, 58],
  694,
  c,
  [82, 4],
  696,
  103,
  702,
  697,
  698,
  c,
  [3548, 91],
  695,
  c,
  [113, 9],
  101,
  241,
  701,
  362,
  361,
  703,
  c,
  [6501, 14],
  704,
  c,
  [6501, 14],
  374,
  706,
  705,
  c,
  [195, 46],
  707,
  241,
  242,
  708,
  c,
  [50, 46],
  711,
  c,
  [377, 49],
  712,
  c,
  [50, 49],
  713,
  c,
  [6651, 5],
  714,
  372,
  371,
  367,
  374,
  715,
  c,
  [6656, 4],
  c,
  [60, 44],
  716,
  c,
  [110, 49],
  717,
  c,
  [50, 49],
  718,
  c,
  [50, 49],
  719,
  c,
  [792, 15],
  720,
  c,
  [13, 12],
  721,
  c,
  [76, 46],
  722,
  c,
  [126, 49],
  723,
  c,
  [50, 49],
  724,
  c,
  [50, 49],
  725,
  c,
  [50, 49],
  726,
  c,
  [50, 49],
  727,
  c,
  [50, 49],
  728,
  c,
  [50, 49],
  729,
  c,
  [50, 49],
  730,
  c,
  [50, 49],
  731,
  c,
  [50, 49],
  732,
  c,
  [50, 49],
  734,
  c,
  [50, 49],
  736,
  c,
  [50, 49],
  737,
  c,
  [50, 49],
  738,
  c,
  [50, 49],
  739,
  c,
  [50, 49],
  740,
  c,
  [50, 49],
  741,
  c,
  [50, 49],
  742,
  c,
  [50, 49],
  744,
  c,
  [50, 49],
  745,
  c,
  [50, 49],
  746,
  c,
  [50, 49],
  747,
  c,
  [50, 49],
  748,
  c,
  [50, 49],
  749,
  c,
  [50, 49],
  750,
  c,
  [50, 49],
  752,
  c,
  [50, 49],
  753,
  c,
  [50, 49],
  754,
  c,
  [1476, 15],
  755,
  c,
  [63, 46],
  756,
  c,
  [113, 49],
  757,
  c,
  [113, 4],
  758,
  c,
  [114, 11],
  759,
  361,
  760,
  c,
  [8408, 59],
  761,
  c,
  [129, 49],
  762,
  c,
  [50, 49],
  763,
  c,
  [50, 49],
  764,
  c,
  [50, 49],
  765,
  c,
  [50, 49],
  766,
  c,
  [50, 49],
  830,
  c,
  [50, 49],
  832,
  c,
  [50, 49],
  848,
  c,
  [50, 49],
  858,
  c,
  [50, 49],
  859,
  c,
  [50, 49],
  860,
  c,
  [742, 15],
  861,
  c,
  [63, 46],
  862,
  c,
  [113, 49],
  863,
  c,
  [50, 49],
  864,
  c,
  [50, 49],
  865,
  c,
  [50, 49],
  866,
  c,
  [50, 49],
  867,
  c,
  [50, 49],
  868,
  c,
  [50, 49],
  869,
  c,
  [50, 49],
  870,
  c,
  [50, 49],
  871,
  c,
  [50, 49],
  872,
  c,
  [50, 3],
  873,
  876,
  361,
  877,
  c,
  [1180, 59],
  878,
  c,
  [67, 3],
  103,
  102,
  c,
  [3401, 93],
  879,
  101,
  100,
  103,
  102,
  880,
  881,
  c,
  [7047, 93],
  c,
  [195, 95],
  882,
  101,
  100,
  361,
  884,
  c,
  [3696, 95],
  883,
  c,
  [3696, 14],
  886,
  c,
  [111, 95],
  885,
  c,
  [111, 13],
  367,
  887,
  367,
  888,
  c,
  [569, 46],
  889,
  c,
  [686, 49],
  890,
  c,
  [1249, 15],
  891,
  c,
  [63, 46],
  892,
  c,
  [113, 49],
  893,
  c,
  [50, 49],
  894,
  c,
  [50, 49],
  895,
  c,
  [50, 49],
  896,
  c,
  [50, 49],
  897,
  c,
  [50, 49],
  898,
  c,
  [50, 49],
  899,
  c,
  [413, 15],
  900,
  c,
  [13, 12],
  901,
  c,
  [13, 12],
  903,
  c,
  [89, 46],
  905,
  c,
  [139, 49],
  906,
  c,
  [50, 49],
  907,
  c,
  [50, 49],
  908,
  c,
  [50, 49],
  909,
  c,
  [50, 49],
  910,
  c,
  [50, 49],
  911,
  c,
  [4479, 4],
  912,
  c,
  [52, 46],
  913,
  c,
  [102, 49],
  914,
  c,
  [50, 49],
  915,
  c,
  [50, 49],
  916,
  c,
  [50, 49],
  917,
  c,
  [50, 49],
  918,
  c,
  [50, 49],
  919,
  c,
  [50, 49],
  921,
  c,
  [50, 49],
  922,
  c,
  [50, 49],
  923,
  c,
  [50, 49],
  924,
  c,
  [50, 49],
  925,
  c,
  [50, 49],
  966,
  c,
  [50, 49],
  970,
  c,
  [50, 49],
  971,
  c,
  [50, 49],
  972,
  c,
  [50, 49],
  975,
  c,
  [852, 4],
  976,
  367,
  977,
  c,
  [54, 46],
  978,
  c,
  [104, 49],
  979,
  c,
  [50, 49],
  980,
  c,
  [50, 49],
  981,
  c,
  [50, 49],
  982,
  c,
  [50, 49],
  983,
  c,
  [50, 49],
  984,
  c,
  [50, 49],
  985,
  c,
  [404, 4],
  986,
  374,
  987,
  c,
  [54, 46],
  988,
  c,
  [104, 49],
  989,
  c,
  [50, 49],
  990,
  c,
  [50, 49],
  991,
  c,
  [50, 49],
  992,
  c,
  [254, 4],
  993,
  c,
  [52, 46],
  994,
  c,
  [102, 49],
  995,
  c,
  [50, 49],
  996,
  c,
  [50, 49],
  997,
  c,
  [50, 49],
  998,
  c,
  [50, 49],
  1000,
  c,
  [50, 49],
  1001,
  c,
  [50, 49],
  1002,
  c,
  [50, 49],
  1025,
  c,
  [2351, 15],
  1026,
  367,
  1027,
  367,
  1028,
  c,
  [67, 46],
  1029,
  c,
  [117, 49],
  1030,
  c,
  [50, 49],
  1031,
  c,
  [50, 49],
  1032,
  c,
  [50, 49],
  1033,
  c,
  [50, 49],
  1034,
  c,
  [50, 49],
  1035,
  c,
  [819, 4],
  1036,
  c,
  [52, 46],
  1037,
  c,
  [102, 49],
  1038,
  c,
  [102, 4],
  1039,
  c,
  [52, 46],
  1040,
  c,
  [102, 49],
  1041,
  c,
  [50, 49],
  1042,
  c,
  [7062, 5],
  1044,
  1043,
  c,
  [54, 46],
  1045,
  c,
  [104, 49],
  1046,
  c,
  [50, 49],
  1063,
  c,
  [50, 49],
  1064,
  c,
  [50, 49],
  1065,
  c,
  [50, 49],
  1066,
  c,
  [50, 49],
  1067,
  c,
  [354, 4],
  1068,
  c,
  [52, 46],
  1069,
  c,
  [102, 49],
  1070,
  c,
  [102, 4],
  1071,
  c,
  [52, 46],
  1072,
  c,
  [102, 49],
  1073,
  c,
  [50, 49],
  1074,
  c,
  [152, 4],
  1075,
  c,
  [52, 46],
  1076,
  c,
  [1281, 15],
  1077,
  c,
  [63, 46],
  1088,
  c,
  [165, 49],
  1089,
  c,
  [50, 49],
  1090,
  c,
  [215, 4],
  1091,
  c,
  [52, 46],
  1092,
  c,
  [102, 49],
  1093,
  c,
  [50, 49],
  1094,
  c,
  [152, 4],
  1095,
  c,
  [52, 46],
  1096,
  c,
  [102, 49],
  1102,
  c,
  [50, 49],
  1103,
  c,
  [50, 49],
  1104,
  c,
  [50, 49],
  1105,
  c,
  [252, 4],
  1106,
  c,
  [52, 46],
  1109,
  c,
  [52, 3]
]),
  mode: u([
  s,
  [1, 105],
  s,
  [2, 571],
  c,
  [581, 197],
  c,
  [189, 8],
  s,
  [1, 528],
  c,
  [554, 19],
  c,
  [6, 7],
  c,
  [211, 191],
  c,
  [170, 334],
  c,
  [764, 216],
  c,
  [6, 5],
  c,
  [4, 3],
  c,
  [364, 717],
  s,
  [1, 774],
  c,
  [1138, 909],
  c,
  [909, 499],
  c,
  [499, 170],
  c,
  [669, 334],
  c,
  [334, 252],
  c,
  [5726, 564],
  c,
  [5524, 530],
  c,
  [1645, 305],
  c,
  [1647, 84],
  c,
  [90, 94],
  c,
  [6757, 27],
  c,
  [1613, 342],
  c,
  [452, 3],
  c,
  [7217, 115],
  c,
  [6820, 344],
  c,
  [2380, 537],
  c,
  [8680, 572],
  s,
  [2, 7344],
  c,
  [9419, 46],
  c,
  [15880, 15],
  c,
  [73, 42],
  c,
  [33, 10],
  c,
  [10, 30],
  c,
  [8630, 33],
  c,
  [45, 21],
  c,
  [15476, 10],
  c,
  [8680, 21],
  c,
  [9533, 38],
  c,
  [62, 19],
  c,
  [240, 10],
  c,
  [177, 18],
  c,
  [11, 5],
  c,
  [7, 10],
  c,
  [331, 35],
  c,
  [35, 11],
  c,
  [377, 40],
  c,
  [214, 9],
  c,
  [220, 25],
  c,
  [121, 7],
  c,
  [92, 21],
  c,
  [303, 24],
  c,
  [411, 40],
  c,
  [94, 12],
  c,
  [16382, 14],
  c,
  [17, 16],
  c,
  [16415, 22],
  c,
  [501, 40],
  c,
  [9454, 100],
  c,
  [130, 92],
  c,
  [360, 27],
  c,
  [99, 35],
  c,
  [264, 110],
  c,
  [10603, 135],
  c,
  [521, 122],
  c,
  [197, 77],
  c,
  [188, 22],
  c,
  [21, 14],
  c,
  [1092, 11],
  c,
  [7, 14],
  c,
  [64, 35],
  c,
  [333, 50],
  c,
  [9989, 73],
  c,
  [85, 37],
  c,
  [443, 52],
  c,
  [1065, 18],
  c,
  [1202, 18],
  c,
  [1396, 24],
  c,
  [1802, 99],
  c,
  [83, 97],
  c,
  [101, 84],
  c,
  [10804, 343],
  c,
  [16270, 915],
  c,
  [3355, 148],
  c,
  [12020, 373],
  s,
  [1, 6379],
  c,
  [6490, 193],
  c,
  [193, 585],
  c,
  [9124, 195],
  c,
  [10869, 32],
  c,
  [429, 110],
  c,
  [19737, 438],
  c,
  [981, 91],
  c,
  [88, 19],
  c,
  [110, 225],
  c,
  [440, 110],
  c,
  [110, 545],
  c,
  [12265, 26],
  c,
  [110, 635],
  c,
  [21269, 431],
  c,
  [10556, 143],
  c,
  [10377, 340],
  c,
  [10607, 316],
  c,
  [316, 155],
  c,
  [155, 153],
  c,
  [14823, 40],
  c,
  [1590, 17],
  c,
  [36, 17],
  c,
  [3, 6],
  c,
  [1620, 25],
  c,
  [261, 11],
  c,
  [9, 18],
  c,
  [59, 27],
  c,
  [14758, 32],
  c,
  [13950, 57],
  c,
  [111, 10],
  c,
  [14670, 60],
  c,
  [13546, 27],
  c,
  [1329, 21],
  c,
  [13859, 69],
  c,
  [14252, 80],
  c,
  [25114, 247],
  c,
  [14784, 38],
  c,
  [427, 122],
  c,
  [14595, 158],
  c,
  [14320, 31],
  c,
  [14644, 28],
  c,
  [1664, 99],
  c,
  [5595, 303],
  c,
  [17202, 810],
  c,
  [962, 701],
  c,
  [14477, 400],
  c,
  [510, 302],
  c,
  [27363, 466],
  c,
  [1910, 412],
  c,
  [29605, 617],
  c,
  [619, 22],
  c,
  [16395, 2899],
  c,
  [5562, 526],
  c,
  [3582, 137],
  c,
  [10390, 32],
  c,
  [8802, 11],
  c,
  [8813, 12],
  c,
  [39068, 23],
  c,
  [70, 20],
  c,
  [23326, 52],
  c,
  [23275, 99],
  c,
  [8271, 39],
  c,
  [8781, 9],
  c,
  [23849, 27],
  c,
  [8363, 53],
  c,
  [36, 46],
  c,
  [8221, 32],
  c,
  [23331, 59],
  c,
  [8526, 138],
  c,
  [23784, 76],
  c,
  [8131, 1182],
  c,
  [22168, 2255],
  c,
  [12856, 34],
  c,
  [12757, 47],
  c,
  [21, 74],
  c,
  [13186, 52],
  c,
  [3938, 55],
  c,
  [12154, 27],
  c,
  [13010, 60],
  c,
  [210, 50],
  c,
  [4056, 114],
  c,
  [2576, 1298],
  c,
  [15802, 30],
  c,
  [10, 67],
  c,
  [1503, 72],
  c,
  [14723, 37],
  c,
  [44833, 134],
  c,
  [1638, 965],
  c,
  [15921, 59],
  c,
  [29375, 25],
  c,
  [92, 42],
  c,
  [48, 24],
  c,
  [6942, 52],
  c,
  [17969, 114],
  c,
  [1175, 595],
  c,
  [782, 39],
  c,
  [8090, 43],
  c,
  [16628, 275],
  c,
  [1373, 163],
  c,
  [6915, 198],
  c,
  [10, 17]
]),
  goto: u([
  106,
  3,
  104,
  99,
  98,
  105,
  s,
  [107, 90, 1],
  s,
  [198, 4, 1],
  197,
  205,
  203,
  202,
  204,
  s,
  [1, 5],
  s,
  [2, 5],
  s,
  [13, 5],
  s,
  [14, 5],
  s,
  [15, 5],
  s,
  [33, 6],
  s,
  [34, 6],
  s,
  [35, 6],
  s,
  [36, 6],
  s,
  [37, 6],
  s,
  [38, 6],
  s,
  [39, 6],
  s,
  [40, 6],
  s,
  [41, 6],
  s,
  [42, 6],
  s,
  [43, 6],
  s,
  [44, 6],
  s,
  [45, 6],
  s,
  [46, 6],
  s,
  [47, 6],
  s,
  [48, 6],
  s,
  [49, 6],
  s,
  [50, 6],
  s,
  [51, 6],
  s,
  [52, 6],
  s,
  [53, 6],
  s,
  [54, 6],
  s,
  [55, 6],
  s,
  [56, 6],
  s,
  [57, 6],
  s,
  [58, 6],
  s,
  [59, 6],
  s,
  [60, 6],
  s,
  [61, 6],
  s,
  [62, 6],
  s,
  [63, 6],
  s,
  [64, 6],
  s,
  [65, 6],
  s,
  [66, 6],
  s,
  [67, 6],
  s,
  [68, 6],
  s,
  [69, 6],
  s,
  [70, 6],
  s,
  [71, 6],
  s,
  [72, 6],
  s,
  [73, 6],
  s,
  [74, 6],
  s,
  [75, 6],
  s,
  [76, 6],
  s,
  [77, 6],
  s,
  [78, 6],
  s,
  [79, 6],
  s,
  [80, 6],
  s,
  [81, 6],
  s,
  [82, 6],
  s,
  [83, 6],
  s,
  [84, 6],
  s,
  [85, 6],
  s,
  [86, 6],
  s,
  [87, 6],
  s,
  [88, 6],
  s,
  [89, 6],
  s,
  [90, 6],
  s,
  [91, 6],
  s,
  [92, 6],
  s,
  [93, 6],
  s,
  [94, 6],
  s,
  [95, 6],
  s,
  [96, 6],
  s,
  [97, 6],
  s,
  [98, 6],
  s,
  [99, 6],
  s,
  [100, 6],
  s,
  [101, 6],
  s,
  [102, 6],
  s,
  [103, 6],
  s,
  [104, 6],
  s,
  [105, 6],
  s,
  [106, 6],
  s,
  [107, 6],
  s,
  [108, 6],
  s,
  [109, 6],
  s,
  [110, 6],
  s,
  [111, 6],
  s,
  [112, 6],
  s,
  [113, 6],
  s,
  [114, 6],
  s,
  [115, 6],
  s,
  [116, 6],
  s,
  [117, 6],
  s,
  [118, 6],
  s,
  [119, 6],
  s,
  [120, 6],
  s,
  [121, 6],
  s,
  [122, 6],
  s,
  [123, 6],
  207,
  208,
  206,
  210,
  211,
  209,
  s,
  [212, 4, 1],
  s,
  [16, 7],
  s,
  [301, 180],
  221,
  222,
  s,
  [127, 6],
  232,
  228,
  231,
  227,
  238,
  s,
  [310, 40, 1],
  s,
  [275, 23, 1],
  c,
  [853, 4],
  224,
  225,
  226,
  230,
  s,
  [306, 4, 1],
  197,
  237,
  352,
  351,
  c,
  [84, 82],
  c,
  [82, 328],
  363,
  104,
  238,
  c,
  [48, 8],
  c,
  [17, 23],
  s,
  [138, 6],
  s,
  [139, 6],
  s,
  [140, 6],
  366,
  s,
  [143, 5],
  366,
  143,
  c,
  [142, 82],
  366,
  373,
  c,
  [226, 99],
  379,
  380,
  s,
  [160, 6],
  c,
  [415, 164],
  s,
  [164, 6],
  c,
  [277, 83],
  366,
  386,
  c,
  [503, 15],
  c,
  [16, 15],
  c,
  [115, 83],
  c,
  [391, 15],
  c,
  [383, 164],
  s,
  [176, 3],
  c,
  [85, 3],
  176,
  176,
  227,
  238,
  176,
  c,
  [268, 93],
  c,
  [16, 96],
  c,
  [364, 164],
  s,
  [191, 3],
  c,
  [85, 3],
  191,
  191,
  227,
  238,
  191,
  c,
  [1578, 405],
  c,
  [82, 492],
  c,
  [1104, 32],
  417,
  c,
  [33, 32],
  420,
  c,
  [230, 164],
  s,
  [221, 3],
  c,
  [85, 3],
  221,
  221,
  227,
  238,
  221,
  c,
  [810, 569],
  430,
  c,
  [329, 328],
  s,
  [243, 3],
  c,
  [85, 3],
  243,
  243,
  227,
  238,
  243,
  c,
  [745, 405],
  440,
  c,
  [83, 82],
  s,
  [255, 3],
  c,
  [85, 3],
  255,
  255,
  227,
  238,
  255,
  c,
  [253, 159],
  s,
  [264, 3],
  c,
  [85, 3],
  264,
  264,
  227,
  238,
  264,
  c,
  [587, 323],
  s,
  [271, 3],
  c,
  [85, 3],
  271,
  271,
  227,
  238,
  271,
  c,
  [252, 241],
  s,
  [456, 111],
  s,
  [416, 111],
  s,
  [417, 111],
  s,
  [418, 111],
  s,
  [419, 111],
  s,
  [3, 5],
  s,
  [4, 3],
  106,
  4,
  4,
  454,
  c,
  [6404, 99],
  458,
  106,
  455,
  457,
  c,
  [103, 99],
  460,
  459,
  c,
  [4253, 180],
  c,
  [3591, 262],
  c,
  [98, 180],
  s,
  [124, 3],
  232,
  474,
  471,
  228,
  231,
  124,
  124,
  227,
  238,
  124,
  c,
  [90, 77],
  s,
  [125, 3],
  c,
  [90, 5],
  125,
  125,
  227,
  238,
  125,
  c,
  [90, 77],
  s,
  [126, 3],
  475,
  s,
  [126, 3],
  s,
  [297, 7],
  s,
  [298, 7],
  210,
  211,
  207,
  208,
  476,
  478,
  477,
  479,
  480,
  481,
  487,
  488,
  s,
  [482, 5, 1],
  489,
  490,
  s,
  [420, 110],
  s,
  [421, 110],
  s,
  [422, 110],
  s,
  [423, 3],
  210,
  423,
  211,
  s,
  [423, 105],
  c,
  [743, 82],
  498,
  499,
  494,
  495,
  492,
  493,
  496,
  497,
  c,
  [1193, 246],
  s,
  [448, 110],
  s,
  [449, 110],
  s,
  [450, 110],
  s,
  [451, 110],
  s,
  [457, 110],
  s,
  [458, 3],
  207,
  458,
  208,
  s,
  [458, 105],
  s,
  [462, 110],
  s,
  [463, 110],
  s,
  [464, 110],
  s,
  [465, 110],
  s,
  [307, 110],
  s,
  [308, 110],
  s,
  [309, 110],
  s,
  [310, 110],
  s,
  [311, 110],
  s,
  [312, 110],
  s,
  [313, 110],
  s,
  [314, 110],
  s,
  [315, 110],
  s,
  [316, 110],
  s,
  [317, 110],
  s,
  [318, 110],
  s,
  [319, 110],
  s,
  [320, 110],
  s,
  [321, 110],
  s,
  [322, 110],
  s,
  [323, 110],
  s,
  [324, 110],
  s,
  [325, 110],
  s,
  [326, 110],
  s,
  [327, 110],
  s,
  [328, 110],
  s,
  [329, 110],
  s,
  [330, 110],
  s,
  [331, 110],
  s,
  [332, 110],
  s,
  [333, 110],
  s,
  [334, 110],
  s,
  [335, 110],
  s,
  [336, 110],
  s,
  [337, 110],
  s,
  [338, 110],
  s,
  [393, 110],
  s,
  [394, 110],
  s,
  [395, 110],
  s,
  [396, 110],
  s,
  [397, 110],
  s,
  [398, 110],
  s,
  [399, 110],
  s,
  [400, 110],
  s,
  [401, 110],
  s,
  [402, 110],
  s,
  [403, 110],
  s,
  [404, 110],
  s,
  [405, 110],
  s,
  [406, 110],
  s,
  [407, 110],
  s,
  [408, 110],
  s,
  [409, 110],
  s,
  [410, 110],
  s,
  [411, 110],
  s,
  [412, 110],
  s,
  [413, 110],
  s,
  [414, 110],
  s,
  [415, 110],
  s,
  [376, 110],
  s,
  [377, 110],
  s,
  [378, 110],
  s,
  [379, 110],
  s,
  [380, 110],
  s,
  [381, 110],
  s,
  [382, 110],
  s,
  [383, 110],
  s,
  [452, 110],
  s,
  [453, 110],
  s,
  [454, 110],
  s,
  [455, 110],
  s,
  [504, 41, 1],
  s,
  [466, 3],
  207,
  208,
  s,
  [466, 4],
  s,
  [467, 3],
  210,
  211,
  s,
  [467, 4],
  s,
  [468, 7],
  s,
  [469, 7],
  545,
  c,
  [9336, 14],
  546,
  c,
  [15, 14],
  s,
  [132, 3],
  c,
  [17, 7],
  s,
  [132, 3],
  c,
  [20, 7],
  s,
  [133, 3],
  c,
  [20, 7],
  s,
  [133, 3],
  c,
  [20, 7],
  c,
  [17, 7],
  547,
  548,
  c,
  [16, 7],
  s,
  [136, 6],
  s,
  [17, 7],
  s,
  [18, 4],
  498,
  499,
  s,
  [18, 3],
  c,
  [9747, 16],
  s,
  [137, 6],
  550,
  s,
  [472, 3],
  210,
  211,
  s,
  [472, 5],
  s,
  [473, 8],
  s,
  [144, 6],
  c,
  [85, 7],
  552,
  553,
  551,
  c,
  [86, 7],
  s,
  [155, 3],
  554,
  s,
  [155, 3],
  s,
  [281, 7],
  s,
  [282, 7],
  s,
  [470, 3],
  207,
  208,
  s,
  [470, 4],
  s,
  [471, 7],
  s,
  [156, 3],
  555,
  s,
  [156, 3],
  s,
  [277, 4],
  c,
  [65, 7],
  s,
  [277, 3],
  c,
  [65, 7],
  s,
  [278, 4],
  c,
  [9039, 4],
  s,
  [278, 3],
  c,
  [9042, 4],
  s,
  [157, 6],
  c,
  [13553, 32],
  s,
  [161, 3],
  558,
  c,
  [74, 7],
  s,
  [161, 3],
  c,
  [74, 7],
  559,
  c,
  [296, 14],
  560,
  c,
  [15, 14],
  s,
  [166, 3],
  554,
  s,
  [166, 3],
  561,
  498,
  499,
  c,
  [158, 6],
  s,
  [458, 3],
  c,
  [161, 7],
  s,
  [462, 3],
  s,
  [471, 3],
  s,
  [168, 6],
  562,
  498,
  499,
  s,
  [170, 3],
  563,
  c,
  [59, 7],
  s,
  [170, 3],
  c,
  [62, 7],
  s,
  [172, 3],
  498,
  499,
  s,
  [172, 3],
  564,
  c,
  [85, 14],
  565,
  c,
  [15, 14],
  s,
  [177, 3],
  c,
  [17, 7],
  s,
  [177, 3],
  c,
  [20, 7],
  s,
  [178, 3],
  566,
  498,
  499,
  s,
  [178, 3],
  s,
  [180, 3],
  567,
  498,
  499,
  s,
  [180, 3],
  s,
  [182, 3],
  498,
  499,
  s,
  [182, 3],
  s,
  [183, 3],
  568,
  498,
  499,
  s,
  [183, 3],
  s,
  [185, 3],
  498,
  499,
  s,
  [185, 3],
  s,
  [186, 3],
  498,
  499,
  s,
  [186, 3],
  s,
  [187, 3],
  498,
  499,
  s,
  [187, 3],
  s,
  [188, 3],
  569,
  c,
  [80, 7],
  s,
  [188, 3],
  c,
  [80, 7],
  s,
  [190, 3],
  c,
  [20, 7],
  s,
  [190, 3],
  c,
  [20, 7],
  s,
  [192, 3],
  c,
  [20, 7],
  s,
  [192, 3],
  c,
  [20, 7],
  570,
  c,
  [155, 14],
  571,
  c,
  [15, 14],
  572,
  c,
  [15, 14],
  573,
  c,
  [15, 14],
  574,
  c,
  [15, 14],
  575,
  c,
  [15, 14],
  s,
  [207, 3],
  c,
  [17, 7],
  s,
  [207, 3],
  c,
  [20, 7],
  s,
  [208, 3],
  c,
  [20, 7],
  s,
  [208, 3],
  c,
  [20, 7],
  576,
  c,
  [55, 14],
  577,
  c,
  [15, 14],
  578,
  498,
  499,
  579,
  498,
  499,
  c,
  [473, 16],
  s,
  [215, 3],
  498,
  499,
  s,
  [215, 3],
  581,
  c,
  [27, 18],
  s,
  [218, 3],
  c,
  [66, 7],
  s,
  [218, 3],
  c,
  [69, 7],
  583,
  c,
  [84, 14],
  s,
  [222, 3],
  c,
  [17, 7],
  s,
  [222, 3],
  c,
  [20, 7],
  584,
  c,
  [35, 14],
  585,
  c,
  [15, 14],
  586,
  c,
  [15, 14],
  587,
  c,
  [15, 14],
  588,
  c,
  [15, 14],
  589,
  c,
  [15, 14],
  c,
  [9561, 82],
  591,
  c,
  [97, 14],
  592,
  c,
  [15, 14],
  593,
  c,
  [15, 14],
  s,
  [242, 3],
  c,
  [17, 7],
  s,
  [242, 3],
  c,
  [20, 7],
  s,
  [244, 3],
  c,
  [20, 7],
  s,
  [244, 3],
  c,
  [20, 7],
  594,
  c,
  [55, 14],
  595,
  c,
  [15, 14],
  596,
  c,
  [15, 14],
  597,
  c,
  [227, 96],
  599,
  c,
  [97, 14],
  s,
  [256, 3],
  600,
  c,
  [18, 7],
  s,
  [256, 3],
  c,
  [21, 7],
  s,
  [260, 3],
  601,
  c,
  [21, 7],
  s,
  [260, 3],
  c,
  [21, 7],
  s,
  [263, 3],
  602,
  s,
  [263, 3],
  s,
  [275, 4],
  c,
  [1071, 4],
  s,
  [275, 3],
  c,
  [1071, 4],
  s,
  [265, 3],
  603,
  c,
  [43, 7],
  s,
  [265, 3],
  c,
  [43, 7],
  s,
  [267, 3],
  604,
  c,
  [21, 7],
  s,
  [267, 3],
  c,
  [21, 7],
  605,
  c,
  [121, 14],
  606,
  c,
  [15, 14],
  s,
  [272, 3],
  c,
  [17, 7],
  s,
  [272, 3],
  c,
  [20, 7],
  607,
  c,
  [35, 14],
  608,
  c,
  [15, 14],
  s,
  [6, 5],
  s,
  [9, 5],
  s,
  [5, 5],
  s,
  [7, 5],
  s,
  [8, 5],
  s,
  [10, 5],
  s,
  [11, 5],
  s,
  [12, 5],
  s,
  [27, 3],
  498,
  499,
  s,
  [27, 3],
  609,
  610,
  c,
  [64, 14],
  611,
  612,
  c,
  [16, 14],
  s,
  [28, 3],
  c,
  [17, 7],
  s,
  [28, 3],
  c,
  [20, 7],
  613,
  614,
  c,
  [36, 14],
  615,
  616,
  c,
  [16, 14],
  s,
  [29, 3],
  498,
  499,
  s,
  [29, 3],
  s,
  [30, 3],
  c,
  [25, 7],
  s,
  [30, 3],
  c,
  [28, 7],
  s,
  [31, 3],
  498,
  499,
  s,
  [31, 3],
  s,
  [32, 3],
  c,
  [28, 7],
  s,
  [32, 3],
  c,
  [28, 7],
  s,
  [302, 90],
  s,
  [303, 6],
  c,
  [113, 7],
  s,
  [303, 76],
  c,
  [186, 7],
  s,
  [303, 7],
  s,
  [304, 7],
  c,
  [521, 4],
  s,
  [304, 76],
  c,
  [594, 4],
  s,
  [304, 7],
  c,
  [15104, 83],
  222,
  c,
  [12171, 426],
  c,
  [82, 738],
  s,
  [424, 110],
  c,
  [17794, 194],
  s,
  [445, 110],
  s,
  [446, 110],
  644,
  c,
  [2134, 14],
  645,
  c,
  [12510, 8],
  c,
  [1712, 99],
  648,
  c,
  [83, 81],
  650,
  651,
  c,
  [1387, 656],
  660,
  c,
  [18380, 524],
  c,
  [3076, 591],
  677,
  c,
  [247, 245],
  681,
  c,
  [1034, 212],
  c,
  [16, 16],
  c,
  [21960, 166],
  c,
  [21714, 34],
  c,
  [2639, 3],
  c,
  [119, 82],
  699,
  363,
  106,
  104,
  99,
  700,
  c,
  [16702, 91],
  c,
  [142, 8],
  c,
  [119, 4],
  c,
  [234, 40],
  c,
  [21840, 84],
  709,
  498,
  499,
  710,
  c,
  [321, 84],
  c,
  [82, 164],
  366,
  373,
  c,
  [338, 84],
  c,
  [2200, 278],
  c,
  [5014, 902],
  733,
  c,
  [1515, 84],
  735,
  c,
  [1600, 248],
  c,
  [82, 328],
  743,
  c,
  [7701, 96],
  c,
  [82, 492],
  751,
  c,
  [589, 260],
  c,
  [2430, 180],
  c,
  [2626, 17],
  c,
  [3327, 16],
  c,
  [197, 164],
  s,
  [23, 111],
  c,
  [193, 82],
  s,
  [24, 111],
  c,
  [193, 82],
  s,
  [19, 111],
  c,
  [193, 82],
  s,
  [20, 111],
  c,
  [193, 82],
  s,
  [305, 6],
  c,
  [1415, 7],
  s,
  [305, 76],
  c,
  [1491, 7],
  s,
  [305, 7],
  s,
  [306, 7],
  c,
  [7245, 4],
  s,
  [306, 76],
  c,
  [7321, 4],
  s,
  [306, 7],
  s,
  [299, 7],
  s,
  [300, 7],
  s,
  [128, 3],
  498,
  499,
  s,
  [128, 3],
  s,
  [425, 10],
  c,
  [225, 3],
  s,
  [425, 97],
  s,
  [426, 10],
  c,
  [110, 3],
  s,
  [426, 97],
  s,
  [427, 110],
  s,
  [428, 110],
  s,
  [429, 110],
  s,
  [430, 8],
  c,
  [775, 7],
  s,
  [430, 84],
  c,
  [780, 4],
  s,
  [430, 7],
  s,
  [431, 8],
  c,
  [110, 7],
  s,
  [431, 84],
  c,
  [110, 4],
  s,
  [431, 7],
  s,
  [432, 8],
  c,
  [110, 7],
  s,
  [432, 84],
  c,
  [110, 4],
  s,
  [432, 7],
  s,
  [433, 8],
  c,
  [110, 5],
  s,
  [433, 97],
  s,
  [434, 8],
  c,
  [110, 5],
  s,
  [434, 97],
  s,
  [435, 8],
  c,
  [110, 5],
  s,
  [435, 97],
  s,
  [436, 8],
  c,
  [110, 5],
  s,
  [436, 97],
  s,
  [437, 8],
  c,
  [110, 5],
  s,
  [437, 97],
  s,
  [438, 8],
  c,
  [110, 5],
  s,
  [438, 97],
  s,
  [439, 9],
  498,
  499,
  s,
  [439, 99],
  s,
  [440, 9],
  498,
  499,
  s,
  [440, 99],
  s,
  [441, 9],
  498,
  499,
  s,
  [441, 99],
  s,
  [442, 9],
  498,
  499,
  s,
  [442, 99],
  s,
  [443, 9],
  498,
  499,
  s,
  [443, 99],
  s,
  [444, 9],
  498,
  499,
  s,
  [444, 99],
  s,
  [459, 10],
  499,
  s,
  [459, 99],
  s,
  [460, 110],
  s,
  [447, 110],
  s,
  [461, 110],
  767,
  498,
  499,
  768,
  c,
  [4276, 14],
  s,
  [341, 110],
  769,
  c,
  [125, 14],
  s,
  [343, 110],
  s,
  [344, 110],
  770,
  c,
  [235, 14],
  771,
  c,
  [15, 14],
  772,
  c,
  [15, 14],
  773,
  c,
  [15, 14],
  774,
  c,
  [15, 14],
  775,
  c,
  [15, 14],
  776,
  c,
  [15, 14],
  777,
  c,
  [15, 14],
  s,
  [353, 110],
  778,
  c,
  [125, 14],
  779,
  c,
  [15, 14],
  780,
  c,
  [15, 14],
  781,
  c,
  [15, 14],
  782,
  c,
  [15, 14],
  783,
  784,
  c,
  [16, 14],
  785,
  498,
  499,
  786,
  498,
  499,
  787,
  498,
  499,
  788,
  c,
  [24, 14],
  789,
  c,
  [15, 14],
  790,
  c,
  [15, 14],
  791,
  792,
  c,
  [16, 14],
  793,
  c,
  [15, 14],
  794,
  c,
  [15, 14],
  795,
  c,
  [15, 14],
  s,
  [373, 110],
  796,
  c,
  [125, 14],
  797,
  c,
  [15, 14],
  798,
  c,
  [15, 14],
  s,
  [385, 110],
  799,
  c,
  [125, 14],
  800,
  801,
  c,
  [16, 14],
  802,
  498,
  499,
  803,
  498,
  499,
  804,
  498,
  499,
  805,
  498,
  499,
  s,
  [129, 6],
  806,
  c,
  [33, 14],
  807,
  c,
  [15, 14],
  s,
  [134, 3],
  808,
  s,
  [134, 3],
  s,
  [291, 7],
  s,
  [135, 3],
  808,
  s,
  [135, 3],
  c,
  [35, 7],
  809,
  c,
  [36, 7],
  145,
  145,
  811,
  145,
  145,
  810,
  s,
  [146, 5],
  812,
  s,
  [285, 6],
  s,
  [286, 6],
  s,
  [287, 6],
  c,
  [22913, 4],
  208,
  206,
  s,
  [458, 5],
  s,
  [465, 3],
  212,
  s,
  [465, 5],
  s,
  [462, 3],
  214,
  s,
  [462, 5],
  s,
  [147, 5],
  813,
  s,
  [148, 5],
  814,
  s,
  [283, 7],
  s,
  [284, 7],
  s,
  [279, 4],
  c,
  [104, 7],
  s,
  [279, 3],
  c,
  [106, 7],
  s,
  [280, 4],
  c,
  [4042, 4],
  s,
  [280, 3],
  c,
  [3969, 4],
  815,
  816,
  s,
  [162, 3],
  c,
  [37, 7],
  s,
  [162, 3],
  c,
  [37, 7],
  s,
  [163, 3],
  c,
  [20, 7],
  s,
  [163, 3],
  c,
  [20, 7],
  817,
  c,
  [214, 14],
  s,
  [167, 3],
  554,
  s,
  [167, 3],
  s,
  [169, 3],
  554,
  s,
  [169, 3],
  818,
  c,
  [29, 14],
  819,
  c,
  [15, 14],
  s,
  [175, 3],
  c,
  [17, 7],
  s,
  [175, 3],
  c,
  [20, 7],
  s,
  [179, 3],
  c,
  [20, 7],
  s,
  [179, 3],
  c,
  [20, 7],
  s,
  [181, 3],
  498,
  499,
  s,
  [181, 3],
  s,
  [184, 3],
  498,
  499,
  s,
  [184, 3],
  820,
  c,
  [71, 14],
  s,
  [193, 3],
  821,
  c,
  [18, 7],
  s,
  [193, 3],
  c,
  [21, 7],
  s,
  [195, 3],
  822,
  c,
  [21, 7],
  s,
  [195, 3],
  c,
  [21, 7],
  823,
  c,
  [57, 14],
  824,
  c,
  [15, 14],
  825,
  c,
  [15, 14],
  826,
  c,
  [15, 14],
  827,
  c,
  [15, 14],
  828,
  c,
  [15, 14],
  s,
  [212, 3],
  c,
  [17, 7],
  s,
  [212, 3],
  c,
  [20, 7],
  829,
  c,
  [5897, 96],
  831,
  c,
  [97, 96],
  833,
  c,
  [97, 14],
  834,
  c,
  [15, 14],
  835,
  c,
  [15, 14],
  s,
  [226, 3],
  836,
  c,
  [18, 7],
  s,
  [226, 3],
  c,
  [21, 7],
  837,
  c,
  [36, 14],
  s,
  [230, 3],
  838,
  c,
  [18, 7],
  s,
  [230, 3],
  c,
  [184, 8],
  232,
  232,
  839,
  c,
  [21, 7],
  s,
  [232, 3],
  c,
  [21, 7],
  840,
  841,
  c,
  [58, 14],
  842,
  c,
  [15, 14],
  843,
  c,
  [15, 14],
  844,
  c,
  [15, 14],
  845,
  c,
  [15, 14],
  846,
  c,
  [15, 14],
  847,
  c,
  [311, 96],
  849,
  c,
  [97, 14],
  s,
  [257, 3],
  850,
  c,
  [18, 7],
  s,
  [257, 3],
  c,
  [21, 7],
  s,
  [261, 3],
  851,
  c,
  [21, 7],
  s,
  [261, 3],
  c,
  [21, 7],
  s,
  [276, 4],
  498,
  499,
  s,
  [276, 3],
  s,
  [266, 3],
  c,
  [29, 7],
  s,
  [266, 3],
  c,
  [29, 7],
  s,
  [268, 3],
  c,
  [20, 7],
  s,
  [268, 3],
  c,
  [20, 7],
  s,
  [269, 3],
  602,
  s,
  [269, 3],
  c,
  [14644, 6],
  s,
  [275, 3],
  s,
  [270, 6],
  852,
  c,
  [128, 14],
  853,
  c,
  [15, 14],
  854,
  c,
  [15, 14],
  855,
  c,
  [15, 14],
  856,
  c,
  [15, 14],
  857,
  c,
  [15, 14],
  s,
  [339, 110],
  c,
  [410, 82],
  s,
  [342, 110],
  s,
  [345, 110],
  s,
  [346, 110],
  s,
  [347, 110],
  s,
  [348, 110],
  s,
  [349, 110],
  s,
  [350, 110],
  s,
  [351, 110],
  c,
  [962, 82],
  s,
  [354, 110],
  s,
  [355, 110],
  s,
  [356, 110],
  s,
  [357, 110],
  s,
  [358, 110],
  s,
  [359, 110],
  c,
  [742, 82],
  s,
  [361, 110],
  s,
  [362, 110],
  c,
  [8475, 98],
  s,
  [365, 110],
  c,
  [192, 82],
  s,
  [367, 110],
  c,
  [9121, 246],
  s,
  [372, 110],
  s,
  [374, 110],
  c,
  [302, 82],
  s,
  [384, 110],
  s,
  [386, 110],
  s,
  [387, 110],
  c,
  [10424, 410],
  875,
  874,
  875,
  874,
  c,
  [9971, 99],
  699,
  106,
  c,
  [30229, 98],
  s,
  [290, 3],
  106,
  290,
  290,
  c,
  [104, 20],
  290,
  c,
  [105, 78],
  c,
  [205, 100],
  c,
  [13834, 115],
  c,
  [115, 115],
  366,
  366,
  c,
  [10967, 344],
  c,
  [16285, 524],
  902,
  c,
  [5327, 14],
  c,
  [31, 16],
  904,
  c,
  [12552, 588],
  c,
  [1489, 165],
  c,
  [82, 410],
  920,
  c,
  [1164, 424],
  s,
  [25, 111],
  s,
  [26, 111],
  s,
  [21, 111],
  s,
  [22, 111],
  926,
  c,
  [869, 14],
  927,
  c,
  [15, 14],
  928,
  c,
  [15, 14],
  929,
  498,
  499,
  930,
  c,
  [18, 14],
  931,
  c,
  [15, 14],
  932,
  c,
  [15, 14],
  933,
  c,
  [15, 14],
  934,
  c,
  [15, 14],
  935,
  c,
  [15, 14],
  936,
  c,
  [15, 14],
  937,
  c,
  [15, 14],
  938,
  c,
  [15, 14],
  939,
  c,
  [15, 14],
  940,
  c,
  [15, 14],
  s,
  [130, 3],
  941,
  s,
  [130, 3],
  s,
  [293, 7],
  s,
  [294, 7],
  s,
  [131, 3],
  941,
  s,
  [131, 3],
  s,
  [292, 7],
  s,
  [141, 3],
  c,
  [52, 7],
  141,
  141,
  942,
  141,
  c,
  [56, 7],
  149,
  149,
  811,
  s,
  [149, 3],
  s,
  [288, 6],
  s,
  [289, 6],
  150,
  150,
  811,
  s,
  [150, 3],
  151,
  151,
  811,
  s,
  [151, 3],
  s,
  [153, 6],
  152,
  152,
  811,
  s,
  [152, 3],
  s,
  [154, 6],
  943,
  944,
  945,
  c,
  [121, 14],
  s,
  [171, 3],
  c,
  [17, 7],
  s,
  [171, 3],
  c,
  [20, 7],
  s,
  [173, 3],
  946,
  498,
  499,
  s,
  [173, 3],
  s,
  [189, 3],
  c,
  [29, 7],
  s,
  [189, 3],
  c,
  [29, 7],
  s,
  [194, 3],
  c,
  [20, 7],
  s,
  [194, 3],
  c,
  [20, 7],
  s,
  [196, 3],
  c,
  [20, 7],
  s,
  [196, 3],
  c,
  [20, 7],
  947,
  c,
  [104, 14],
  948,
  c,
  [15, 14],
  949,
  c,
  [15, 14],
  s,
  [203, 3],
  950,
  c,
  [18, 7],
  s,
  [203, 3],
  c,
  [21, 7],
  951,
  c,
  [36, 14],
  952,
  498,
  499,
  s,
  [213, 3],
  c,
  [5, 5],
  953,
  s,
  [216, 3],
  498,
  499,
  s,
  [216, 3],
  954,
  955,
  c,
  [36, 14],
  s,
  [223, 3],
  c,
  [17, 7],
  s,
  [223, 3],
  c,
  [20, 7],
  s,
  [224, 3],
  956,
  c,
  [21, 7],
  s,
  [224, 3],
  c,
  [21, 7],
  957,
  c,
  [56, 14],
  s,
  [228, 3],
  958,
  c,
  [18, 7],
  s,
  [228, 3],
  c,
  [21, 7],
  959,
  c,
  [36, 14],
  s,
  [233, 3],
  c,
  [17, 7],
  s,
  [233, 3],
  c,
  [20, 7],
  960,
  s,
  [238, 3],
  c,
  [21, 7],
  s,
  [238, 3],
  c,
  [21, 7],
  961,
  c,
  [56, 14],
  s,
  [241, 3],
  c,
  [17, 7],
  s,
  [241, 3],
  c,
  [20, 7],
  962,
  c,
  [35, 14],
  s,
  [246, 3],
  963,
  c,
  [18, 7],
  s,
  [246, 3],
  c,
  [21, 7],
  964,
  c,
  [36, 14],
  965,
  c,
  [1628, 96],
  967,
  c,
  [97, 14],
  s,
  [258, 3],
  968,
  c,
  [18, 7],
  s,
  [258, 3],
  c,
  [21, 7],
  s,
  [262, 3],
  c,
  [20, 7],
  s,
  [262, 3],
  c,
  [20, 7],
  s,
  [273, 3],
  c,
  [20, 7],
  s,
  [273, 3],
  c,
  [20, 7],
  969,
  c,
  [76, 14],
  s,
  [340, 110],
  s,
  [352, 110],
  s,
  [360, 110],
  s,
  [363, 110],
  s,
  [364, 110],
  s,
  [366, 110],
  s,
  [368, 110],
  s,
  [369, 110],
  c,
  [1053, 82],
  s,
  [375, 110],
  s,
  [388, 110],
  c,
  [302, 82],
  s,
  [390, 110],
  s,
  [391, 110],
  c,
  [302, 82],
  974,
  973,
  c,
  [4041, 83],
  c,
  [4042, 575],
  c,
  [41944, 166],
  c,
  [5111, 739],
  999,
  c,
  [4947, 260],
  1003,
  c,
  [261, 14],
  1004,
  c,
  [15, 14],
  1005,
  c,
  [15, 14],
  s,
  [295, 7],
  s,
  [296, 7],
  s,
  [142, 3],
  c,
  [31, 7],
  s,
  [142, 3],
  c,
  [34, 7],
  1006,
  1007,
  1008,
  c,
  [51, 14],
  s,
  [174, 3],
  c,
  [17, 7],
  s,
  [174, 3],
  c,
  [20, 7],
  s,
  [197, 3],
  1009,
  c,
  [21, 7],
  s,
  [197, 3],
  c,
  [21, 7],
  s,
  [199, 3],
  1010,
  c,
  [21, 7],
  s,
  [199, 3],
  c,
  [21, 7],
  s,
  [201, 3],
  1011,
  c,
  [21, 7],
  s,
  [201, 3],
  c,
  [21, 7],
  s,
  [204, 3],
  1012,
  c,
  [21, 7],
  s,
  [204, 3],
  c,
  [21, 7],
  1013,
  c,
  [119, 14],
  1014,
  c,
  [15, 14],
  1015,
  s,
  [217, 6],
  1016,
  c,
  [22, 14],
  s,
  [225, 3],
  c,
  [17, 7],
  s,
  [225, 3],
  c,
  [20, 7],
  1017,
  c,
  [35, 14],
  s,
  [229, 3],
  c,
  [17, 7],
  s,
  [229, 3],
  c,
  [20, 7],
  s,
  [231, 3],
  c,
  [20, 7],
  s,
  [231, 3],
  c,
  [20, 7],
  s,
  [234, 3],
  1018,
  s,
  [234, 3],
  1019,
  c,
  [62, 14],
  s,
  [245, 3],
  c,
  [17, 7],
  s,
  [245, 3],
  c,
  [20, 7],
  s,
  [247, 3],
  c,
  [20, 7],
  s,
  [247, 3],
  c,
  [20, 7],
  s,
  [249, 3],
  1020,
  c,
  [21, 7],
  s,
  [249, 3],
  c,
  [21, 7],
  1021,
  c,
  [76, 14],
  1022,
  1023,
  c,
  [16, 14],
  s,
  [259, 3],
  c,
  [17, 7],
  s,
  [259, 3],
  c,
  [20, 7],
  1024,
  c,
  [722, 96],
  s,
  [389, 110],
  c,
  [7056, 16],
  c,
  [2426, 576],
  c,
  [575, 165],
  c,
  [740, 247],
  c,
  [2756, 166],
  1047,
  c,
  [1377, 14],
  1048,
  498,
  499,
  s,
  [158, 6],
  s,
  [159, 6],
  1049,
  c,
  [30, 14],
  s,
  [198, 3],
  c,
  [17, 7],
  s,
  [198, 3],
  c,
  [20, 7],
  s,
  [200, 3],
  c,
  [20, 7],
  s,
  [200, 3],
  c,
  [20, 7],
  s,
  [202, 3],
  c,
  [20, 7],
  s,
  [202, 3],
  c,
  [20, 7],
  s,
  [205, 3],
  1050,
  c,
  [21, 7],
  s,
  [205, 3],
  c,
  [21, 7],
  1051,
  c,
  [96, 14],
  1052,
  c,
  [15, 14],
  1053,
  1054,
  c,
  [16, 14],
  1055,
  c,
  [15, 14],
  s,
  [235, 3],
  1056,
  s,
  [235, 3],
  1057,
  c,
  [22, 14],
  1058,
  c,
  [15, 14],
  1059,
  c,
  [15, 14],
  1060,
  s,
  [253, 6],
  1061,
  c,
  [22, 14],
  1062,
  c,
  [1638, 96],
  s,
  [392, 110],
  c,
  [1374, 741],
  c,
  [9564, 98],
  1078,
  1079,
  c,
  [1047, 14],
  s,
  [165, 3],
  c,
  [17, 7],
  s,
  [165, 3],
  c,
  [20, 7],
  s,
  [206, 3],
  c,
  [20, 7],
  s,
  [206, 3],
  c,
  [20, 7],
  1080,
  c,
  [55, 14],
  s,
  [211, 3],
  c,
  [17, 7],
  s,
  [211, 3],
  c,
  [20, 7],
  s,
  [214, 6],
  s,
  [219, 3],
  1081,
  c,
  [27, 7],
  s,
  [219, 3],
  c,
  [27, 7],
  s,
  [227, 3],
  c,
  [20, 7],
  s,
  [227, 3],
  c,
  [20, 7],
  s,
  [236, 3],
  1082,
  s,
  [236, 3],
  s,
  [239, 3],
  1083,
  c,
  [28, 7],
  s,
  [239, 3],
  c,
  [28, 7],
  1084,
  c,
  [110, 14],
  s,
  [251, 3],
  1085,
  c,
  [18, 7],
  s,
  [251, 3],
  c,
  [21, 7],
  1086,
  1087,
  c,
  [37, 14],
  s,
  [274, 3],
  498,
  499,
  s,
  [274, 3],
  s,
  [370, 110],
  c,
  [4399, 493],
  c,
  [247, 83],
  1097,
  c,
  [709, 14],
  s,
  [209, 3],
  1098,
  c,
  [18, 7],
  s,
  [209, 3],
  c,
  [21, 7],
  1099,
  c,
  [36, 14],
  s,
  [237, 6],
  s,
  [240, 3],
  c,
  [23, 7],
  s,
  [240, 3],
  c,
  [26, 7],
  s,
  [248, 3],
  c,
  [20, 7],
  s,
  [248, 3],
  c,
  [20, 7],
  1100,
  c,
  [61, 14],
  1101,
  s,
  [254, 3],
  c,
  [18, 7],
  s,
  [254, 3],
  c,
  [9383, 335],
  366,
  1107,
  c,
  [365, 14],
  s,
  [210, 3],
  c,
  [17, 7],
  s,
  [210, 3],
  c,
  [20, 7],
  s,
  [220, 3],
  c,
  [20, 7],
  s,
  [220, 3],
  c,
  [20, 7],
  1108,
  c,
  [55, 14],
  s,
  [252, 6],
  s,
  [371, 110],
  c,
  [269, 82],
  s,
  [250, 3],
  c,
  [215, 7],
  s,
  [250, 3],
  c,
  [218, 7]
])
}),
defaultActions: bda({
  idx: u([
  s,
  [2, 96, 1],
  104,
  105,
  106,
  108,
  118,
  119,
  120,
  129,
  132,
  s,
  [197, 6, 1],
  219,
  220,
  224,
  225,
  226,
  s,
  [233, 5, 1],
  s,
  [239, 71, 1],
  353,
  354,
  360,
  361,
  364,
  367,
  368,
  371,
  372,
  374,
  378,
  388,
  s,
  [453, 8, 1],
  471,
  491,
  500,
  501,
  s,
  [609, 4, 2],
  619,
  620,
  624,
  625,
  626,
  643,
  644,
  645,
  648,
  650,
  651,
  660,
  677,
  681,
  688,
  692,
  697,
  698,
  699,
  705,
  706,
  760,
  767,
  s,
  [769, 8, 1],
  s,
  [778, 6, 1],
  785,
  786,
  789,
  791,
  795,
  796,
  798,
  799,
  800,
  s,
  [854, 4, 1],
  874,
  875,
  877,
  880,
  881,
  884,
  886,
  s,
  [926, 8, 1],
  935,
  936,
  938,
  939,
  973,
  974,
  987,
  1004,
  1027,
  1028,
  1044,
  1048,
  1068,
  1078,
  1091,
  1106,
  1107
]),
  goto: u([
  1,
  2,
  13,
  14,
  15,
  s,
  [33, 91, 1],
  16,
  301,
  301,
  127,
  138,
  139,
  140,
  160,
  164,
  456,
  s,
  [416, 4, 1],
  3,
  297,
  298,
  420,
  421,
  422,
  s,
  [448, 4, 1],
  457,
  s,
  [462, 4, 1],
  s,
  [307, 32, 1],
  s,
  [393, 23, 1],
  s,
  [376, 8, 1],
  s,
  [452, 4, 1],
  468,
  469,
  136,
  17,
  137,
  473,
  144,
  281,
  282,
  471,
  157,
  168,
  6,
  9,
  5,
  7,
  8,
  10,
  11,
  12,
  302,
  424,
  445,
  446,
  23,
  24,
  19,
  20,
  299,
  300,
  427,
  428,
  429,
  460,
  447,
  461,
  341,
  343,
  344,
  353,
  373,
  385,
  129,
  291,
  285,
  286,
  287,
  283,
  284,
  270,
  339,
  342,
  s,
  [345, 7, 1],
  s,
  [354, 6, 1],
  361,
  362,
  365,
  367,
  372,
  374,
  384,
  386,
  387,
  25,
  26,
  21,
  22,
  293,
  294,
  292,
  288,
  289,
  153,
  154,
  340,
  352,
  360,
  363,
  364,
  366,
  368,
  369,
  375,
  388,
  390,
  391,
  295,
  296,
  217,
  389,
  158,
  159,
  253,
  392,
  214,
  370,
  237,
  252,
  371
])
}),
parseError: function parseError(str, hash, ExceptionClass) {
    if (hash.recoverable) {
        if (typeof this.trace === 'function') {
            this.trace(str);
        }
        hash.destroy();             // destroy... well, *almost*!
    } else {
        if (typeof this.trace === 'function') {
            this.trace(str);
        }
        if (!ExceptionClass) {
            ExceptionClass = this.JisonParserError;
        }
        throw new ExceptionClass(str, hash);
    }
},
parse: function parse(input) {
    var self = this;
    var stack = new Array(128);         // token stack: stores token which leads to state at the same index (column storage)
    var sstack = new Array(128);        // state stack: stores states (column storage)

    var vstack = new Array(128);        // semantic value stack

    var table = this.table;
    var sp = 0;                         // 'stack pointer': index into the stacks


    


    var symbol = 0;
    var preErrorSymbol = 0;
    var lastEofErrorStateDepth = Infinity;
    var recoveringErrorInfo = null;
    var recovering = 0;                 // (only used when the grammar contains error recovery rules)
    var TERROR = this.TERROR;
    var EOF = this.EOF;
    var ERROR_RECOVERY_TOKEN_DISCARD_COUNT = (this.options.errorRecoveryTokenDiscardCount | 0) || 3;
    var NO_ACTION = [0, 1110 /* === table.length :: ensures that anyone using this new state will fail dramatically! */];

    var lexer;
    if (this.__lexer__) {
        lexer = this.__lexer__;
    } else {
        lexer = this.__lexer__ = Object.create(this.lexer);
    }

    var sharedState_yy = {
        parseError: undefined,
        quoteName: undefined,
        lexer: undefined,
        parser: undefined,
        pre_parse: undefined,
        post_parse: undefined,
        pre_lex: undefined,
        post_lex: undefined      // WARNING: must be written this way for the code expanders to work correctly in both ES5 and ES6 modes!
    };

    var ASSERT;
    if (typeof assert !== 'function') {
        ASSERT = function JisonAssert(cond, msg) {
            if (!cond) {
                throw new Error('assertion failed: ' + (msg || '***'));
            }
        };
    } else {
        ASSERT = assert;
    }

    this.yyGetSharedState = function yyGetSharedState() {
        return sharedState_yy;
    };


    this.yyGetErrorInfoTrack = function yyGetErrorInfoTrack() {
        return recoveringErrorInfo;
    };


    // shallow clone objects, straight copy of simple `src` values
    // e.g. `lexer.yytext` MAY be a complex value object,
    // rather than a simple string/value.
    function shallow_copy(src) {
        if (typeof src === 'object') {
            var dst = {};
            for (var k in src) {
                if (Object.prototype.hasOwnProperty.call(src, k)) {
                    dst[k] = src[k];
                }
            }
            return dst;
        }
        return src;
    }
    function shallow_copy_noclobber(dst, src) {
        for (var k in src) {
            if (typeof dst[k] === 'undefined' && Object.prototype.hasOwnProperty.call(src, k)) {
                dst[k] = src[k];
            }
        }
    }

    // copy state
    shallow_copy_noclobber(sharedState_yy, this.yy);

    sharedState_yy.lexer = lexer;
    sharedState_yy.parser = this;







    // Does the shared state override the default `parseError` that already comes with this instance?
    if (typeof sharedState_yy.parseError === 'function') {
        this.parseError = function parseErrorAlt(str, hash, ExceptionClass) {
            if (!ExceptionClass) {
                ExceptionClass = this.JisonParserError;
            }
            return sharedState_yy.parseError.call(this, str, hash, ExceptionClass);
        };
    } else {
        this.parseError = this.originalParseError;
    }

    // Does the shared state override the default `quoteName` that already comes with this instance?
    if (typeof sharedState_yy.quoteName === 'function') {
        this.quoteName = function quoteNameAlt(id_str) {
            return sharedState_yy.quoteName.call(this, id_str);
        };
    } else {
        this.quoteName = this.originalQuoteName;
    }

    // set up the cleanup function; make it an API so that external code can re-use this one in case of
    // calamities or when the `%options no-try-catch` option has been specified for the grammar, in which
    // case this parse() API method doesn't come with a `finally { ... }` block any more!
    //
    // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,
    //       or else your `sharedState`, etc. references will be *wrong*!
    this.cleanupAfterParse = function parser_cleanupAfterParse(resultValue, invoke_post_methods, do_not_nuke_errorinfos) {
        var rv;

        if (invoke_post_methods) {
            var hash;

            if (sharedState_yy.post_parse || this.post_parse) {
                // create an error hash info instance: we re-use this API in a **non-error situation**
                // as this one delivers all parser internals ready for access by userland code.
                hash = this.constructParseErrorInfo(null /* no error! */, null /* no exception! */, null, false);
            }

            if (sharedState_yy.post_parse) {
                rv = sharedState_yy.post_parse.call(this, sharedState_yy, resultValue, hash);
                if (typeof rv !== 'undefined') resultValue = rv;
            }
            if (this.post_parse) {
                rv = this.post_parse.call(this, sharedState_yy, resultValue, hash);
                if (typeof rv !== 'undefined') resultValue = rv;
            }

            // cleanup:
            if (hash && hash.destroy) {
                hash.destroy();
            }
        }

        if (this.__reentrant_call_depth > 1) return resultValue;        // do not (yet) kill the sharedState when this is a reentrant run.

        // clean up the lingering lexer structures as well:
        if (lexer.cleanupAfterLex) {
            lexer.cleanupAfterLex(do_not_nuke_errorinfos);
        }

        // prevent lingering circular references from causing memory leaks:
        if (sharedState_yy) {
            sharedState_yy.lexer = undefined;
            sharedState_yy.parser = undefined;
            if (lexer.yy === sharedState_yy) {
                lexer.yy = undefined;
            }
        }
        sharedState_yy = undefined;
        this.parseError = this.originalParseError;
        this.quoteName = this.originalQuoteName;

        // nuke the vstack[] array at least as that one will still reference obsoleted user values.
        // To be safe, we nuke the other internal stack columns as well...
        stack.length = 0;               // fastest way to nuke an array without overly bothering the GC
        sstack.length = 0;

        vstack.length = 0;
        sp = 0;

        // nuke the error hash info instances created during this run.
        // Userland code must COPY any data/references
        // in the error hash instance(s) it is more permanently interested in.
        if (!do_not_nuke_errorinfos) {
            for (var i = this.__error_infos.length - 1; i >= 0; i--) {
                var el = this.__error_infos[i];
                if (el && typeof el.destroy === 'function') {
                    el.destroy();
                }
            }
            this.__error_infos.length = 0;


            for (var i = this.__error_recovery_infos.length - 1; i >= 0; i--) {
                var el = this.__error_recovery_infos[i];
                if (el && typeof el.destroy === 'function') {
                    el.destroy();
                }
            }
            this.__error_recovery_infos.length = 0;

            // `recoveringErrorInfo` is also part of the `__error_recovery_infos` array,
            // hence has been destroyed already: no need to do that *twice*.
            if (recoveringErrorInfo) {
                recoveringErrorInfo = undefined;
            }


        }

        return resultValue;
    };






































































































































    // NOTE: as this API uses parse() as a closure, it MUST be set again on every parse() invocation,
    //       or else your `lexer`, `sharedState`, etc. references will be *wrong*!
    this.constructParseErrorInfo = function parser_constructParseErrorInfo(msg, ex, expected, recoverable) {
        var pei = {
            errStr: msg,
            exception: ex,
            text: lexer.match,
            value: lexer.yytext,
            token: this.describeSymbol(symbol) || symbol,
            token_id: symbol,
            line: lexer.yylineno,

            expected: expected,
            recoverable: recoverable,
            state: state,
            action: action,
            new_state: newState,
            symbol_stack: stack,
            state_stack: sstack,
            value_stack: vstack,

            stack_pointer: sp,
            yy: sharedState_yy,
            lexer: lexer,
            parser: this,

            // and make sure the error info doesn't stay due to potential
            // ref cycle via userland code manipulations.
            // These would otherwise all be memory leak opportunities!
            //
            // Note that only array and object references are nuked as those
            // constitute the set of elements which can produce a cyclic ref.
            // The rest of the members is kept intact as they are harmless.
            destroy: function destructParseErrorInfo() {
                // remove cyclic references added to error info:
                // info.yy = null;
                // info.lexer = null;
                // info.value = null;
                // info.value_stack = null;
                // ...
                var rec = !!this.recoverable;
                for (var key in this) {
                    if (this.hasOwnProperty(key) && typeof key === 'object') {
                        this[key] = undefined;
                    }
                }
                this.recoverable = rec;
            }
        };
        // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
        this.__error_infos.push(pei);
        return pei;
    };

    // clone some parts of the (possibly enhanced!) errorInfo object
    // to give them some persistence.
    this.shallowCopyErrorInfo = function parser_shallowCopyErrorInfo(p) {
        var rv = shallow_copy(p);

        // remove the large parts which can only cause cyclic references
        // and are otherwise available from the parser kernel anyway.
        delete rv.sharedState_yy;
        delete rv.parser;
        delete rv.lexer;

        // lexer.yytext MAY be a complex value object, rather than a simple string/value:
        rv.value = shallow_copy(rv.value);




        // the 'expected' set won't be modified, so no need to clone it:
        //rv.expected = rv.expected.slice(0);

        //symbol stack is a simple array:
        rv.symbol_stack = rv.symbol_stack.slice(0);
        // ditto for state stack:
        rv.state_stack = rv.state_stack.slice(0);


        // and the value stack may carry both simple and complex values:
        // shallow-copy the latter.
        rv.value_stack = rv.value_stack.map(shallow_copy);

        // and we don't bother with the sharedState_yy reference:
        //delete rv.yy;

        // now we prepare for tracking the COMBINE actions
        // in the error recovery code path:
        //
        // as we want to keep the maximum error info context, we
        // *scan* the state stack to find the first *empty* slot.
        // This position will surely be AT OR ABOVE the current
        // stack pointer, but we want to keep the 'used but discarded'
        // part of the parse stacks *intact* as those slots carry
        // error context that may be useful when you want to produce
        // very detailed error diagnostic reports.
        //
        // ### Purpose of each stack pointer:
        //
        // - stack_pointer: points at the top of the parse stack
        //                  **as it existed at the time of the error
        //                  occurrence, i.e. at the time the stack
        //                  snapshot was taken and copied into the
        //                  errorInfo object.**
        // - base_pointer:  the bottom of the **empty part** of the
        //                  stack, i.e. **the start of the rest of
        //                  the stack space /above/ the existing
        //                  parse stack. This section will be filled
        //                  by the error recovery process as it
        //                  travels the parse state machine to
        //                  arrive at the resolving error recovery rule.**
        // - info_stack_pointer:
        //                  this stack pointer points to the **top of
        //                  the error ecovery tracking stack space**, i.e.
        //                  this stack pointer takes up the role of
        //                  the `stack_pointer` for the error recovery
        //                  process. Any mutations in the **parse stack**
        //                  are **copy-appended** to this part of the
        //                  stack space, keeping the bottom part of the
        //                  stack (the 'snapshot' part where the parse
        //                  state at the time of error occurrence was kept)
        //                  intact.
        // - root_failure_pointer:
        //                  copy of the `stack_pointer`...
        //
        for (var i = rv.stack_pointer; typeof rv.state_stack[i] !== 'undefined'; i++) {
            // empty
        }
        rv.base_pointer = i;
        rv.info_stack_pointer = i;

        rv.root_failure_pointer = rv.stack_pointer;

        // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
        this.__error_recovery_infos.push(rv);

        return rv;
    };

    function getNonTerminalFromCode(symbol) {
        var tokenName = self.getSymbolName(symbol);
        if (!tokenName) {
            tokenName = symbol;
        }
        return tokenName;
    }


    function stdLex() {
        var token = lexer.lex();
        // if token isn't its numeric value, convert
        if (typeof token !== 'number') {
            token = self.symbols_[token] || token;
        }

        return token || EOF;
    }

    function fastLex() {
        var token = lexer.fastLex();
        // if token isn't its numeric value, convert
        if (typeof token !== 'number') {
            token = self.symbols_[token] || token;
        }

        return token || EOF;
    }

    var lex = stdLex;


    var state, action, r, t;
    var yyval = {
        $: true,
        _$: undefined,
        yy: sharedState_yy
    };
    var p;
    var yyrulelen;
    var this_production;
    var newState;
    var retval = false;


    // Return the rule stack depth where the nearest error rule can be found.
    // Return -1 when no error recovery rule was found.
    function locateNearestErrorRecoveryRule(state) {
        var stack_probe = sp - 1;
        var depth = 0;

        // try to recover from error
        while (stack_probe >= 0) {
            // check for error recovery rule in this state









            var t = table[state][TERROR] || NO_ACTION;
            if (t[0]) {
                // We need to make sure we're not cycling forever:
                // once we hit EOF, even when we `yyerrok()` an error, we must
                // prevent the core from running forever,
                // e.g. when parent rules are still expecting certain input to
                // follow after this, for example when you handle an error inside a set
                // of braces which are matched by a parent rule in your grammar.
                //
                // Hence we require that every error handling/recovery attempt
                // *after we've hit EOF* has a diminishing state stack: this means
                // we will ultimately have unwound the state stack entirely and thus
                // terminate the parse in a controlled fashion even when we have
                // very complex error/recovery code interplay in the core + user
                // action code blocks:









                if (symbol === EOF) {
                    if (lastEofErrorStateDepth > sp - 1 - depth) {
                        lastEofErrorStateDepth = sp - 1 - depth;
                    } else {









                        --stack_probe; // popStack(1): [symbol, action]
                        state = sstack[stack_probe];
                        ++depth;
                        continue;
                    }
                }
                return depth;
            }
            if (state === 0 /* $accept rule */ || stack_probe < 1) {









                return -1; // No suitable error recovery rule available.
            }
            --stack_probe; // popStack(1): [symbol, action]
            state = sstack[stack_probe];
            ++depth;
        }









        return -1; // No suitable error recovery rule available.
    }


    try {
        this.__reentrant_call_depth++;

        lexer.setInput(input, sharedState_yy);

        // NOTE: we *assume* no lexer pre/post handlers are set up *after* 
        // this initial `setInput()` call: hence we can now check and decide
        // whether we'll go with the standard, slower, lex() API or the
        // `fast_lex()` one:
        if (typeof lexer.canIUse === 'function') {
            var lexerInfo = lexer.canIUse();
            if (lexerInfo.fastLex && typeof fastLex === 'function') {
                lex = fastLex;
            }
        } 



        vstack[sp] = null;
        sstack[sp] = 0;
        stack[sp] = 0;
        ++sp;





        if (this.pre_parse) {
            this.pre_parse.call(this, sharedState_yy);
        }
        if (sharedState_yy.pre_parse) {
            sharedState_yy.pre_parse.call(this, sharedState_yy);
        }

        newState = sstack[sp - 1];
        for (;;) {
            // retrieve state number from top of stack
            state = newState;               // sstack[sp - 1];

            // use default actions if available
            if (this.defaultActions[state]) {
                action = 2;
                newState = this.defaultActions[state];
            } else {
                // The single `==` condition below covers both these `===` comparisons in a single
                // operation:
                //
                //     if (symbol === null || typeof symbol === 'undefined') ...
                if (!symbol) {
                    symbol = lex();
                }
                // read action for current state and first input
                t = (table[state] && table[state][symbol]) || NO_ACTION;
                newState = t[1];
                action = t[0];











                // handle parse error
                if (!action) {
                    // first see if there's any chance at hitting an error recovery rule:
                    var error_rule_depth = locateNearestErrorRecoveryRule(state);
                    var errStr = null;
                    var errSymbolDescr = (this.describeSymbol(symbol) || symbol);
                    var expected = this.collect_expected_token_set(state);

                    if (!recovering) {
                        // Report error
                        if (typeof lexer.yylineno === 'number') {
                            errStr = 'Parse error on line ' + (lexer.yylineno + 1) + ': ';
                        } else {
                            errStr = 'Parse error: ';
                        }

                        if (typeof lexer.showPosition === 'function') {
                            errStr += '\n' + lexer.showPosition(79 - 10, 10) + '\n';
                        }
                        if (expected.length) {
                            errStr += 'Expecting ' + expected.join(', ') + ', got unexpected ' + errSymbolDescr;
                        } else {
                            errStr += 'Unexpected ' + errSymbolDescr;
                        }

                        p = this.constructParseErrorInfo(errStr, null, expected, (error_rule_depth >= 0));

                        // DO NOT cleanup the old one before we start the new error info track:
                        // the old one will *linger* on the error stack and stay alive until we 
                        // invoke the parser's cleanup API!
                        recoveringErrorInfo = this.shallowCopyErrorInfo(p);










                        r = this.parseError(p.errStr, p, this.JisonParserError);
                        if (typeof r !== 'undefined') {
                            retval = r;
                            break;
                        }

                        // Protect against overly blunt userland `parseError` code which *sets*
                        // the `recoverable` flag without properly checking first:
                        // we always terminate the parse when there's no recovery rule available anyhow!
                        if (!p.recoverable || error_rule_depth < 0) {
                            break;
                        } else {
                            // TODO: allow parseError callback to edit symbol and or state at the start of the error recovery process...
                        }
                    }










                    var esp = recoveringErrorInfo.info_stack_pointer;

                    // just recovered from another error
                    if (recovering === ERROR_RECOVERY_TOKEN_DISCARD_COUNT && error_rule_depth >= 0) {
                        // SHIFT current lookahead and grab another
                        recoveringErrorInfo.symbol_stack[esp] = symbol;
                        recoveringErrorInfo.value_stack[esp] = shallow_copy(lexer.yytext);

                        recoveringErrorInfo.state_stack[esp] = newState; // push state
                        ++esp;

                        // Pick up the lexer details for the current symbol as that one is not 'look-ahead' any more:





                        preErrorSymbol = 0;
                        symbol = lex();









                    }

                    // try to recover from error
                    if (error_rule_depth < 0) {
                        ASSERT(recovering > 0, "line 897");
                        recoveringErrorInfo.info_stack_pointer = esp;

                        // barf a fatal hairball when we're out of look-ahead symbols and none hit a match
                        // while we are still busy recovering from another error:
                        var po = this.__error_infos[this.__error_infos.length - 1];

                        // Report error
                        if (typeof lexer.yylineno === 'number') {
                            errStr = 'Parsing halted on line ' + (lexer.yylineno + 1) + ' while starting to recover from another error';
                        } else {
                            errStr = 'Parsing halted while starting to recover from another error';
                        }

                        if (po) {
                            errStr += ' -- previous error which resulted in this fatal result: ' + po.errStr;
                        } else {
                            errStr += ': ';
                        }

                        if (typeof lexer.showPosition === 'function') {
                            errStr += '\n' + lexer.showPosition(79 - 10, 10) + '\n';
                        }
                        if (expected.length) {
                            errStr += 'Expecting ' + expected.join(', ') + ', got unexpected ' + errSymbolDescr;
                        } else {
                            errStr += 'Unexpected ' + errSymbolDescr;
                        }

                        p = this.constructParseErrorInfo(errStr, null, expected, false);
                        if (po) {
                            p.extra_error_attributes = po;
                        }

                        r = this.parseError(p.errStr, p, this.JisonParserError);
                        if (typeof r !== 'undefined') {
                            retval = r;
                        }
                        break;
                    }

                    preErrorSymbol = (symbol === TERROR ? 0 : symbol); // save the lookahead token
                    symbol = TERROR;            // insert generic error symbol as new lookahead

                    const EXTRA_STACK_SAMPLE_DEPTH = 3;

                    // REDUCE/COMBINE the pushed terms/tokens to a new ERROR token:
                    recoveringErrorInfo.symbol_stack[esp] = preErrorSymbol;
                    if (errStr) {
                        recoveringErrorInfo.value_stack[esp] = {
                            yytext: shallow_copy(lexer.yytext),
                            errorRuleDepth: error_rule_depth,
                            errStr: errStr,
                            errorSymbolDescr: errSymbolDescr,
                            expectedStr: expected,
                            stackSampleLength: error_rule_depth + EXTRA_STACK_SAMPLE_DEPTH
                        };









                    } else {
                        recoveringErrorInfo.value_stack[esp] = {
                            yytext: shallow_copy(lexer.yytext),
                            errorRuleDepth: error_rule_depth,
                            stackSampleLength: error_rule_depth + EXTRA_STACK_SAMPLE_DEPTH
                        };
                    }

                    recoveringErrorInfo.state_stack[esp] = newState || NO_ACTION[1];

                    ++esp;
                    recoveringErrorInfo.info_stack_pointer = esp;

                    yyval.$ = recoveringErrorInfo;


                    yyrulelen = error_rule_depth;









                    r = this.performAction.call(yyval, NO_ACTION[1], sp - 1, vstack);

                    if (typeof r !== 'undefined') {
                        retval = r;
                        break;
                    }

                    // pop off stack
                    sp -= yyrulelen;

                    // and move the top entries + discarded part of the parse stacks onto the error info stack:
                    for (var idx = sp - EXTRA_STACK_SAMPLE_DEPTH, top = idx + yyrulelen; idx < top; idx++, esp++) {
                        recoveringErrorInfo.symbol_stack[esp] = stack[idx];
                        recoveringErrorInfo.value_stack[esp] = shallow_copy(vstack[idx]);

                        recoveringErrorInfo.state_stack[esp] = sstack[idx];
                    }

                    recoveringErrorInfo.symbol_stack[esp] = TERROR;
                    recoveringErrorInfo.value_stack[esp] = shallow_copy(yyval.$);


                    // goto new state = table[STATE][NONTERMINAL]
                    newState = sstack[sp - 1];

                    if (this.defaultActions[newState]) {
                        recoveringErrorInfo.state_stack[esp] = this.defaultActions[newState];
                    } else {
                        t = (table[newState] && table[newState][symbol]) || NO_ACTION;
                        recoveringErrorInfo.state_stack[esp] = t[1];
                    }

                    ++esp;
                    recoveringErrorInfo.info_stack_pointer = esp;

                    // allow N (default: 3) real symbols to be shifted before reporting a new error
                    recovering = ERROR_RECOVERY_TOKEN_DISCARD_COUNT;










                    // Now duplicate the standard parse machine here, at least its initial
                    // couple of rounds until the TERROR symbol is **pushed onto the parse stack**,
                    // as we wish to push something special then!
                    //
                    // Run the state machine in this copy of the parser state machine
                    // until we *either* consume the error symbol (and its related information)
                    // *or* we run into another error while recovering from this one
                    // *or* we execute a `reduce` action which outputs a final parse
                    // result (yes, that MAY happen!).
                    //
                    // We stay in this secondary parse loop until we have completed
                    // the *error recovery phase* as the main parse loop (further below)
                    // is optimized for regular parse operation and DOES NOT cope with
                    // error recovery *at all*.
                    //
                    // We call the secondary parse loop just below the "slow parse loop",
                    // while the main parse loop, which is an almost-duplicate of this one,
                    // yet optimized for regular parse operation, is called the "fast
                    // parse loop".
                    //
                    // Compare this to `bison` & (vanilla) `jison`, both of which have
                    // only a single parse loop, which handles everything. Our goal is
                    // to eke out every drop of performance in the main parse loop...

                    ASSERT(recoveringErrorInfo, "line 1049");
                    ASSERT(symbol === TERROR, "line 1050");
                    ASSERT(!action, "line 1051");
                    var errorSymbolFromParser = true;
                    for (;;) {
                        // retrieve state number from top of stack
                        state = newState;               // sstack[sp - 1];

                        // use default actions if available
                        if (this.defaultActions[state]) {
                            action = 2;
                            newState = this.defaultActions[state];
                        } else {
                            // The single `==` condition below covers both these `===` comparisons in a single
                            // operation:
                            //
                            //     if (symbol === null || typeof symbol === 'undefined') ...
                            if (!symbol) {
                                symbol = lex();
                                // **Warning: Edge Case**: the *lexer* may produce
                                // TERROR tokens of its own volition: *those* TERROR
                                // tokens should be treated like *regular tokens*
                                // i.e. tokens which have a lexer-provided `yyvalue`

                                errorSymbolFromParser = false;
                            }
                            // read action for current state and first input
                            t = (table[state] && table[state][symbol]) || NO_ACTION;
                            newState = t[1];
                            action = t[0];










                            // encountered another parse error? If so, break out to main loop
                            // and take it from there!
                            if (!action) {










                                ASSERT(recoveringErrorInfo, "line 1087");

                                // Prep state variables so that upon breaking out of
                                // this "slow parse loop" and hitting the `continue;`
                                // statement in the outer "fast parse loop" we redo
                                // the exact same state table lookup as the one above
                                // so that the outer=main loop will also correctly
                                // detect the 'parse error' state (`!action`) we have
                                // just encountered above.
                                newState = state;
                                break;
                            }
                        }










                        switch (action) {
                        // catch misc. parse failures:
                        default:
                            // this shouldn't happen, unless resolve defaults are off
                            //
                            // SILENTLY SIGNAL that the outer "fast parse loop" should
                            // take care of this internal error condition:
                            // prevent useless code duplication now/here.
                            break;

                        // shift:
                        case 1:
                            stack[sp] = symbol;
                            // ### Note/Warning ###
                            //
                            // The *lexer* may also produce TERROR tokens on its own,
                            // so we specifically test for the TERROR we did set up
                            // in the error recovery logic further above!
                            if (symbol === TERROR && errorSymbolFromParser) {
                                // Push a special value onto the stack when we're
                                // shifting the `error` symbol that is related to the
                                // error we're recovering from.
                                ASSERT(recoveringErrorInfo, "line 1131");
                                vstack[sp] = recoveringErrorInfo;
                            } else {
                                ASSERT(symbol !== 0, "line 1135");
                                ASSERT(preErrorSymbol === 0, "line 1136");
                                vstack[sp] = lexer.yytext;

                            }
                            sstack[sp] = newState; // push state

                            ++sp;
                            symbol = 0;
                            // **Warning: Edge Case**: the *lexer* may have produced
                            // TERROR tokens of its own volition: *those* TERROR
                            // tokens should be treated like *regular tokens*
                            // i.e. tokens which have a lexer-provided `yyvalue`

                            errorSymbolFromParser = false;
                            if (!preErrorSymbol) { // normal execution / no error
                                // Pick up the lexer details for the current symbol as that one is not 'look-ahead' any more:





                                if (recovering > 0) {
                                    recovering--;









                                }
                            } else {
                                // error just occurred, resume old lookahead f/ before error, *unless* that drops us straight back into error mode:
                                ASSERT(recovering > 0, "line 1163");
                                symbol = preErrorSymbol;
                                preErrorSymbol = 0;









                                // read action for current state and first input
                                t = (table[newState] && table[newState][symbol]) || NO_ACTION;
                                if (!t[0] || symbol === TERROR) {
                                    // forget about that symbol and move forward: this wasn't a 'forgot to insert' error type where
                                    // (simple) stuff might have been missing before the token which caused the error we're
                                    // recovering from now...
                                    //
                                    // Also check if the LookAhead symbol isn't the ERROR token we set as part of the error
                                    // recovery, for then this we would we idling (cycling) on the error forever.
                                    // Yes, this does not take into account the possibility that the *lexer* may have
                                    // produced a *new* TERROR token all by itself, but that would be a very peculiar grammar!









                                    symbol = 0;
                                }
                            }

                            // once we have pushed the special ERROR token value,
                            // we REMAIN in this inner, "slow parse loop" until
                            // the entire error recovery phase has completed.
                            //
                            // ### Note About Edge Case ###
                            //
                            // Userland action code MAY already have 'reset' the
                            // error recovery phase marker `recovering` to ZERO(0)
                            // while the error symbol hasn't been shifted onto
                            // the stack yet. Hence we only exit this "slow parse loop"
                            // when *both* conditions are met!
                            ASSERT(preErrorSymbol === 0, "line 1194");
                            if (recovering === 0) {
                                break;
                            }
                            continue;

                        // reduce:
                        case 2:
                            this_production = this.productions_[newState - 1];  // `this.productions_[]` is zero-based indexed while states start from 1 upwards...
                            yyrulelen = this_production[1];










                            r = this.performAction.call(yyval, newState, sp - 1, vstack);

                            if (typeof r !== 'undefined') {
                                // signal end of error recovery loop AND end of outer parse loop
                                action = 3;
                                sp = -2;      // magic number: signal outer "fast parse loop" ACCEPT state that we already have a properly set up `retval` parser return value.
                                retval = r;
                                break;
                            }

                            // pop off stack
                            sp -= yyrulelen;

                            // don't overwrite the `symbol` variable: use a local var to speed things up:
                            var ntsymbol = this_production[0];    // push nonterminal (reduce)
                            stack[sp] = ntsymbol;
                            vstack[sp] = yyval.$;

                            // goto new state = table[STATE][NONTERMINAL]
                            newState = table[sstack[sp - 1]][ntsymbol];
                            sstack[sp] = newState;
                            ++sp;









                            continue;

                        // accept:
                        case 3:
                            retval = true;
                            // Return the `$accept` rule's `$$` result, if available.
                            //
                            // Also note that JISON always adds this top-most `$accept` rule (with implicit,
                            // default, action):
                            //
                            //     $accept: <startSymbol> $end
                            //                  %{ $$ = $1; @$ = @1; %}
                            //
                            // which, combined with the parse kernel's `$accept` state behaviour coded below,
                            // will produce the `$$` value output of the <startSymbol> rule as the parse result,
                            // IFF that result is *not* `undefined`. (See also the parser kernel code.)
                            //
                            // In code:
                            //
                            //                  %{
                            //                      @$ = @1;            // if location tracking support is included
                            //                      if (typeof $1 !== 'undefined')
                            //                          return $1;
                            //                      else
                            //                          return true;           // the default parse result if the rule actions don't produce anything
                            //                  %}
                            sp--;
                            if (sp >= 0 && typeof vstack[sp] !== 'undefined') {
                                retval = vstack[sp];
                            }
                            sp = -2;      // magic number: signal outer "fast parse loop" ACCEPT state that we already have a properly set up `retval` parser return value.
                            break;
                        }

                        // break out of loop: we accept or fail with error
                        break;
                    }

                    // should we also break out of the regular/outer parse loop,
                    // i.e. did the parser already produce a parse result in here?!
                    // *or* did we hit an unsupported parse state, to be handled
                    // in the `switch/default` code further below?
                    ASSERT(action !== 2, "line 1272");
                    if (!action || action === 1) {
                        continue;
                    }
                }


            }










            switch (action) {
            // catch misc. parse failures:
            default:
                // this shouldn't happen, unless resolve defaults are off
                if (action instanceof Array) {
                    p = this.constructParseErrorInfo('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol, null, null, false);
                    r = this.parseError(p.errStr, p, this.JisonParserError);
                    if (typeof r !== 'undefined') {
                        retval = r;
                    }
                    break;
                }
                // Another case of better safe than sorry: in case state transitions come out of another error recovery process
                // or a buggy LUT (LookUp Table):
                p = this.constructParseErrorInfo('Parsing halted. No viable error recovery approach available due to internal system failure.', null, null, false);
                r = this.parseError(p.errStr, p, this.JisonParserError);
                if (typeof r !== 'undefined') {
                    retval = r;
                }
                break;

            // shift:
            case 1:
                stack[sp] = symbol;
                vstack[sp] = lexer.yytext;

                sstack[sp] = newState; // push state

                ++sp;
                symbol = 0;

                ASSERT(preErrorSymbol === 0, "line 1352");         // normal execution / no error
                ASSERT(recovering === 0, "line 1353");             // normal execution / no error

                // Pick up the lexer details for the current symbol as that one is not 'look-ahead' any more:




                continue;

            // reduce:
            case 2:
                ASSERT(preErrorSymbol === 0, "line 1364");         // normal execution / no error
                ASSERT(recovering === 0, "line 1365");             // normal execution / no error

                this_production = this.productions_[newState - 1];  // `this.productions_[]` is zero-based indexed while states start from 1 upwards...
                yyrulelen = this_production[1];










                r = this.performAction.call(yyval, newState, sp - 1, vstack);

                if (typeof r !== 'undefined') {
                    retval = r;
                    break;
                }

                // pop off stack
                sp -= yyrulelen;

                // don't overwrite the `symbol` variable: use a local var to speed things up:
                var ntsymbol = this_production[0];    // push nonterminal (reduce)
                stack[sp] = ntsymbol;
                vstack[sp] = yyval.$;

                // goto new state = table[STATE][NONTERMINAL]
                newState = table[sstack[sp - 1]][ntsymbol];
                sstack[sp] = newState;
                ++sp;









                continue;

            // accept:
            case 3:
                if (sp !== -2) {
                    retval = true;
                    // Return the `$accept` rule's `$$` result, if available.
                    //
                    // Also note that JISON always adds this top-most `$accept` rule (with implicit,
                    // default, action):
                    //
                    //     $accept: <startSymbol> $end
                    //                  %{ $$ = $1; @$ = @1; %}
                    //
                    // which, combined with the parse kernel's `$accept` state behaviour coded below,
                    // will produce the `$$` value output of the <startSymbol> rule as the parse result,
                    // IFF that result is *not* `undefined`. (See also the parser kernel code.)
                    //
                    // In code:
                    //
                    //                  %{
                    //                      @$ = @1;            // if location tracking support is included
                    //                      if (typeof $1 !== 'undefined')
                    //                          return $1;
                    //                      else
                    //                          return true;           // the default parse result if the rule actions don't produce anything
                    //                  %}
                    sp--;
                    if (typeof vstack[sp] !== 'undefined') {
                        retval = vstack[sp];
                    }
                }
                break;
            }

            // break out of loop: we accept or fail with error
            break;
        }
    } catch (ex) {
        // report exceptions through the parseError callback too, but keep the exception intact
        // if it is a known parser or lexer error which has been thrown by parseError() already:
        if (ex instanceof this.JisonParserError) {
            throw ex;
        }
        else if (lexer && typeof lexer.JisonLexerError === 'function' && ex instanceof lexer.JisonLexerError) {
            throw ex;
        }

        p = this.constructParseErrorInfo('Parsing aborted due to exception.', ex, null, false);
        retval = false;
        r = this.parseError(p.errStr, p, this.JisonParserError);
        if (typeof r !== 'undefined') {
            retval = r;
        }
    } finally {
        retval = this.cleanupAfterParse(retval, true, true);
        this.__reentrant_call_depth--;
    }   // /finally

    return retval;
}
};
parser.originalParseError = parser.parseError;
parser.originalQuoteName = parser.quoteName;
/* lexer generated by jison-lex 0.6.1-215 */

/*
 * Returns a Lexer object of the following structure:
 *
 *  Lexer: {
 *    yy: {}     The so-called "shared state" or rather the *source* of it;
 *               the real "shared state" `yy` passed around to
 *               the rule actions, etc. is a direct reference!
 *
 *               This "shared context" object was passed to the lexer by way of 
 *               the `lexer.setInput(str, yy)` API before you may use it.
 *
 *               This "shared context" object is passed to the lexer action code in `performAction()`
 *               so userland code in the lexer actions may communicate with the outside world 
 *               and/or other lexer rules' actions in more or less complex ways.
 *
 *  }
 *
 *  Lexer.prototype: {
 *    EOF: 1,
 *    ERROR: 2,
 *
 *    yy:        The overall "shared context" object reference.
 *
 *    JisonLexerError: function(msg, hash),
 *
 *    performAction: function lexer__performAction(yy, yyrulenumber, YY_START),
 *
 *               The function parameters and `this` have the following value/meaning:
 *               - `this`    : reference to the `lexer` instance. 
 *                               `yy_` is an alias for `this` lexer instance reference used internally.
 *
 *               - `yy`      : a reference to the `yy` "shared state" object which was passed to the lexer
 *                             by way of the `lexer.setInput(str, yy)` API before.
 *
 *                             Note:
 *                             The extra arguments you specified in the `%parse-param` statement in your
 *                             **parser** grammar definition file are passed to the lexer via this object
 *                             reference as member variables.
 *
 *               - `yyrulenumber`   : index of the matched lexer rule (regex), used internally.
 *
 *               - `YY_START`: the current lexer "start condition" state.
 *
 *    parseError: function(str, hash, ExceptionClass),
 *
 *    constructLexErrorInfo: function(error_message, is_recoverable),
 *               Helper function.
 *               Produces a new errorInfo 'hash object' which can be passed into `parseError()`.
 *               See it's use in this lexer kernel in many places; example usage:
 *
 *                   var infoObj = lexer.constructParseErrorInfo('fail!', true);
 *                   var retVal = lexer.parseError(infoObj.errStr, infoObj, lexer.JisonLexerError);
 *
 *    options: { ... lexer %options ... },
 *
 *    lex: function(),
 *               Produce one token of lexed input, which was passed in earlier via the `lexer.setInput()` API.
 *               You MAY use the additional `args...` parameters as per `%parse-param` spec of the **lexer** grammar:
 *               these extra `args...` are added verbatim to the `yy` object reference as member variables.
 *
 *               WARNING:
 *               Lexer's additional `args...` parameters (via lexer's `%parse-param`) MAY conflict with
 *               any attributes already added to `yy` by the **parser** or the jison run-time; 
 *               when such a collision is detected an exception is thrown to prevent the generated run-time 
 *               from silently accepting this confusing and potentially hazardous situation! 
 *
 *    cleanupAfterLex: function(do_not_nuke_errorinfos),
 *               Helper function.
 *
 *               This helper API is invoked when the **parse process** has completed: it is the responsibility
 *               of the **parser** (or the calling userland code) to invoke this method once cleanup is desired. 
 *
 *               This helper may be invoked by user code to ensure the internal lexer gets properly garbage collected.
 *
 *    setInput: function(input, [yy]),
 *
 *
 *    input: function(),
 *
 *
 *    unput: function(str),
 *
 *
 *    more: function(),
 *
 *
 *    reject: function(),
 *
 *
 *    less: function(n),
 *
 *
 *    pastInput: function(n),
 *
 *
 *    upcomingInput: function(n),
 *
 *
 *    showPosition: function(),
 *
 *
 *    test_match: function(regex_match_array, rule_index),
 *
 *
 *    next: function(),
 *
 *
 *    begin: function(condition),
 *
 *
 *    pushState: function(condition),
 *
 *
 *    popState: function(),
 *
 *
 *    topState: function(),
 *
 *
 *    _currentRules: function(),
 *
 *
 *    stateStackSize: function(),
 *
 *
 *    performAction: function(yy, yy_, yyrulenumber, YY_START),
 *
 *
 *    rules: [...],
 *
 *
 *    conditions: {associative list: name ==> set},
 *  }
 *
 *
 *  token location info (`yylloc`): {
 *    first_line: n,
 *    last_line: n,
 *    first_column: n,
 *    last_column: n,
 *    range: [start_number, end_number]
 *               (where the numbers are indexes into the input string, zero-based)
 *  }
 *
 * ---
 *
 * The `parseError` function receives a 'hash' object with these members for lexer errors:
 *
 *  {
 *    text:        (matched text)
 *    token:       (the produced terminal token, if any)
 *    token_id:    (the produced terminal token numeric ID, if any)
 *    line:        (yylineno)
 *    loc:         (yylloc)
 *    recoverable: (boolean: TRUE when the parser MAY have an error recovery rule
 *                  available for this particular error)
 *    yy:          (object: the current parser internal "shared state" `yy`
 *                  as is also available in the rule actions; this can be used,
 *                  for instance, for advanced error analysis and reporting)
 *    lexer:       (reference to the current lexer instance used by the parser)
 *  }
 *
 * while `this` will reference the current lexer instance.
 *
 * When `parseError` is invoked by the lexer, the default implementation will
 * attempt to invoke `yy.parser.parseError()`; when this callback is not provided
 * it will try to invoke `yy.parseError()` instead. When that callback is also not
 * provided, a `JisonLexerError` exception will be thrown containing the error
 * message and `hash`, as constructed by the `constructLexErrorInfo()` API.
 *
 * Note that the lexer's `JisonLexerError` error class is passed via the
 * `ExceptionClass` argument, which is invoked to construct the exception
 * instance to be thrown, so technically `parseError` will throw the object
 * produced by the `new ExceptionClass(str, hash)` JavaScript expression.
 *
 * ---
 *
 * You can specify lexer options by setting / modifying the `.options` object of your Lexer instance.
 * These options are available:
 *
 * (Options are permanent.)
 *  
 *  yy: {
 *      parseError: function(str, hash, ExceptionClass)
 *                 optional: overrides the default `parseError` function.
 *  }
 *
 *  lexer.options: {
 *      pre_lex:  function()
 *                 optional: is invoked before the lexer is invoked to produce another token.
 *                 `this` refers to the Lexer object.
 *      post_lex: function(token) { return token; }
 *                 optional: is invoked when the lexer has produced a token `token`;
 *                 this function can override the returned token value by returning another.
 *                 When it does not return any (truthy) value, the lexer will return
 *                 the original `token`.
 *                 `this` refers to the Lexer object.
 *
 * WARNING: the next set of options are not meant to be changed. They echo the abilities of
 * the lexer as per when it was compiled!
 *
 *      ranges: boolean
 *                 optional: `true` ==> token location info will include a .range[] member.
 *      flex: boolean
 *                 optional: `true` ==> flex-like lexing behaviour where the rules are tested
 *                 exhaustively to find the longest match.
 *      backtrack_lexer: boolean
 *                 optional: `true` ==> lexer regexes are tested in order and for invoked;
 *                 the lexer terminates the scan when a token is returned by the action code.
 *      xregexp: boolean
 *                 optional: `true` ==> lexer rule regexes are "extended regex format" requiring the
 *                 `XRegExp` library. When this %option has not been specified at compile time, all lexer
 *                 rule regexes have been written as standard JavaScript RegExp expressions.
 *  }
 */


var lexer = function() {
  /**
   * See also:
   * http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript/#35881508
   * but we keep the prototype.constructor and prototype.name assignment lines too for compatibility
   * with userland code which might access the derived class in a 'classic' way.
   *
   * @public
   * @constructor
   * @nocollapse
   */
  function JisonLexerError(msg, hash) {
    Object.defineProperty(this, 'name', {
      enumerable: false,
      writable: false,
      value: 'JisonLexerError'
    });

    if (msg == null)
      msg = '???';

    Object.defineProperty(this, 'message', {
      enumerable: false,
      writable: true,
      value: msg
    });

    this.hash = hash;
    var stacktrace;

    if (hash && hash.exception instanceof Error) {
      var ex2 = hash.exception;
      this.message = ex2.message || msg;
      stacktrace = ex2.stack;
    }

    if (!stacktrace) {
      if (Error.hasOwnProperty('captureStackTrace')) {
        // V8
        Error.captureStackTrace(this, this.constructor);
      } else {
        stacktrace = new Error(msg).stack;
      }
    }

    if (stacktrace) {
      Object.defineProperty(this, 'stack', {
        enumerable: false,
        writable: false,
        value: stacktrace
      });
    }
  }

  if (typeof Object.setPrototypeOf === 'function') {
    Object.setPrototypeOf(JisonLexerError.prototype, Error.prototype);
  } else {
    JisonLexerError.prototype = Object.create(Error.prototype);
  }

  JisonLexerError.prototype.constructor = JisonLexerError;
  JisonLexerError.prototype.name = 'JisonLexerError';

  var lexer = {
    
// Code Generator Information Report
// ---------------------------------
//
// Options:
//
//   backtracking: .................... false
//   location.ranges: ................. false
//   location line+column tracking: ... true
//
//
// Forwarded Parser Analysis flags:
//
//   uses yyleng: ..................... false
//   uses yylineno: ................... false
//   uses yytext: ..................... false
//   uses yylloc: ..................... false
//   uses lexer values: ............... true / true
//   location tracking: ............... false
//   location assignment: ............. false
//
//
// Lexer Analysis flags:
//
//   uses yyleng: ..................... ???
//   uses yylineno: ................... ???
//   uses yytext: ..................... ???
//   uses yylloc: ..................... ???
//   uses ParseError API: ............. ???
//   uses yyerror: .................... ???
//   uses location tracking & editing:  ???
//   uses more() API: ................. ???
//   uses unput() API: ................ ???
//   uses reject() API: ............... ???
//   uses less() API: ................. ???
//   uses display APIs pastInput(), upcomingInput(), showPosition():
//        ............................. ???
//   uses describeYYLLOC() API: ....... ???
//
// --------- END OF REPORT -----------

EOF: 1,
    ERROR: 2,

    // JisonLexerError: JisonLexerError,        /// <-- injected by the code generator

    // options: {},                             /// <-- injected by the code generator

    // yy: ...,                                 /// <-- injected by setInput()

    __currentRuleSet__: null,                   /// INTERNAL USE ONLY: internal rule set cache for the current lexer state  

    __error_infos: [],                          /// INTERNAL USE ONLY: the set of lexErrorInfo objects created since the last cleanup  
    __decompressed: false,                      /// INTERNAL USE ONLY: mark whether the lexer instance has been 'unfolded' completely and is now ready for use  
    done: false,                                /// INTERNAL USE ONLY  
    _backtrack: false,                          /// INTERNAL USE ONLY  
    _input: '',                                 /// INTERNAL USE ONLY  
    _more: false,                               /// INTERNAL USE ONLY  
    _signaled_error_token: false,               /// INTERNAL USE ONLY  
    conditionStack: [],                         /// INTERNAL USE ONLY; managed via `pushState()`, `popState()`, `topState()` and `stateStackSize()`  
    match: '',                                  /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks input which has been matched so far for the lexer token under construction. `match` is identical to `yytext` except that this one still contains the matched input string after `lexer.performAction()` has been invoked, where userland code MAY have changed/replaced the `yytext` value entirely!  
    matched: '',                                /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks entire input which has been matched so far  
    matches: false,                             /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks RE match result for last (successful) match attempt  
    yytext: '',                                 /// ADVANCED USE ONLY: tracks input which has been matched so far for the lexer token under construction; this value is transferred to the parser as the 'token value' when the parser consumes the lexer token produced through a call to the `lex()` API.  
    offset: 0,                                  /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks the 'cursor position' in the input string, i.e. the number of characters matched so far  
    yyleng: 0,                                  /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: length of matched input for the token under construction (`yytext`)  
    yylineno: 0,                                /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: 'line number' at which the token under construction is located  
    yylloc: null,                               /// READ-ONLY EXTERNAL ACCESS - ADVANCED USE ONLY: tracks location info (lines + columns) for the token under construction  

    /**
     * INTERNAL USE: construct a suitable error info hash object instance for `parseError`.
     * 
     * @public
     * @this {RegExpLexer}
     */
    constructLexErrorInfo: function lexer_constructLexErrorInfo(msg, recoverable, show_input_position) {
      msg = '' + msg;

      // heuristic to determine if the error message already contains a (partial) source code dump
      // as produced by either `showPosition()` or `prettyPrintRange()`:
      if (show_input_position == undefined) {
        show_input_position = !(msg.indexOf('\n') > 0 && msg.indexOf('^') > 0);
      }

      if (this.yylloc && show_input_position) {
        if (typeof this.prettyPrintRange === 'function') {
          var pretty_src = this.prettyPrintRange(this.yylloc);

          if (!/\n\s*$/.test(msg)) {
            msg += '\n';
          }

          msg += '\n  Erroneous area:\n' + this.prettyPrintRange(this.yylloc);
        } else if (typeof this.showPosition === 'function') {
          var pos_str = this.showPosition();

          if (pos_str) {
            if (msg.length && msg[msg.length - 1] !== '\n' && pos_str[0] !== '\n') {
              msg += '\n' + pos_str;
            } else {
              msg += pos_str;
            }
          }
        }
      }

      /** @constructor */
      var pei = {
        errStr: msg,
        recoverable: !!recoverable,
        text: this.match,           // This one MAY be empty; userland code should use the `upcomingInput` API to obtain more text which follows the 'lexer cursor position'...  
        token: null,
        line: this.yylineno,
        loc: this.yylloc,
        yy: this.yy,
        lexer: this,

        /**
         * and make sure the error info doesn't stay due to potential
         * ref cycle via userland code manipulations.
         * These would otherwise all be memory leak opportunities!
         * 
         * Note that only array and object references are nuked as those
         * constitute the set of elements which can produce a cyclic ref.
         * The rest of the members is kept intact as they are harmless.
         * 
         * @public
         * @this {LexErrorInfo}
         */
        destroy: function destructLexErrorInfo() {
          // remove cyclic references added to error info:
          // info.yy = null;
          // info.lexer = null;
          // ...
          var rec = !!this.recoverable;

          for (var key in this) {
            if (this.hasOwnProperty(key) && typeof key === 'object') {
              this[key] = undefined;
            }
          }

          this.recoverable = rec;
        }
      };

      // track this instance so we can `destroy()` it once we deem it superfluous and ready for garbage collection!
      this.__error_infos.push(pei);

      return pei;
    },

    /**
     * handler which is invoked when a lexer error occurs.
     * 
     * @public
     * @this {RegExpLexer}
     */
    parseError: function lexer_parseError(str, hash, ExceptionClass) {
      if (!ExceptionClass) {
        ExceptionClass = this.JisonLexerError;
      }

      if (this.yy) {
        if (this.yy.parser && typeof this.yy.parser.parseError === 'function') {
          return this.yy.parser.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;
        } else if (typeof this.yy.parseError === 'function') {
          return this.yy.parseError.call(this, str, hash, ExceptionClass) || this.ERROR;
        }
      }

      throw new ExceptionClass(str, hash);
    },

    /**
     * method which implements `yyerror(str, ...args)` functionality for use inside lexer actions.
     * 
     * @public
     * @this {RegExpLexer}
     */
    yyerror: function yyError(str /*, ...args */) {
      var lineno_msg = '';

      if (this.yylloc) {
        lineno_msg = ' on line ' + (this.yylineno + 1);
      }

      var p = this.constructLexErrorInfo(
        'Lexical error' + lineno_msg + ': ' + str,
        this.options.lexerErrorsAreRecoverable
      );

      // Add any extra args to the hash under the name `extra_error_attributes`:
      var args = Array.prototype.slice.call(arguments, 1);

      if (args.length) {
        p.extra_error_attributes = args;
      }

      return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
    },

    /**
     * final cleanup function for when we have completed lexing the input;
     * make it an API so that external code can use this one once userland
     * code has decided it's time to destroy any lingering lexer error
     * hash object instances and the like: this function helps to clean
     * up these constructs, which *may* carry cyclic references which would
     * otherwise prevent the instances from being properly and timely
     * garbage-collected, i.e. this function helps prevent memory leaks!
     * 
     * @public
     * @this {RegExpLexer}
     */
    cleanupAfterLex: function lexer_cleanupAfterLex(do_not_nuke_errorinfos) {
      // prevent lingering circular references from causing memory leaks:
      this.setInput('', {});

      // nuke the error hash info instances created during this run.
      // Userland code must COPY any data/references
      // in the error hash instance(s) it is more permanently interested in.
      if (!do_not_nuke_errorinfos) {
        for (var i = this.__error_infos.length - 1; i >= 0; i--) {
          var el = this.__error_infos[i];

          if (el && typeof el.destroy === 'function') {
            el.destroy();
          }
        }

        this.__error_infos.length = 0;
      }

      return this;
    },

    /**
     * clear the lexer token context; intended for internal use only
     * 
     * @public
     * @this {RegExpLexer}
     */
    clear: function lexer_clear() {
      this.yytext = '';
      this.yyleng = 0;
      this.match = '';

      // - DO NOT reset `this.matched`
      this.matches = false;

      this._more = false;
      this._backtrack = false;
      var col = (this.yylloc ? this.yylloc.last_column : 0);

      this.yylloc = {
        first_line: this.yylineno + 1,
        first_column: col,
        last_line: this.yylineno + 1,
        last_column: col,
        range: [this.offset, this.offset]
      };
    },

    /**
     * resets the lexer, sets new input
     * 
     * @public
     * @this {RegExpLexer}
     */
    setInput: function lexer_setInput(input, yy) {
      this.yy = yy || this.yy || {};

      // also check if we've fully initialized the lexer instance,
      // including expansion work to be done to go from a loaded
      // lexer to a usable lexer:
      if (!this.__decompressed) {
        // step 1: decompress the regex list:
        var rules = this.rules;

        for (var i = 0, len = rules.length; i < len; i++) {
          var rule_re = rules[i];

          // compression: is the RE an xref to another RE slot in the rules[] table?
          if (typeof rule_re === 'number') {
            rules[i] = rules[rule_re];
          }
        }

        // step 2: unfold the conditions[] set to make these ready for use:
        var conditions = this.conditions;

        for (var k in conditions) {
          var spec = conditions[k];
          var rule_ids = spec.rules;
          var len = rule_ids.length;
          var rule_regexes = new Array(len + 1);             // slot 0 is unused; we use a 1-based index approach here to keep the hottest code in `lexer_next()` fast and simple! 
          var rule_new_ids = new Array(len + 1);

          for (var i = 0; i < len; i++) {
            var idx = rule_ids[i];
            var rule_re = rules[idx];
            rule_regexes[i + 1] = rule_re;
            rule_new_ids[i + 1] = idx;
          }

          spec.rules = rule_new_ids;
          spec.__rule_regexes = rule_regexes;
          spec.__rule_count = len;
        }

        this.__decompressed = true;
      }

      this._input = input || '';
      this.clear();
      this._signaled_error_token = false;
      this.done = false;
      this.yylineno = 0;
      this.matched = '';
      this.conditionStack = ['INITIAL'];
      this.__currentRuleSet__ = null;

      this.yylloc = {
        first_line: 1,
        first_column: 0,
        last_line: 1,
        last_column: 0,
        range: [0, 0]
      };

      this.offset = 0;
      return this;
    },

    /**
     * edit the remaining input via user-specified callback.
     * This can be used to forward-adjust the input-to-parse, 
     * e.g. inserting macro expansions and alike in the
     * input which has yet to be lexed.
     * The behaviour of this API contrasts the `unput()` et al
     * APIs as those act on the *consumed* input, while this
     * one allows one to manipulate the future, without impacting
     * the current `yyloc` cursor location or any history. 
     * 
     * Use this API to help implement C-preprocessor-like
     * `#include` statements, etc.
     * 
     * The provided callback must be synchronous and is
     * expected to return the edited input (string).
     *
     * The `cpsArg` argument value is passed to the callback
     * as-is.
     *
     * `callback` interface: 
     * `function callback(input, cpsArg)`
     * 
     * - `input` will carry the remaining-input-to-lex string
     *   from the lexer.
     * - `cpsArg` is `cpsArg` passed into this API.
     * 
     * The `this` reference for the callback will be set to
     * reference this lexer instance so that userland code
     * in the callback can easily and quickly access any lexer
     * API. 
     *
     * When the callback returns a non-string-type falsey value,
     * we assume the callback did not edit the input and we
     * will using the input as-is.
     *
     * When the callback returns a non-string-type value, it
     * is converted to a string for lexing via the `"" + retval`
     * operation. (See also why: http://2ality.com/2012/03/converting-to-string.html 
     * -- that way any returned object's `toValue()` and `toString()`
     * methods will be invoked in a proper/desirable order.)
     * 
     * @public
     * @this {RegExpLexer}
     */
    editRemainingInput: function lexer_editRemainingInput(callback, cpsArg) {
      var rv = callback.call(this, this._input, cpsArg);

      if (typeof rv !== 'string') {
        if (rv) {
          this._input = '' + rv;
        } 
        // else: keep `this._input` as is.  
      } else {
        this._input = rv;
      }

      return this;
    },

    /**
     * consumes and returns one char from the input
     * 
     * @public
     * @this {RegExpLexer}
     */
    input: function lexer_input() {
      if (!this._input) {
        //this.done = true;    -- don't set `done` as we want the lex()/next() API to be able to produce one custom EOF token match after this anyhow. (lexer can match special <<EOF>> tokens and perform user action code for a <<EOF>> match, but only does so *once*)
        return null;
      }

      var ch = this._input[0];
      this.yytext += ch;
      this.yyleng++;
      this.offset++;
      this.match += ch;
      this.matched += ch;

      // Count the linenumber up when we hit the LF (or a stand-alone CR).
      // On CRLF, the linenumber is incremented when you fetch the CR or the CRLF combo
      // and we advance immediately past the LF as well, returning both together as if
      // it was all a single 'character' only.
      var slice_len = 1;

      var lines = false;

      if (ch === '\n') {
        lines = true;
      } else if (ch === '\r') {
        lines = true;
        var ch2 = this._input[1];

        if (ch2 === '\n') {
          slice_len++;
          ch += ch2;
          this.yytext += ch2;
          this.yyleng++;
          this.offset++;
          this.match += ch2;
          this.matched += ch2;
          this.yylloc.range[1]++;
        }
      }

      if (lines) {
        this.yylineno++;
        this.yylloc.last_line++;
        this.yylloc.last_column = 0;
      } else {
        this.yylloc.last_column++;
      }

      this.yylloc.range[1]++;
      this._input = this._input.slice(slice_len);
      return ch;
    },

    /**
     * unshifts one char (or an entire string) into the input
     * 
     * @public
     * @this {RegExpLexer}
     */
    unput: function lexer_unput(ch) {
      var len = ch.length;
      var lines = ch.split(/(?:\r\n?|\n)/g);
      this._input = ch + this._input;
      this.yytext = this.yytext.substr(0, this.yytext.length - len);
      this.yyleng = this.yytext.length;
      this.offset -= len;
      this.match = this.match.substr(0, this.match.length - len);
      this.matched = this.matched.substr(0, this.matched.length - len);

      if (lines.length > 1) {
        this.yylineno -= lines.length - 1;
        this.yylloc.last_line = this.yylineno + 1;

        // Get last entirely matched line into the `pre_lines[]` array's
        // last index slot; we don't mind when other previously 
        // matched lines end up in the array too. 
        var pre = this.match;

        var pre_lines = pre.split(/(?:\r\n?|\n)/g);

        if (pre_lines.length === 1) {
          pre = this.matched;
          pre_lines = pre.split(/(?:\r\n?|\n)/g);
        }

        this.yylloc.last_column = pre_lines[pre_lines.length - 1].length;
      } else {
        this.yylloc.last_column -= len;
      }

      this.yylloc.range[1] = this.yylloc.range[0] + this.yyleng;
      this.done = false;
      return this;
    },

    /**
     * cache matched text and append it on next action
     * 
     * @public
     * @this {RegExpLexer}
     */
    more: function lexer_more() {
      this._more = true;
      return this;
    },

    /**
     * signal the lexer that this rule fails to match the input, so the
     * next matching rule (regex) should be tested instead.
     * 
     * @public
     * @this {RegExpLexer}
     */
    reject: function lexer_reject() {
      if (this.options.backtrack_lexer) {
        this._backtrack = true;
      } else {
        // when the `parseError()` call returns, we MUST ensure that the error is registered.
        // We accomplish this by signaling an 'error' token to be produced for the current
        // `.lex()` run.
        var lineno_msg = '';

        if (this.yylloc) {
          lineno_msg = ' on line ' + (this.yylineno + 1);
        }

        var p = this.constructLexErrorInfo(
          'Lexical error' + lineno_msg + ': You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).',
          false
        );

        this._signaled_error_token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
      }

      return this;
    },

    /**
     * retain first n characters of the match
     * 
     * @public
     * @this {RegExpLexer}
     */
    less: function lexer_less(n) {
      return this.unput(this.match.slice(n));
    },

    /**
     * return (part of the) already matched input, i.e. for error
     * messages.
     * 
     * Limit the returned string length to `maxSize` (default: 20).
     * 
     * Limit the returned string to the `maxLines` number of lines of
     * input (default: 1).
     * 
     * Negative limit values equal *unlimited*.
     * 
     * @public
     * @this {RegExpLexer}
     */
    pastInput: function lexer_pastInput(maxSize, maxLines) {
      var past = this.matched.substring(0, this.matched.length - this.match.length);

      if (maxSize < 0)
        maxSize = past.length;
      else if (!maxSize)
        maxSize = 20;

      if (maxLines < 0)
        maxLines = past.length;          // can't ever have more input lines than this! 
      else if (!maxLines)
        maxLines = 1;

      // `substr` anticipation: treat \r\n as a single character and take a little
      // more than necessary so that we can still properly check against maxSize
      // after we've transformed and limited the newLines in here:
      past = past.substr(-maxSize * 2 - 2);

      // now that we have a significantly reduced string to process, transform the newlines
      // and chop them, then limit them:
      var a = past.replace(/\r\n|\r/g, '\n').split('\n');

      a = a.slice(-maxLines);
      past = a.join('\n');

      // When, after limiting to maxLines, we still have too much to return,
      // do add an ellipsis prefix...
      if (past.length > maxSize) {
        past = '...' + past.substr(-maxSize);
      }

      return past;
    },

    /**
     * return (part of the) upcoming input, i.e. for error messages.
     * 
     * Limit the returned string length to `maxSize` (default: 20).
     * 
     * Limit the returned string to the `maxLines` number of lines of input (default: 1).
     * 
     * Negative limit values equal *unlimited*.
     *
     * > ### NOTE ###
     * >
     * > *"upcoming input"* is defined as the whole of the both
     * > the *currently lexed* input, together with any remaining input
     * > following that. *"currently lexed"* input is the input 
     * > already recognized by the lexer but not yet returned with
     * > the lexer token. This happens when you are invoking this API
     * > from inside any lexer rule action code block. 
     * >
     * 
     * @public
     * @this {RegExpLexer}
     */
    upcomingInput: function lexer_upcomingInput(maxSize, maxLines) {
      var next = this.match;

      if (maxSize < 0)
        maxSize = next.length + this._input.length;
      else if (!maxSize)
        maxSize = 20;

      if (maxLines < 0)
        maxLines = maxSize;          // can't ever have more input lines than this! 
      else if (!maxLines)
        maxLines = 1;

      // `substring` anticipation: treat \r\n as a single character and take a little
      // more than necessary so that we can still properly check against maxSize
      // after we've transformed and limited the newLines in here:
      if (next.length < maxSize * 2 + 2) {
        next += this._input.substring(0, maxSize * 2 + 2);   // substring is faster on Chrome/V8 
      }

      // now that we have a significantly reduced string to process, transform the newlines
      // and chop them, then limit them:
      var a = next.replace(/\r\n|\r/g, '\n').split('\n');

      a = a.slice(0, maxLines);
      next = a.join('\n');

      // When, after limiting to maxLines, we still have too much to return,
      // do add an ellipsis postfix...
      if (next.length > maxSize) {
        next = next.substring(0, maxSize) + '...';
      }

      return next;
    },

    /**
     * return a string which displays the character position where the
     * lexing error occurred, i.e. for error messages
     * 
     * @public
     * @this {RegExpLexer}
     */
    showPosition: function lexer_showPosition(maxPrefix, maxPostfix) {
      var pre = this.pastInput(maxPrefix).replace(/\s/g, ' ');
      var c = new Array(pre.length + 1).join('-');
      return pre + this.upcomingInput(maxPostfix).replace(/\s/g, ' ') + '\n' + c + '^';
    },

    /**
     * return an YYLLOC info object derived off the given context (actual, preceding, following, current).
     * Use this method when the given `actual` location is not guaranteed to exist (i.e. when
     * it MAY be NULL) and you MUST have a valid location info object anyway:
     * then we take the given context of the `preceding` and `following` locations, IFF those are available,
     * and reconstruct the `actual` location info from those.
     * If this fails, the heuristic is to take the `current` location, IFF available.
     * If this fails as well, we assume the sought location is at/around the current lexer position
     * and then produce that one as a response. DO NOTE that these heuristic/derived location info
     * values MAY be inaccurate!
     *
     * NOTE: `deriveLocationInfo()` ALWAYS produces a location info object *copy* of `actual`, not just
     * a *reference* hence all input location objects can be assumed to be 'constant' (function has no side-effects).
     * 
     * @public
     * @this {RegExpLexer}
     */
    deriveLocationInfo: function lexer_deriveYYLLOC(actual, preceding, following, current) {
      var loc = {
        first_line: 1,
        first_column: 0,
        last_line: 1,
        last_column: 0,
        range: [0, 0]
      };

      if (actual) {
        loc.first_line = actual.first_line | 0;
        loc.last_line = actual.last_line | 0;
        loc.first_column = actual.first_column | 0;
        loc.last_column = actual.last_column | 0;

        if (actual.range) {
          loc.range[0] = actual.range[0] | 0;
          loc.range[1] = actual.range[1] | 0;
        }
      }

      if (loc.first_line <= 0 || loc.last_line < loc.first_line) {
        // plan B: heuristic using preceding and following:
        if (loc.first_line <= 0 && preceding) {
          loc.first_line = preceding.last_line | 0;
          loc.first_column = preceding.last_column | 0;

          if (preceding.range) {
            loc.range[0] = actual.range[1] | 0;
          }
        }

        if ((loc.last_line <= 0 || loc.last_line < loc.first_line) && following) {
          loc.last_line = following.first_line | 0;
          loc.last_column = following.first_column | 0;

          if (following.range) {
            loc.range[1] = actual.range[0] | 0;
          }
        }

        // plan C?: see if the 'current' location is useful/sane too:
        if (loc.first_line <= 0 && current && (loc.last_line <= 0 || current.last_line <= loc.last_line)) {
          loc.first_line = current.first_line | 0;
          loc.first_column = current.first_column | 0;

          if (current.range) {
            loc.range[0] = current.range[0] | 0;
          }
        }

        if (loc.last_line <= 0 && current && (loc.first_line <= 0 || current.first_line >= loc.first_line)) {
          loc.last_line = current.last_line | 0;
          loc.last_column = current.last_column | 0;

          if (current.range) {
            loc.range[1] = current.range[1] | 0;
          }
        }
      }

      // sanitize: fix last_line BEFORE we fix first_line as we use the 'raw' value of the latter
      // or plan D heuristics to produce a 'sensible' last_line value:
      if (loc.last_line <= 0) {
        if (loc.first_line <= 0) {
          loc.first_line = this.yylloc.first_line;
          loc.last_line = this.yylloc.last_line;
          loc.first_column = this.yylloc.first_column;
          loc.last_column = this.yylloc.last_column;
          loc.range[0] = this.yylloc.range[0];
          loc.range[1] = this.yylloc.range[1];
        } else {
          loc.last_line = this.yylloc.last_line;
          loc.last_column = this.yylloc.last_column;
          loc.range[1] = this.yylloc.range[1];
        }
      }

      if (loc.first_line <= 0) {
        loc.first_line = loc.last_line;
        loc.first_column = 0;  // loc.last_column; 
        loc.range[1] = loc.range[0];
      }

      if (loc.first_column < 0) {
        loc.first_column = 0;
      }

      if (loc.last_column < 0) {
        loc.last_column = (loc.first_column > 0 ? loc.first_column : 80);
      }

      return loc;
    },

    /**
     * return a string which displays the lines & columns of input which are referenced 
     * by the given location info range, plus a few lines of context.
     * 
     * This function pretty-prints the indicated section of the input, with line numbers 
     * and everything!
     * 
     * This function is very useful to provide highly readable error reports, while
     * the location range may be specified in various flexible ways:
     * 
     * - `loc` is the location info object which references the area which should be
     *   displayed and 'marked up': these lines & columns of text are marked up by `^`
     *   characters below each character in the entire input range.
     * 
     * - `context_loc` is the *optional* location info object which instructs this
     *   pretty-printer how much *leading* context should be displayed alongside
     *   the area referenced by `loc`. This can help provide context for the displayed
     *   error, etc.
     * 
     *   When this location info is not provided, a default context of 3 lines is
     *   used.
     * 
     * - `context_loc2` is another *optional* location info object, which serves
     *   a similar purpose to `context_loc`: it specifies the amount of *trailing*
     *   context lines to display in the pretty-print output.
     * 
     *   When this location info is not provided, a default context of 1 line only is
     *   used.
     * 
     * Special Notes:
     * 
     * - when the `loc`-indicated range is very large (about 5 lines or more), then
     *   only the first and last few lines of this block are printed while a
     *   `...continued...` message will be printed between them.
     * 
     *   This serves the purpose of not printing a huge amount of text when the `loc`
     *   range happens to be huge: this way a manageable & readable output results
     *   for arbitrary large ranges.
     * 
     * - this function can display lines of input which whave not yet been lexed.
     *   `prettyPrintRange()` can access the entire input!
     * 
     * @public
     * @this {RegExpLexer}
     */
    prettyPrintRange: function lexer_prettyPrintRange(loc, context_loc, context_loc2) {
      loc = this.deriveLocationInfo(loc, context_loc, context_loc2);
      const CONTEXT = 3;
      const CONTEXT_TAIL = 1;
      const MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT = 2;
      var input = this.matched + this._input;
      var lines = input.split('\n');
      var l0 = Math.max(1, (context_loc ? context_loc.first_line : loc.first_line - CONTEXT));
      var l1 = Math.max(1, (context_loc2 ? context_loc2.last_line : loc.last_line + CONTEXT_TAIL));
      var lineno_display_width = 1 + Math.log10(l1 | 1) | 0;
      var ws_prefix = new Array(lineno_display_width).join(' ');
      var nonempty_line_indexes = [];

      var rv = lines.slice(l0 - 1, l1 + 1).map(function injectLineNumber(line, index) {
        var lno = index + l0;
        var lno_pfx = (ws_prefix + lno).substr(-lineno_display_width);
        var rv = lno_pfx + ': ' + line;
        var errpfx = new Array(lineno_display_width + 1).join('^');
        var offset = 2 + 1;
        var len = 0;

        if (lno === loc.first_line) {
          offset += loc.first_column;

          len = Math.max(
            2,
            ((lno === loc.last_line ? loc.last_column : line.length)) - loc.first_column + 1
          );
        } else if (lno === loc.last_line) {
          len = Math.max(2, loc.last_column + 1);
        } else if (lno > loc.first_line && lno < loc.last_line) {
          len = Math.max(2, line.length + 1);
        }

        if (len) {
          var lead = new Array(offset).join('.');
          var mark = new Array(len).join('^');
          rv += '\n' + errpfx + lead + mark;

          if (line.trim().length > 0) {
            nonempty_line_indexes.push(index);
          }
        }

        rv = rv.replace(/\t/g, ' ');
        return rv;
      });

      // now make sure we don't print an overly large amount of error area: limit it 
      // to the top and bottom line count:
      if (nonempty_line_indexes.length > 2 * MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT) {
        var clip_start = nonempty_line_indexes[MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT - 1] + 1;
        var clip_end = nonempty_line_indexes[nonempty_line_indexes.length - MINIMUM_VISIBLE_NONEMPTY_LINE_COUNT] - 1;
        var intermediate_line = new Array(lineno_display_width + 1).join(' ') + '  (...continued...)';
        intermediate_line += '\n' + new Array(lineno_display_width + 1).join('-') + '  (---------------)';
        rv.splice(clip_start, clip_end - clip_start + 1, intermediate_line);
      }

      return rv.join('\n');
    },

    /**
     * helper function, used to produce a human readable description as a string, given
     * the input `yylloc` location object.
     * 
     * Set `display_range_too` to TRUE to include the string character index position(s)
     * in the description if the `yylloc.range` is available.
     * 
     * @public
     * @this {RegExpLexer}
     */
    describeYYLLOC: function lexer_describe_yylloc(yylloc, display_range_too) {
      var l1 = yylloc.first_line;
      var l2 = yylloc.last_line;
      var c1 = yylloc.first_column;
      var c2 = yylloc.last_column;
      var dl = l2 - l1;
      var dc = c2 - c1;
      var rv;

      if (dl === 0) {
        rv = 'line ' + l1 + ', ';

        if (dc <= 1) {
          rv += 'column ' + c1;
        } else {
          rv += 'columns ' + c1 + ' .. ' + c2;
        }
      } else {
        rv = 'lines ' + l1 + '(column ' + c1 + ') .. ' + l2 + '(column ' + c2 + ')';
      }

      if (yylloc.range && display_range_too) {
        var r1 = yylloc.range[0];
        var r2 = yylloc.range[1] - 1;

        if (r2 <= r1) {
          rv += ' {String Offset: ' + r1 + '}';
        } else {
          rv += ' {String Offset range: ' + r1 + ' .. ' + r2 + '}';
        }
      }

      return rv;
    },

    /**
     * test the lexed token: return FALSE when not a match, otherwise return token.
     * 
     * `match` is supposed to be an array coming out of a regex match, i.e. `match[0]`
     * contains the actually matched text string.
     * 
     * Also move the input cursor forward and update the match collectors:
     * 
     * - `yytext`
     * - `yyleng`
     * - `match`
     * - `matches`
     * - `yylloc`
     * - `offset`
     * 
     * @public
     * @this {RegExpLexer}
     */
    test_match: function lexer_test_match(match, indexed_rule) {
      var token, lines, backup, match_str, match_str_len;

      if (this.options.backtrack_lexer) {
        // save context
        backup = {
          yylineno: this.yylineno,

          yylloc: {
            first_line: this.yylloc.first_line,
            last_line: this.yylloc.last_line,
            first_column: this.yylloc.first_column,
            last_column: this.yylloc.last_column,
            range: this.yylloc.range.slice(0)
          },

          yytext: this.yytext,
          match: this.match,
          matches: this.matches,
          matched: this.matched,
          yyleng: this.yyleng,
          offset: this.offset,
          _more: this._more,
          _input: this._input,

          //_signaled_error_token: this._signaled_error_token,
          yy: this.yy,

          conditionStack: this.conditionStack.slice(0),
          done: this.done
        };
      }

      match_str = match[0];
      match_str_len = match_str.length;

      // if (match_str.indexOf('\n') !== -1 || match_str.indexOf('\r') !== -1) {
      lines = match_str.split(/(?:\r\n?|\n)/g);

      if (lines.length > 1) {
        this.yylineno += lines.length - 1;
        this.yylloc.last_line = this.yylineno + 1;
        this.yylloc.last_column = lines[lines.length - 1].length;
      } else {
        this.yylloc.last_column += match_str_len;
      }

      // }
      this.yytext += match_str;

      this.match += match_str;
      this.matched += match_str;
      this.matches = match;
      this.yyleng = this.yytext.length;
      this.yylloc.range[1] += match_str_len;

      // previous lex rules MAY have invoked the `more()` API rather than producing a token:
      // those rules will already have moved this `offset` forward matching their match lengths,
      // hence we must only add our own match length now:
      this.offset += match_str_len;

      this._more = false;
      this._backtrack = false;
      this._input = this._input.slice(match_str_len);

      // calling this method:
      //
      //   function lexer__performAction(yy, yyrulenumber, YY_START) {...}
      token = this.performAction.call(
        this,
        this.yy,
        indexed_rule,
        this.conditionStack[this.conditionStack.length - 1] /* = YY_START */
      );

      // otherwise, when the action codes are all simple return token statements:
      //token = this.simpleCaseActionClusters[indexed_rule];

      if (this.done && this._input) {
        this.done = false;
      }

      if (token) {
        return token;
      } else if (this._backtrack) {
        // recover context
        for (var k in backup) {
          this[k] = backup[k];
        }

        this.__currentRuleSet__ = null;
        return false;  // rule action called reject() implying the next rule should be tested instead. 
      } else if (this._signaled_error_token) {
        // produce one 'error' token as `.parseError()` in `reject()`
        // did not guarantee a failure signal by throwing an exception!
        token = this._signaled_error_token;

        this._signaled_error_token = false;
        return token;
      }

      return false;
    },

    /**
     * return next match in input
     * 
     * @public
     * @this {RegExpLexer}
     */
    next: function lexer_next() {
      if (this.done) {
        this.clear();
        return this.EOF;
      }

      if (!this._input) {
        this.done = true;
      }

      var token, match, tempMatch, index;

      if (!this._more) {
        this.clear();
      }

      var spec = this.__currentRuleSet__;

      if (!spec) {
        // Update the ruleset cache as we apparently encountered a state change or just started lexing.
        // The cache is set up for fast lookup -- we assume a lexer will switch states much less often than it will
        // invoke the `lex()` token-producing API and related APIs, hence caching the set for direct access helps
        // speed up those activities a tiny bit.
        spec = this.__currentRuleSet__ = this._currentRules();

        // Check whether a *sane* condition has been pushed before: this makes the lexer robust against
        // user-programmer bugs such as https://github.com/zaach/jison-lex/issues/19
        if (!spec || !spec.rules) {
          var lineno_msg = '';

          if (this.options.trackPosition) {
            lineno_msg = ' on line ' + (this.yylineno + 1);
          }

          var p = this.constructLexErrorInfo(
            'Internal lexer engine error' + lineno_msg + ': The lex grammar programmer pushed a non-existing condition name "' + this.topState() + '"; this is a fatal error and should be reported to the application programmer team!',
            false
          );

          // produce one 'error' token until this situation has been resolved, most probably by parse termination!
          return this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;
        }
      }

      var rule_ids = spec.rules;
      var regexes = spec.__rule_regexes;
      var len = spec.__rule_count;

      // Note: the arrays are 1-based, while `len` itself is a valid index,
      // hence the non-standard less-or-equal check in the next loop condition!
      for (var i = 1; i <= len; i++) {
        tempMatch = this._input.match(regexes[i]);

        if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
          match = tempMatch;
          index = i;

          if (this.options.backtrack_lexer) {
            token = this.test_match(tempMatch, rule_ids[i]);

            if (token !== false) {
              return token;
            } else if (this._backtrack) {
              match = undefined;
              continue;  // rule action called reject() implying a rule MISmatch. 
            } else {
              // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
              return false;
            }
          } else if (!this.options.flex) {
            break;
          }
        }
      }

      if (match) {
        token = this.test_match(match, rule_ids[index]);

        if (token !== false) {
          return token;
        }

        // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
        return false;
      }

      if (!this._input) {
        this.done = true;
        this.clear();
        return this.EOF;
      } else {
        var lineno_msg = '';

        if (this.options.trackPosition) {
          lineno_msg = ' on line ' + (this.yylineno + 1);
        }

        var p = this.constructLexErrorInfo(
          'Lexical error' + lineno_msg + ': Unrecognized text.',
          this.options.lexerErrorsAreRecoverable
        );

        var pendingInput = this._input;
        var activeCondition = this.topState();
        var conditionStackDepth = this.conditionStack.length;
        token = this.parseError(p.errStr, p, this.JisonLexerError) || this.ERROR;

        if (token === this.ERROR) {
          // we can try to recover from a lexer error that `parseError()` did not 'recover' for us
          // by moving forward at least one character at a time IFF the (user-specified?) `parseError()`
          // has not consumed/modified any pending input or changed state in the error handler:
          if (!this.matches && // and make sure the input has been modified/consumed ...
          pendingInput === this._input && // ...or the lexer state has been modified significantly enough
          // to merit a non-consuming error handling action right now.
          activeCondition === this.topState() && conditionStackDepth === this.conditionStack.length) {
            this.input();
          }
        }

        return token;
      }
    },

    /**
     * return next match that has a token
     * 
     * @public
     * @this {RegExpLexer}
     */
    lex: function lexer_lex() {
      var r;

      // allow the PRE/POST handlers set/modify the return token for maximum flexibility of the generated lexer:
      if (typeof this.pre_lex === 'function') {
        r = this.pre_lex.call(this, 0);
      }

      if (typeof this.options.pre_lex === 'function') {
        // (also account for a userdef function which does not return any value: keep the token as is)
        r = this.options.pre_lex.call(this, r) || r;
      }

      if (this.yy && typeof this.yy.pre_lex === 'function') {
        // (also account for a userdef function which does not return any value: keep the token as is)
        r = this.yy.pre_lex.call(this, r) || r;
      }

      while (!r) {
        r = this.next();
      }

      if (this.yy && typeof this.yy.post_lex === 'function') {
        // (also account for a userdef function which does not return any value: keep the token as is)
        r = this.yy.post_lex.call(this, r) || r;
      }

      if (typeof this.options.post_lex === 'function') {
        // (also account for a userdef function which does not return any value: keep the token as is)
        r = this.options.post_lex.call(this, r) || r;
      }

      if (typeof this.post_lex === 'function') {
        // (also account for a userdef function which does not return any value: keep the token as is)
        r = this.post_lex.call(this, r) || r;
      }

      return r;
    },

    /**
     * return next match that has a token. Identical to the `lex()` API but does not invoke any of the 
     * `pre_lex()` nor any of the `post_lex()` callbacks.
     * 
     * @public
     * @this {RegExpLexer}
     */
    fastLex: function lexer_fastLex() {
      var r;

      while (!r) {
        r = this.next();
      }

      return r;
    },

    /**
     * return info about the lexer state that can help a parser or other lexer API user to use the
     * most efficient means available. This API is provided to aid run-time performance for larger
     * systems which employ this lexer.
     * 
     * @public
     * @this {RegExpLexer}
     */
    canIUse: function lexer_canIUse() {
      var rv = {
        fastLex: !(typeof this.pre_lex === 'function' || typeof this.options.pre_lex === 'function' || this.yy && typeof this.yy.pre_lex === 'function' || this.yy && typeof this.yy.post_lex === 'function' || typeof this.options.post_lex === 'function' || typeof this.post_lex === 'function') && typeof this.fastLex === 'function'
      };

      return rv;
    },

    /**
     * backwards compatible alias for `pushState()`;
     * the latter is symmetrical with `popState()` and we advise to use
     * those APIs in any modern lexer code, rather than `begin()`.
     * 
     * @public
     * @this {RegExpLexer}
     */
    begin: function lexer_begin(condition) {
      return this.pushState(condition);
    },

    /**
     * activates a new lexer condition state (pushes the new lexer
     * condition state onto the condition stack)
     * 
     * @public
     * @this {RegExpLexer}
     */
    pushState: function lexer_pushState(condition) {
      this.conditionStack.push(condition);
      this.__currentRuleSet__ = null;
      return this;
    },

    /**
     * pop the previously active lexer condition state off the condition
     * stack
     * 
     * @public
     * @this {RegExpLexer}
     */
    popState: function lexer_popState() {
      var n = this.conditionStack.length - 1;

      if (n > 0) {
        this.__currentRuleSet__ = null;
        return this.conditionStack.pop();
      } else {
        return this.conditionStack[0];
      }
    },

    /**
     * return the currently active lexer condition state; when an index
     * argument is provided it produces the N-th previous condition state,
     * if available
     * 
     * @public
     * @this {RegExpLexer}
     */
    topState: function lexer_topState(n) {
      n = this.conditionStack.length - 1 - Math.abs(n || 0);

      if (n >= 0) {
        return this.conditionStack[n];
      } else {
        return 'INITIAL';
      }
    },

    /**
     * (internal) determine the lexer rule set which is active for the
     * currently active lexer condition state
     * 
     * @public
     * @this {RegExpLexer}
     */
    _currentRules: function lexer__currentRules() {
      if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
        return this.conditions[this.conditionStack[this.conditionStack.length - 1]];
      } else {
        return this.conditions['INITIAL'];
      }
    },

    /**
     * return the number of states currently on the stack
     * 
     * @public
     * @this {RegExpLexer}
     */
    stateStackSize: function lexer_stateStackSize() {
      return this.conditionStack.length;
    },

    options: {
      trackPosition: true,
      caseInsensitive: true,
      easy_keyword_rules: true
    },

    JisonLexerError: JisonLexerError,

    performAction: function lexer__performAction(yy, yyrulenumber, YY_START) {
      var yy_ = this;
      var YYSTATE = YY_START;

      switch (yyrulenumber) {
      case 1:
        /*! Conditions:: INITIAL */
        /*! Rule::       [^\S\n]+ */
        /* whitespace */
        break;

      default:
        return this.simpleCaseActionClusters[yyrulenumber];
      }
    },

    simpleCaseActionClusters: {
      /*! Conditions:: INITIAL */
      /*! Rule::       (\s*\n)+ */
      0: 21,

      /*! Conditions:: INITIAL */
      /*! Rule::       : */
      2: 3,

      /*! Conditions:: INITIAL */
      /*! Rule::       '[^\n]* */
      3: 20,

      /*! Conditions:: INITIAL */
      /*! Rule::       REM [^\n]* */
      4: 22,

      /*! Conditions:: INITIAL */
      /*! Rule::       ; */
      5: 11,

      /*! Conditions:: INITIAL */
      /*! Rule::       , */
      6: 8,

      /*! Conditions:: INITIAL */
      /*! Rule::       \( */
      7: 4,

      /*! Conditions:: INITIAL */
      /*! Rule::       \) */
      8: 5,

      /*! Conditions:: INITIAL */
      /*! Rule::       \[ */
      9: 6,

      /*! Conditions:: INITIAL */
      /*! Rule::       \] */
      10: 7,

      /*! Conditions:: INITIAL */
      /*! Rule::       \+ */
      11: 13,

      /*! Conditions:: INITIAL */
      /*! Rule::       - */
      12: 12,

      /*! Conditions:: INITIAL */
      /*! Rule::       \* */
      13: 14,

      /*! Conditions:: INITIAL */
      /*! Rule::       \/ */
      14: 15,

      /*! Conditions:: INITIAL */
      /*! Rule::       % */
      15: 16,

      /*! Conditions:: INITIAL */
      /*! Rule::       >= */
      16: 196,

      /*! Conditions:: INITIAL */
      /*! Rule::       <= */
      17: 197,

      /*! Conditions:: INITIAL */
      /*! Rule::       > */
      18: 17,

      /*! Conditions:: INITIAL */
      /*! Rule::       < */
      19: 18,

      /*! Conditions:: INITIAL */
      /*! Rule::       == */
      20: 194,

      /*! Conditions:: INITIAL */
      /*! Rule::       != */
      21: 195,

      /*! Conditions:: INITIAL */
      /*! Rule::       = */
      22: 9,

      /*! Conditions:: INITIAL */
      /*! Rule::       ! */
      23: 19,

      /*! Conditions:: INITIAL */
      /*! Rule::       AND\b */
      24: 191,

      /*! Conditions:: INITIAL */
      /*! Rule::       OR\b */
      25: 192,

      /*! Conditions:: INITIAL */
      /*! Rule::       XOR\b */
      26: 193,

      /*! Conditions:: INITIAL */
      /*! Rule::       NOT\b */
      27: 198,

      /*! Conditions:: INITIAL */
      /*! Rule::       CSRX\b */
      28: 161,

      /*! Conditions:: INITIAL */
      /*! Rule::       CSRY\b */
      29: 162,

      /*! Conditions:: INITIAL */
      /*! Rule::       FREEMEM\b */
      30: 163,

      /*! Conditions:: INITIAL */
      /*! Rule::       VERSION\b */
      31: 164,

      /*! Conditions:: INITIAL */
      /*! Rule::       ERR\b */
      32: 165,

      /*! Conditions:: INITIAL */
      /*! Rule::       ERL\b */
      33: 166,

      /*! Conditions:: INITIAL */
      /*! Rule::       RESULT\b */
      34: 167,

      /*! Conditions:: INITIAL */
      /*! Rule::       TCHX\b */
      35: 168,

      /*! Conditions:: INITIAL */
      /*! Rule::       TCHY\b */
      36: 169,

      /*! Conditions:: INITIAL */
      /*! Rule::       TCHST\b */
      37: 170,

      /*! Conditions:: INITIAL */
      /*! Rule::       TCHTIME\b */
      38: 171,

      /*! Conditions:: INITIAL */
      /*! Rule::       MAINCNTL\b */
      39: 173,

      /*! Conditions:: INITIAL */
      /*! Rule::       MAINCNTH\b */
      40: 172,

      /*! Conditions:: INITIAL */
      /*! Rule::       TABSTEP\b */
      41: 184,

      /*! Conditions:: INITIAL */
      /*! Rule::       TRUE\b */
      42: 174,

      /*! Conditions:: INITIAL */
      /*! Rule::       FALSE\b */
      43: 175,

      /*! Conditions:: INITIAL */
      /*! Rule::       CANCEL\b */
      44: 176,

      /*! Conditions:: INITIAL */
      /*! Rule::       ICONPUSE\b */
      45: 185,

      /*! Conditions:: INITIAL */
      /*! Rule::       ICONPAGE\b */
      46: 186,

      /*! Conditions:: INITIAL */
      /*! Rule::       FUNCNO\b */
      47: 177,

      /*! Conditions:: INITIAL */
      /*! Rule::       FREEVAR\b */
      48: 178,

      /*! Conditions:: INITIAL */
      /*! Rule::       SYSBEEP\b */
      49: 187,

      /*! Conditions:: INITIAL */
      /*! Rule::       KEYBOARD\b */
      50: 179,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHITNO\b */
      51: 180,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHITX\b */
      52: 181,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHITY\b */
      53: 182,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHITT\b */
      54: 183,

      /*! Conditions:: INITIAL */
      /*! Rule::       TIME\$ */
      55: 199,

      /*! Conditions:: INITIAL */
      /*! Rule::       DATE\$ */
      56: 200,

      /*! Conditions:: INITIAL */
      /*! Rule::       MEM\$ */
      57: 203,

      /*! Conditions:: INITIAL */
      /*! Rule::       PRGNAME\$ */
      58: 201,

      /*! Conditions:: INITIAL */
      /*! Rule::       PACKAGE\$ */
      59: 202,

      /*! Conditions:: INITIAL */
      /*! Rule::       NEW\b */
      60: 'NEW',

      /*! Conditions:: INITIAL */
      /*! Rule::       LIST\b */
      61: 'LIST',

      /*! Conditions:: INITIAL */
      /*! Rule::       RUN\b */
      62: 'RUN',

      /*! Conditions:: INITIAL */
      /*! Rule::       CONT\b */
      63: 'CONT',

      /*! Conditions:: INITIAL */
      /*! Rule::       FILES\b */
      64: 'FILES',

      /*! Conditions:: INITIAL */
      /*! Rule::       REBOOT\b */
      65: 'REBOOT',

      /*! Conditions:: INITIAL */
      /*! Rule::       CLEAR\b */
      66: 28,

      /*! Conditions:: INITIAL */
      /*! Rule::       DIM\b */
      67: 27,

      /*! Conditions:: INITIAL */
      /*! Rule::       KEY\b */
      68: 29,

      /*! Conditions:: INITIAL */
      /*! Rule::       SWAP\b */
      69: 30,

      /*! Conditions:: INITIAL */
      /*! Rule::       SORT\b */
      70: 31,

      /*! Conditions:: INITIAL */
      /*! Rule::       RSORT\b */
      71: 32,

      /*! Conditions:: INITIAL */
      /*! Rule::       VSYNC\b */
      72: 33,

      /*! Conditions:: INITIAL */
      /*! Rule::       WAIT\b */
      73: 34,

      /*! Conditions:: INITIAL */
      /*! Rule::       ON\b */
      74: 35,

      /*! Conditions:: INITIAL */
      /*! Rule::       GOTO\b */
      75: 36,

      /*! Conditions:: INITIAL */
      /*! Rule::       GOSUB\b */
      76: 37,

      /*! Conditions:: INITIAL */
      /*! Rule::       RETURN\b */
      77: 38,

      /*! Conditions:: INITIAL */
      /*! Rule::       STOP\b */
      78: 39,

      /*! Conditions:: INITIAL */
      /*! Rule::       END\b */
      79: 40,

      /*! Conditions:: INITIAL */
      /*! Rule::       FOR\b */
      80: 41,

      /*! Conditions:: INITIAL */
      /*! Rule::       TO\b */
      81: 42,

      /*! Conditions:: INITIAL */
      /*! Rule::       STEP\b */
      82: 43,

      /*! Conditions:: INITIAL */
      /*! Rule::       NEXT\b */
      83: 44,

      /*! Conditions:: INITIAL */
      /*! Rule::       IF\b */
      84: 45,

      /*! Conditions:: INITIAL */
      /*! Rule::       THEN\b */
      85: 46,

      /*! Conditions:: INITIAL */
      /*! Rule::       ELSE\b */
      86: 47,

      /*! Conditions:: INITIAL */
      /*! Rule::       READ\b */
      87: 48,

      /*! Conditions:: INITIAL */
      /*! Rule::       DATA\b */
      88: 49,

      /*! Conditions:: INITIAL */
      /*! Rule::       RESTORE\b */
      89: 50,

      /*! Conditions:: INITIAL */
      /*! Rule::       TMREAD\b */
      90: 51,

      /*! Conditions:: INITIAL */
      /*! Rule::       DTREAD\b */
      91: 52,

      /*! Conditions:: INITIAL */
      /*! Rule::       CLS\b */
      92: 53,

      /*! Conditions:: INITIAL */
      /*! Rule::       COLOR\b */
      93: 54,

      /*! Conditions:: INITIAL */
      /*! Rule::       LOCATE\b */
      94: 55,

      /*! Conditions:: INITIAL */
      /*! Rule::       PRINT\b */
      95: 26,

      /*! Conditions:: INITIAL */
      /*! Rule::       \? */
      96: 26,

      /*! Conditions:: INITIAL */
      /*! Rule::       CHKCHR\b */
      97: 122,

      /*! Conditions:: INITIAL */
      /*! Rule::       ACLS\b */
      98: 56,

      /*! Conditions:: INITIAL */
      /*! Rule::       VISIBLE\b */
      99: 57,

      /*! Conditions:: INITIAL */
      /*! Rule::       INKEY\$ */
      100: 154,

      /*! Conditions:: INITIAL */
      /*! Rule::       INPUT\b */
      101: 58,

      /*! Conditions:: INITIAL */
      /*! Rule::       LINPUT\b */
      102: 59,

      /*! Conditions:: INITIAL */
      /*! Rule::       BUTTON\b */
      103: 123,

      /*! Conditions:: INITIAL */
      /*! Rule::       BTRIG\b */
      104: 124,

      /*! Conditions:: INITIAL */
      /*! Rule::       BREPEAT\b */
      105: 60,

      /*! Conditions:: INITIAL */
      /*! Rule::       PNLTYPE\b */
      106: 61,

      /*! Conditions:: INITIAL */
      /*! Rule::       PNLSTR\b */
      107: 62,

      /*! Conditions:: INITIAL */
      /*! Rule::       ICONSET\b */
      108: 63,

      /*! Conditions:: INITIAL */
      /*! Rule::       ICONCLR\b */
      109: 64,

      /*! Conditions:: INITIAL */
      /*! Rule::       ICONCHK\b */
      110: 125,

      /*! Conditions:: INITIAL */
      /*! Rule::       LOAD\b */
      111: 65,

      /*! Conditions:: INITIAL */
      /*! Rule::       SAVE\b */
      112: 66,

      /*! Conditions:: INITIAL */
      /*! Rule::       DELETE\b */
      113: 67,

      /*! Conditions:: INITIAL */
      /*! Rule::       RENAME\b */
      114: 68,

      /*! Conditions:: INITIAL */
      /*! Rule::       RECVFILE\b */
      115: 69,

      /*! Conditions:: INITIAL */
      /*! Rule::       SENDFILE\b */
      116: 70,

      /*! Conditions:: INITIAL */
      /*! Rule::       APPEND\b */
      117: 'APPEND',

      /*! Conditions:: INITIAL */
      /*! Rule::       EXEC\b */
      118: 71,

      /*! Conditions:: INITIAL */
      /*! Rule::       FLOOR\b */
      119: 126,

      /*! Conditions:: INITIAL */
      /*! Rule::       RND\b */
      120: 127,

      /*! Conditions:: INITIAL */
      /*! Rule::       ABS\b */
      121: 128,

      /*! Conditions:: INITIAL */
      /*! Rule::       SGN\b */
      122: 129,

      /*! Conditions:: INITIAL */
      /*! Rule::       SQR\b */
      123: 130,

      /*! Conditions:: INITIAL */
      /*! Rule::       EXP\b */
      124: 131,

      /*! Conditions:: INITIAL */
      /*! Rule::       LOG\b */
      125: 132,

      /*! Conditions:: INITIAL */
      /*! Rule::       POW\b */
      126: 133,

      /*! Conditions:: INITIAL */
      /*! Rule::       PI\b */
      127: 134,

      /*! Conditions:: INITIAL */
      /*! Rule::       RAD\b */
      128: 135,

      /*! Conditions:: INITIAL */
      /*! Rule::       DEG\b */
      129: 136,

      /*! Conditions:: INITIAL */
      /*! Rule::       SIN\b */
      130: 137,

      /*! Conditions:: INITIAL */
      /*! Rule::       COS\b */
      131: 138,

      /*! Conditions:: INITIAL */
      /*! Rule::       TAN\b */
      132: 139,

      /*! Conditions:: INITIAL */
      /*! Rule::       ATAN\b */
      133: 140,

      /*! Conditions:: INITIAL */
      /*! Rule::       ASC\b */
      134: 141,

      /*! Conditions:: INITIAL */
      /*! Rule::       CHR\$ */
      135: 155,

      /*! Conditions:: INITIAL */
      /*! Rule::       VAL\b */
      136: 121,

      /*! Conditions:: INITIAL */
      /*! Rule::       STR\$ */
      137: 153,

      /*! Conditions:: INITIAL */
      /*! Rule::       HEX\$ */
      138: 156,

      /*! Conditions:: INITIAL */
      /*! Rule::       LEN\b */
      139: 142,

      /*! Conditions:: INITIAL */
      /*! Rule::       MID\$ */
      140: 157,

      /*! Conditions:: INITIAL */
      /*! Rule::       LEFT\$ */
      141: 159,

      /*! Conditions:: INITIAL */
      /*! Rule::       RIGHT\$ */
      142: 158,

      /*! Conditions:: INITIAL */
      /*! Rule::       INSTR\b */
      143: 143,

      /*! Conditions:: INITIAL */
      /*! Rule::       SUBST\$ */
      144: 160,

      /*! Conditions:: INITIAL */
      /*! Rule::       GPAGE\b */
      145: 72,

      /*! Conditions:: INITIAL */
      /*! Rule::       GCOLOR\b */
      146: 73,

      /*! Conditions:: INITIAL */
      /*! Rule::       GCLS\b */
      147: 74,

      /*! Conditions:: INITIAL */
      /*! Rule::       GSPOIT\b */
      148: 144,

      /*! Conditions:: INITIAL */
      /*! Rule::       GPSET\b */
      149: 75,

      /*! Conditions:: INITIAL */
      /*! Rule::       GPAINT\b */
      150: 76,

      /*! Conditions:: INITIAL */
      /*! Rule::       GLINE\b */
      151: 77,

      /*! Conditions:: INITIAL */
      /*! Rule::       GBOX\b */
      152: 78,

      /*! Conditions:: INITIAL */
      /*! Rule::       GFILL\b */
      153: 79,

      /*! Conditions:: INITIAL */
      /*! Rule::       GCIRCLE\b */
      154: 80,

      /*! Conditions:: INITIAL */
      /*! Rule::       GPRIO\b */
      155: 81,

      /*! Conditions:: INITIAL */
      /*! Rule::       GDRAWMD\b */
      156: 82,

      /*! Conditions:: INITIAL */
      /*! Rule::       GCOPY\b */
      157: 83,

      /*! Conditions:: INITIAL */
      /*! Rule::       GPUTCHR\b */
      158: 84,

      /*! Conditions:: INITIAL */
      /*! Rule::       COLINIT\b */
      159: 85,

      /*! Conditions:: INITIAL */
      /*! Rule::       COLSET\b */
      160: 86,

      /*! Conditions:: INITIAL */
      /*! Rule::       COLREAD\b */
      161: 87,

      /*! Conditions:: INITIAL */
      /*! Rule::       CHRINIT\b */
      162: 88,

      /*! Conditions:: INITIAL */
      /*! Rule::       CHRSET\b */
      163: 89,

      /*! Conditions:: INITIAL */
      /*! Rule::       CHRCOPY\b */
      164: 'CHRCOPY',

      /*! Conditions:: INITIAL */
      /*! Rule::       CHRREAD\b */
      165: 90,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPPAGE\b */
      166: 91,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPSET\b */
      167: 92,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPCLR\b */
      168: 93,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHOME\b */
      169: 94,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPOFS\b */
      170: 95,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPCHR\b */
      171: 96,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPANIM\b */
      172: 97,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPANGLE\b */
      173: 98,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPSCALE\b */
      174: 99,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPCHK\b */
      175: 145,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPREAD\b */
      176: 100,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPSETV\b */
      177: 101,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPGETV\b */
      178: 146,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPCOL\b */
      179: 102,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPCOLVEC\b */
      180: 103,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHIT\b */
      181: 147,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHITSP\b */
      182: 148,

      /*! Conditions:: INITIAL */
      /*! Rule::       SPHITRC\b */
      183: 149,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGPAGE\b */
      184: 104,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGCLR\b */
      185: 105,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGCLIP\b */
      186: 106,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGOFS\b */
      187: 107,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGPUT\b */
      188: 108,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGFILL\b */
      189: 109,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGREAD\b */
      190: 110,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGCHK\b */
      191: 150,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGCOPY\b */
      192: 111,

      /*! Conditions:: INITIAL */
      /*! Rule::       BEEP\b */
      193: 112,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMPLAY\b */
      194: 113,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMSTOP\b */
      195: 114,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMCHK\b */
      196: 151,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMVOL\b */
      197: 115,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMSET\b */
      198: 116,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMSETD\b */
      199: 117,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMCLEAR\b */
      200: 118,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMSETV\b */
      201: 119,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMGETV\b */
      202: 152,

      /*! Conditions:: INITIAL */
      /*! Rule::       BGMPRG\b */
      203: 120,

      /*! Conditions:: INITIAL */
      /*! Rule::       [A-Z_][_A-Z0-9]*\$ */
      204: 25,

      /*! Conditions:: INITIAL */
      /*! Rule::       [A-Z_][_A-Z0-9]* */
      205: 24,

      /*! Conditions:: INITIAL */
      /*! Rule::       [0-9]+(\.[0-9]+)? */
      206: 188,

      /*! Conditions:: INITIAL */
      /*! Rule::       \.[0-9]+ */
      207: 188,

      /*! Conditions:: INITIAL */
      /*! Rule::       &B[01]+ */
      208: 189,

      /*! Conditions:: INITIAL */
      /*! Rule::       &H[0-9A-F]+ */
      209: 190,

      /*! Conditions:: INITIAL */
      /*! Rule::       "([^\n\"]*)("|((?=\n))) */
      210: 204,

      /*! Conditions:: INITIAL */
      /*! Rule::       @[A-Z0-9_]+ */
      211: 23,

      /*! Conditions:: INITIAL */
      /*! Rule::       $ */
      212: 1
    },

    rules: [
      /*   0: */  /^(?:(\s*\n)+)/i,
      /*   1: */  /^(?:[^\S\n]+)/i,
      /*   2: */  /^(?::)/i,
      /*   3: */  /^(?:'[^\n]*)/i,
      /*   4: */  /^(?:REM [^\n]*)/i,
      /*   5: */  /^(?:;)/i,
      /*   6: */  /^(?:,)/i,
      /*   7: */  /^(?:\()/i,
      /*   8: */  /^(?:\))/i,
      /*   9: */  /^(?:\[)/i,
      /*  10: */  /^(?:\])/i,
      /*  11: */  /^(?:\+)/i,
      /*  12: */  /^(?:-)/i,
      /*  13: */  /^(?:\*)/i,
      /*  14: */  /^(?:\/)/i,
      /*  15: */  /^(?:%)/i,
      /*  16: */  /^(?:>=)/i,
      /*  17: */  /^(?:<=)/i,
      /*  18: */  /^(?:>)/i,
      /*  19: */  /^(?:<)/i,
      /*  20: */  /^(?:==)/i,
      /*  21: */  /^(?:!=)/i,
      /*  22: */  /^(?:=)/i,
      /*  23: */  /^(?:!)/i,
      /*  24: */  /^(?:AND\b)/i,
      /*  25: */  /^(?:OR\b)/i,
      /*  26: */  /^(?:XOR\b)/i,
      /*  27: */  /^(?:NOT\b)/i,
      /*  28: */  /^(?:CSRX\b)/i,
      /*  29: */  /^(?:CSRY\b)/i,
      /*  30: */  /^(?:FREEMEM\b)/i,
      /*  31: */  /^(?:VERSION\b)/i,
      /*  32: */  /^(?:ERR\b)/i,
      /*  33: */  /^(?:ERL\b)/i,
      /*  34: */  /^(?:RESULT\b)/i,
      /*  35: */  /^(?:TCHX\b)/i,
      /*  36: */  /^(?:TCHY\b)/i,
      /*  37: */  /^(?:TCHST\b)/i,
      /*  38: */  /^(?:TCHTIME\b)/i,
      /*  39: */  /^(?:MAINCNTL\b)/i,
      /*  40: */  /^(?:MAINCNTH\b)/i,
      /*  41: */  /^(?:TABSTEP\b)/i,
      /*  42: */  /^(?:TRUE\b)/i,
      /*  43: */  /^(?:FALSE\b)/i,
      /*  44: */  /^(?:CANCEL\b)/i,
      /*  45: */  /^(?:ICONPUSE\b)/i,
      /*  46: */  /^(?:ICONPAGE\b)/i,
      /*  47: */  /^(?:FUNCNO\b)/i,
      /*  48: */  /^(?:FREEVAR\b)/i,
      /*  49: */  /^(?:SYSBEEP\b)/i,
      /*  50: */  /^(?:KEYBOARD\b)/i,
      /*  51: */  /^(?:SPHITNO\b)/i,
      /*  52: */  /^(?:SPHITX\b)/i,
      /*  53: */  /^(?:SPHITY\b)/i,
      /*  54: */  /^(?:SPHITT\b)/i,
      /*  55: */  /^(?:TIME\$)/i,
      /*  56: */  /^(?:DATE\$)/i,
      /*  57: */  /^(?:MEM\$)/i,
      /*  58: */  /^(?:PRGNAME\$)/i,
      /*  59: */  /^(?:PACKAGE\$)/i,
      /*  60: */  /^(?:NEW\b)/i,
      /*  61: */  /^(?:LIST\b)/i,
      /*  62: */  /^(?:RUN\b)/i,
      /*  63: */  /^(?:CONT\b)/i,
      /*  64: */  /^(?:FILES\b)/i,
      /*  65: */  /^(?:REBOOT\b)/i,
      /*  66: */  /^(?:CLEAR\b)/i,
      /*  67: */  /^(?:DIM\b)/i,
      /*  68: */  /^(?:KEY\b)/i,
      /*  69: */  /^(?:SWAP\b)/i,
      /*  70: */  /^(?:SORT\b)/i,
      /*  71: */  /^(?:RSORT\b)/i,
      /*  72: */  /^(?:VSYNC\b)/i,
      /*  73: */  /^(?:WAIT\b)/i,
      /*  74: */  /^(?:ON\b)/i,
      /*  75: */  /^(?:GOTO\b)/i,
      /*  76: */  /^(?:GOSUB\b)/i,
      /*  77: */  /^(?:RETURN\b)/i,
      /*  78: */  /^(?:STOP\b)/i,
      /*  79: */  /^(?:END\b)/i,
      /*  80: */  /^(?:FOR\b)/i,
      /*  81: */  /^(?:TO\b)/i,
      /*  82: */  /^(?:STEP\b)/i,
      /*  83: */  /^(?:NEXT\b)/i,
      /*  84: */  /^(?:IF\b)/i,
      /*  85: */  /^(?:THEN\b)/i,
      /*  86: */  /^(?:ELSE\b)/i,
      /*  87: */  /^(?:READ\b)/i,
      /*  88: */  /^(?:DATA\b)/i,
      /*  89: */  /^(?:RESTORE\b)/i,
      /*  90: */  /^(?:TMREAD\b)/i,
      /*  91: */  /^(?:DTREAD\b)/i,
      /*  92: */  /^(?:CLS\b)/i,
      /*  93: */  /^(?:COLOR\b)/i,
      /*  94: */  /^(?:LOCATE\b)/i,
      /*  95: */  /^(?:PRINT\b)/i,
      /*  96: */  /^(?:\?)/i,
      /*  97: */  /^(?:CHKCHR\b)/i,
      /*  98: */  /^(?:ACLS\b)/i,
      /*  99: */  /^(?:VISIBLE\b)/i,
      /* 100: */  /^(?:INKEY\$)/i,
      /* 101: */  /^(?:INPUT\b)/i,
      /* 102: */  /^(?:LINPUT\b)/i,
      /* 103: */  /^(?:BUTTON\b)/i,
      /* 104: */  /^(?:BTRIG\b)/i,
      /* 105: */  /^(?:BREPEAT\b)/i,
      /* 106: */  /^(?:PNLTYPE\b)/i,
      /* 107: */  /^(?:PNLSTR\b)/i,
      /* 108: */  /^(?:ICONSET\b)/i,
      /* 109: */  /^(?:ICONCLR\b)/i,
      /* 110: */  /^(?:ICONCHK\b)/i,
      /* 111: */  /^(?:LOAD\b)/i,
      /* 112: */  /^(?:SAVE\b)/i,
      /* 113: */  /^(?:DELETE\b)/i,
      /* 114: */  /^(?:RENAME\b)/i,
      /* 115: */  /^(?:RECVFILE\b)/i,
      /* 116: */  /^(?:SENDFILE\b)/i,
      /* 117: */  /^(?:APPEND\b)/i,
      /* 118: */  /^(?:EXEC\b)/i,
      /* 119: */  /^(?:FLOOR\b)/i,
      /* 120: */  /^(?:RND\b)/i,
      /* 121: */  /^(?:ABS\b)/i,
      /* 122: */  /^(?:SGN\b)/i,
      /* 123: */  /^(?:SQR\b)/i,
      /* 124: */  /^(?:EXP\b)/i,
      /* 125: */  /^(?:LOG\b)/i,
      /* 126: */  /^(?:POW\b)/i,
      /* 127: */  /^(?:PI\b)/i,
      /* 128: */  /^(?:RAD\b)/i,
      /* 129: */  /^(?:DEG\b)/i,
      /* 130: */  /^(?:SIN\b)/i,
      /* 131: */  /^(?:COS\b)/i,
      /* 132: */  /^(?:TAN\b)/i,
      /* 133: */  /^(?:ATAN\b)/i,
      /* 134: */  /^(?:ASC\b)/i,
      /* 135: */  /^(?:CHR\$)/i,
      /* 136: */  /^(?:VAL\b)/i,
      /* 137: */  /^(?:STR\$)/i,
      /* 138: */  /^(?:HEX\$)/i,
      /* 139: */  /^(?:LEN\b)/i,
      /* 140: */  /^(?:MID\$)/i,
      /* 141: */  /^(?:LEFT\$)/i,
      /* 142: */  /^(?:RIGHT\$)/i,
      /* 143: */  /^(?:INSTR\b)/i,
      /* 144: */  /^(?:SUBST\$)/i,
      /* 145: */  /^(?:GPAGE\b)/i,
      /* 146: */  /^(?:GCOLOR\b)/i,
      /* 147: */  /^(?:GCLS\b)/i,
      /* 148: */  /^(?:GSPOIT\b)/i,
      /* 149: */  /^(?:GPSET\b)/i,
      /* 150: */  /^(?:GPAINT\b)/i,
      /* 151: */  /^(?:GLINE\b)/i,
      /* 152: */  /^(?:GBOX\b)/i,
      /* 153: */  /^(?:GFILL\b)/i,
      /* 154: */  /^(?:GCIRCLE\b)/i,
      /* 155: */  /^(?:GPRIO\b)/i,
      /* 156: */  /^(?:GDRAWMD\b)/i,
      /* 157: */  /^(?:GCOPY\b)/i,
      /* 158: */  /^(?:GPUTCHR\b)/i,
      /* 159: */  /^(?:COLINIT\b)/i,
      /* 160: */  /^(?:COLSET\b)/i,
      /* 161: */  /^(?:COLREAD\b)/i,
      /* 162: */  /^(?:CHRINIT\b)/i,
      /* 163: */  /^(?:CHRSET\b)/i,
      /* 164: */  /^(?:CHRCOPY\b)/i,
      /* 165: */  /^(?:CHRREAD\b)/i,
      /* 166: */  /^(?:SPPAGE\b)/i,
      /* 167: */  /^(?:SPSET\b)/i,
      /* 168: */  /^(?:SPCLR\b)/i,
      /* 169: */  /^(?:SPHOME\b)/i,
      /* 170: */  /^(?:SPOFS\b)/i,
      /* 171: */  /^(?:SPCHR\b)/i,
      /* 172: */  /^(?:SPANIM\b)/i,
      /* 173: */  /^(?:SPANGLE\b)/i,
      /* 174: */  /^(?:SPSCALE\b)/i,
      /* 175: */  /^(?:SPCHK\b)/i,
      /* 176: */  /^(?:SPREAD\b)/i,
      /* 177: */  /^(?:SPSETV\b)/i,
      /* 178: */  /^(?:SPGETV\b)/i,
      /* 179: */  /^(?:SPCOL\b)/i,
      /* 180: */  /^(?:SPCOLVEC\b)/i,
      /* 181: */  /^(?:SPHIT\b)/i,
      /* 182: */  /^(?:SPHITSP\b)/i,
      /* 183: */  /^(?:SPHITRC\b)/i,
      /* 184: */  /^(?:BGPAGE\b)/i,
      /* 185: */  /^(?:BGCLR\b)/i,
      /* 186: */  /^(?:BGCLIP\b)/i,
      /* 187: */  /^(?:BGOFS\b)/i,
      /* 188: */  /^(?:BGPUT\b)/i,
      /* 189: */  /^(?:BGFILL\b)/i,
      /* 190: */  /^(?:BGREAD\b)/i,
      /* 191: */  /^(?:BGCHK\b)/i,
      /* 192: */  /^(?:BGCOPY\b)/i,
      /* 193: */  /^(?:BEEP\b)/i,
      /* 194: */  /^(?:BGMPLAY\b)/i,
      /* 195: */  /^(?:BGMSTOP\b)/i,
      /* 196: */  /^(?:BGMCHK\b)/i,
      /* 197: */  /^(?:BGMVOL\b)/i,
      /* 198: */  /^(?:BGMSET\b)/i,
      /* 199: */  /^(?:BGMSETD\b)/i,
      /* 200: */  /^(?:BGMCLEAR\b)/i,
      /* 201: */  /^(?:BGMSETV\b)/i,
      /* 202: */  /^(?:BGMGETV\b)/i,
      /* 203: */  /^(?:BGMPRG\b)/i,
      /* 204: */  /^(?:[A-Z_][\dA-Z_]*\$)/i,
      /* 205: */  /^(?:[A-Z_][\dA-Z_]*)/i,
      /* 206: */  /^(?:\d+(\.\d+)?)/i,
      /* 207: */  /^(?:\.\d+)/i,
      /* 208: */  /^(?:&B[01]+)/i,
      /* 209: */  /^(?:&H[\dA-F]+)/i,
      /* 210: */  /^(?:"([^\n"]*)("|((?=\n))))/i,
      /* 211: */  /^(?:@[\dA-Z_]+)/i,
      /* 212: */  /^(?:$)/i
    ],

    conditions: {
      'INITIAL': {
        rules: [
          0,
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21,
          22,
          23,
          24,
          25,
          26,
          27,
          28,
          29,
          30,
          31,
          32,
          33,
          34,
          35,
          36,
          37,
          38,
          39,
          40,
          41,
          42,
          43,
          44,
          45,
          46,
          47,
          48,
          49,
          50,
          51,
          52,
          53,
          54,
          55,
          56,
          57,
          58,
          59,
          60,
          61,
          62,
          63,
          64,
          65,
          66,
          67,
          68,
          69,
          70,
          71,
          72,
          73,
          74,
          75,
          76,
          77,
          78,
          79,
          80,
          81,
          82,
          83,
          84,
          85,
          86,
          87,
          88,
          89,
          90,
          91,
          92,
          93,
          94,
          95,
          96,
          97,
          98,
          99,
          100,
          101,
          102,
          103,
          104,
          105,
          106,
          107,
          108,
          109,
          110,
          111,
          112,
          113,
          114,
          115,
          116,
          117,
          118,
          119,
          120,
          121,
          122,
          123,
          124,
          125,
          126,
          127,
          128,
          129,
          130,
          131,
          132,
          133,
          134,
          135,
          136,
          137,
          138,
          139,
          140,
          141,
          142,
          143,
          144,
          145,
          146,
          147,
          148,
          149,
          150,
          151,
          152,
          153,
          154,
          155,
          156,
          157,
          158,
          159,
          160,
          161,
          162,
          163,
          164,
          165,
          166,
          167,
          168,
          169,
          170,
          171,
          172,
          173,
          174,
          175,
          176,
          177,
          178,
          179,
          180,
          181,
          182,
          183,
          184,
          185,
          186,
          187,
          188,
          189,
          190,
          191,
          192,
          193,
          194,
          195,
          196,
          197,
          198,
          199,
          200,
          201,
          202,
          203,
          204,
          205,
          206,
          207,
          208,
          209,
          210,
          211,
          212
        ],

        inclusive: true
      }
    }
  };

  return lexer;
}();
parser.lexer = lexer;



function Parser() {
  this.yy = {};
}
Parser.prototype = parser;
parser.Parser = Parser;

return new Parser();
})();

        


if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
  exports.parser = ptc;
  exports.Parser = ptc.Parser;
  exports.parse = function () {
    return ptc.parse.apply(ptc, arguments);
  };
  
}