lexp.js

/* Version 23055.1536 */
/** lexpjs - Copyright (C) 2018,2021 Patrick H. Rigney, All Rights Reserved
 *  See https://github.com/toggledbits/lexpjs
 *
 *  This Software is open source offered under the MIT LICENSE. See https://opensource.org/licenses/MIT
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 *  documentation files (the "Software"), to deal in the Software without restriction, including without limitation
 *  the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
 *  to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of
 *  the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
 *  THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 *  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 *  SOFTWARE.
 */

const version = 23055;

const FEATURE_MONTH_BASE = 1;   /* 1 = months 1-12; set to 0 if you prefer JS semantics where 0=Jan,11=Dec */
const MAX_RANGE = 1000;         /* Maximum number of elements in a result range op result array */

const c_quot = {                /* Default quoting */
    "\"": "\\\"",
    "\\": "\\\\",
    "\t": "\\t",
    "\n": "\\n",
    "\r": "\\r",
    "\b": "\\b",
    "\f": "\\f",
    "\v": "\\v"
};

(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD. Register as an anonymous module.
        define([], factory);
    } else if (typeof module === 'object' && module.exports) {
        // Node. Does not work with strict CommonJS, but
        // only CommonJS-like environments that support module.exports,
        // like Node.
        module.exports = factory();
    } else {
        // Browser globals (root is window)
        root.lexp = factory();
    }
}(typeof self !== 'undefined' ? self : this, function () {

/* --------------------------------- generated grammar (DO NOT EDIT) ------------------------------- */

/* parser generated by jison 0.4.18 */
/*
  Returns a Parser object of the following structure:

  Parser: {
    yy: {}
  }

  Parser.prototype: {
    yy: {},
    trace: function(),
    symbols_: {associative list: name ==> number},
    terminals_: {associative list: number ==> name},
    productions_: [...],
    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
    table: [...],
    defaultActions: {...},
    parseError: function(str, hash),
    parse: function(input),

    lexer: {
        EOF: 1,
        parseError: function(str, hash),
        setInput: function(input),
        input: function(),
        unput: function(str),
        more: function(),
        less: function(n),
        pastInput: function(),
        upcomingInput: function(),
        showPosition: function(),
        test_match: function(regex_match_array, rule_index),
        next: function(),
        lex: function(),
        begin: function(condition),
        popState: function(),
        _currentRules: function(),
        topState: function(),
        pushState: function(condition),

        options: {
            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 each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
        },

        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, regular 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)
    line:        (yylineno)
  }
  while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
    loc:         (yylloc)
    expected:    (string describing the set of expected tokens)
    recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
  }
*/
var parser = (function(){
var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,28],$V1=[1,8],$V2=[1,29],$V3=[1,27],$V4=[1,30],$V5=[1,31],$V6=[1,4],$V7=[1,5],$V8=[1,6],$V9=[1,7],$Va=[1,9],$Vb=[1,10],$Vc=[1,11],$Vd=[1,12],$Ve=[1,14],$Vf=[1,15],$Vg=[1,16],$Vh=[1,17],$Vi=[1,18],$Vj=[1,19],$Vk=[1,22],$Vl=[1,23],$Vm=[1,24],$Vn=[1,25],$Vo=[1,26],$Vp=[1,33],$Vq=[1,34],$Vr=[5,7,10,11,21,36,73,83],$Vs=[1,41],$Vt=[1,35],$Vu=[1,36],$Vv=[1,37],$Vw=[1,38],$Vx=[1,39],$Vy=[1,40],$Vz=[1,42],$VA=[1,43],$VB=[1,44],$VC=[1,45],$VD=[1,46],$VE=[1,47],$VF=[1,48],$VG=[1,49],$VH=[1,50],$VI=[1,51],$VJ=[1,52],$VK=[1,53],$VL=[1,54],$VM=[1,55],$VN=[1,56],$VO=[1,57],$VP=[1,58],$VQ=[1,59],$VR=[1,60],$VS=[1,61],$VT=[1,68],$VU=[1,69],$VV=[5,7,9,10,11,17,21,25,35,36,37,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,67,73,81,83,86],$VW=[5,7,9,10,11,15,16,17,18,19,21,25,32,35,36,37,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,67,73,81,83,86],$VX=[10,67],$VY=[10,17],$VZ=[2,8],$V_=[5,7,9,10,11,17,21,25,35,36,37,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,67,73,81,83,86],$V$=[5,7,9,10,11,17,21,25,35,36,37,41,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,67,73,81,83,86],$V01=[5,7,9,10,11,17,21,25,35,36,41,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,67,73,81,83,86],$V11=[5,7,9,10,11,17,21,25,35,36,49,50,51,52,53,63,64,65,67,73,81,83,86],$V21=[5,7,9,10,11,17,21,25,35,36,49,50,51,52,53,54,55,56,57,58,63,64,65,67,73,81,83,86],$V31=[5,7,9,10,11,17,21,25,35,36,63,64,65,67,73,81,83,86],$V41=[5,7,9,10,11,17,21,25,35,36,67,73,81,83,86],$V51=[35,86],$V61=[5,7,9,10,11,17,21,35,36,67,73,81,83,86],$V71=[7,36,73];
var parser = {trace: function trace () { },
yy: {},
symbols_: {"error":2,"expressions":3,"expr_list":4,"EOF":5,"elif_list":6,"ELIF":7,"e":8,"THEN":9,"COMMA":10,"EXPRSEP":11,"arg_list":12,"ref_expr":13,"IDENTIFIER":14,"DOT":15,"[":16,"]":17,"QDOT":18,"QBRACKET":19,"(":20,")":21,"quoted_string":22,"QSTR":23,"dict_element":24,"COLON":25,"dict_elements":26,"element_list":27,"array_elements":28,"array_list":29,"assignment":30,"GLOBAL":31,"ASSIGN":32,"LOCAL":33,"when_list":34,"WHEN":35,"ELSE":36,"-":37,"LNOT":38,"BNOT":39,"POW":40,"RANGE":41,"*":42,"/":43,"MOD":44,"+":45,"<<":46,">>":47,">>>":48,"BAND":49,"BOR":50,"BXOR":51,"LAND":52,"LOR":53,"==":54,"!=":55,"===":56,"!==":57,"IN":58,"<":59,"<=":60,">":61,">=":62,"COALESCE":63,"COALESCENAN":64,"?":65,"LCURLY":66,"RCURLY":67,"NUMBER":68,"HEXNUM":69,"OCTNUM":70,"BINNUM":71,"IF":72,"ENDIF":73,"TRUE":74,"FALSE":75,"NULL":76,"NAN":77,"INF":78,"EACH":79,"FIRST":80,"WITH":81,"DO":82,"DONE":83,"DEF":84,"CASE":85,"END":86,"$accept":0,"$end":1},
terminals_: {2:"error",5:"EOF",7:"ELIF",9:"THEN",10:"COMMA",11:"EXPRSEP",14:"IDENTIFIER",15:"DOT",16:"[",17:"]",18:"QDOT",19:"QBRACKET",20:"(",21:")",23:"QSTR",25:"COLON",31:"GLOBAL",32:"ASSIGN",33:"LOCAL",35:"WHEN",36:"ELSE",37:"-",38:"LNOT",39:"BNOT",40:"POW",41:"RANGE",42:"*",43:"/",44:"MOD",45:"+",46:"<<",47:">>",48:">>>",49:"BAND",50:"BOR",51:"BXOR",52:"LAND",53:"LOR",54:"==",55:"!=",56:"===",57:"!==",58:"IN",59:"<",60:"<=",61:">",62:">=",63:"COALESCE",64:"COALESCENAN",65:"?",66:"LCURLY",67:"RCURLY",68:"NUMBER",69:"HEXNUM",70:"OCTNUM",71:"BINNUM",72:"IF",73:"ENDIF",74:"TRUE",75:"FALSE",76:"NULL",77:"NAN",78:"INF",79:"EACH",80:"FIRST",81:"WITH",82:"DO",83:"DONE",84:"DEF",85:"CASE",86:"END"},
productions_: [0,[3,2],[6,5],[6,4],[4,3],[4,3],[4,1],[12,1],[12,0],[13,1],[13,3],[13,4],[13,3],[13,4],[13,4],[13,3],[22,1],[24,3],[24,5],[24,3],[26,3],[26,1],[27,1],[27,0],[28,3],[28,1],[29,1],[29,0],[30,4],[30,4],[30,3],[34,7],[34,5],[34,4],[8,2],[8,2],[8,2],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,3],[8,5],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[8,1],[8,8],[8,6],[8,7],[8,5],[8,1],[8,1],[8,1],[8,1],[8,1],[8,1],[8,1],[8,8],[8,6],[8,10],[8,8],[8,8],[8,6],[8,3],[8,6],[8,3]],
performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
/* this == yyval */

var $0 = $$.length - 1;
switch (yystate) {
case 1:
 return $$[$0-1]; 
break;
case 2:
 $$[$0-4].push( { test: $$[$0-2], tc: $$[$0] } ); this.$ = $$[$0-4]; 
break;
case 3:
 this.$ = [ { test: $$[$0-2], tc: $$[$0] } ]; 
break;
case 4: case 5:
 $$[$0-2].expr.push( $$[$0] ); this.$ = $$[$0-2]; 
break;
case 6:
 this.$ = atom( 'list', { expr: [ $$[$0] ] } ); 
break;
case 7: case 22: case 26: case 70: case 80: case 81:
 this.$ = $$[$0]; 
break;
case 8:
 this.$ = atom( 'list', { expr: [] } ); 
break;
case 9:
 this.$ = atom( 'vref', { name: $$[$0] } ); 
break;
case 10:
 this.$ = atom( 'deref', { context: $$[$0-2], member: $$[$0], locs: [_$[$0-2], _$[$0]] } ); 
break;
case 11:
 this.$ = atom( 'deref', { context: $$[$0-3], member: $$[$0-1], locs: [_$[$0-3], _$[$0-1]] } ); 
break;
case 12:
 this.$ = atom( 'deref', { context: $$[$0-2], member: $$[$0], locs: [_$[$0-2], _$[$0]], op: $$[$0-1] } ); 
break;
case 13:
 this.$ = atom( 'deref', { context: $$[$0-3], member: $$[$0-1], locs: [_$[$0-3], _$[$0-1]], op: $$[$0-2] } ); 
break;
case 14:
 this.$ = atom( 'fref', { name: $$[$0-3], args: is_atom( $$[$0-1], 'list') ? ($$[$0-1]).expr : [ $$[$0-1] ], locs: [_$[$0-3]] } ); 
break;
case 15: case 64: case 65:
 this.$ = $$[$0-1]; 
break;
case 16:
 this.$ = buffer; 
break;
case 17: case 19:
 this.$ = { key: $$[$0-2], value: $$[$0] }; 
break;
case 18:
 this.$ = { key: $$[$0-3], value: $$[$0] }; 
break;
case 20:
 ($$[$0-2])[($$[$0]).key] = ($$[$0]).value; this.$ = $$[$0-2]; 
break;
case 21:
 this.$ = { [($$[$0]).key]: ($$[$0]).value }; 
break;
case 23:
 this.$ = {}; 
break;
case 24:
 $$[$0-2].push( $$[$0] ); this.$ = $$[$0-2]; 
break;
case 25:
 this.$ = [ $$[$0] ]; 
break;
case 27:
 this.$ = []; 
break;
case 28:
 this.$ = atom( 'binop', { 'op': $$[$0-1], v1: atom( 'vref', { name: $$[$0-2] } ), v2: $$[$0], global: true, locs: [_$[$0-2], _$[$0]] } ); 
break;
case 29:
 this.$ = atom( 'binop', { 'op': $$[$0-1], v1: atom( 'vref', { name: $$[$0-2] } ), v2: $$[$0], local: true, locs: [_$[$0-2], _$[$0]] } ); 
break;
case 30:
 this.$ = atom( 'binop', { 'op': $$[$0-1], v1: $$[$0-2], v2: $$[$0], locs: [_$[$0-2], _$[$0]] } ); 
break;
case 31:
 $$[$0-6].expr.push( atom( 'if', { test: $$[$0-4], tc: $$[$0-2], fc: $$[$0], locs: [_$[$0-4], _$[$0-2], _$[$0]] } ) ); this.$ = $$[$0-6]; 
break;
case 32:
 $$[$0-4].expr.push( atom( 'if', { test: $$[$0-2], tc: $$[$0], locs: [_$[$0-2], _$[$0]] } ) ); this.$ = $$[$0-4]; 
break;
case 33:
 this.$ = atom( 'list', { expr: [ atom( 'if', { test: $$[$0-2], tc: $$[$0], locs: [_$[$0-2], _$[$0]] } ) ] } ); 
break;
case 34:
 this.$ = atom( 'unop', { op: '-', val: $$[$0] } ); 
break;
case 35:
 this.$ = atom( 'unop', { op: '!', val: $$[$0] } ); 
break;
case 36:
 this.$ = atom( 'unop', { op: '~', val: $$[$0] } ); 
break;
case 37: case 38: case 39: case 40: case 41: case 42: case 43: case 44: case 45: case 46: case 47: case 48: case 49: case 52: case 53: case 54: case 55: case 56: case 57: case 58: case 59: case 60: case 61: case 62:
 this.$ = atom( 'binop', { op: $$[$0-1], v1: $$[$0-2], v2: $$[$0], locs: [_$[$0-2],_$[$0]] } ); 
break;
case 50:
 this.$ = atom( 'binop', { op: '&&', v1: $$[$0-2], v2: $$[$0], locs: [_$[$0-2],_$[$0]] } ); 
break;
case 51:
 this.$ = atom( 'binop', { op: '||', v1: $$[$0-2], v2: $$[$0], locs: [_$[$0-2],_$[$0]] } ); 
break;
case 63:
 this.$ = atom( 'if', { test: $$[$0-4], tc: $$[$0-2], fc: $$[$0], locs: [_$[$0-4], _$[$0-2], _$[$0]] } ); 
break;
case 66:
 this.$ = Number(yytext); 
break;
case 67:
 this.$ = parseInt( yytext.substr( 2 ), 16 ); 
break;
case 68:
 this.$ = parseInt( yytext.substr( 2 ), 8 ); 
break;
case 69:
 this.$ = parseInt( yytext.substr( 2 ), 2 ); 
break;
case 71:
 this.$ = atom( 'if', { test: $$[$0-6], tc: $$[$0-4], alts: $$[$0-3], fc: $$[$0-1], locs: [_$[$0-6], _$[$0-4], _$[$0-3], _$[$0-1]] } ); 
break;
case 72:
 this.$ = atom( 'if', { test: $$[$0-4], tc: $$[$0-2], alts: $$[$0-1], locs: [_$[$0-4], _$[$0-2], _$[$0-1]] } ); 
break;
case 73:
 this.$ = atom( 'if', { test: $$[$0-5], tc: $$[$0-3], fc: $$[$0-1], locs: [_$[$0-5], _$[$0-3], _$[$0-1]] } ); 
break;
case 74:
 this.$ = atom( 'if', { test: $$[$0-3], tc: $$[$0-1], locs: [_$[$0-3], _$[$0-1]] } ); 
break;
case 75:
 this.$ = true; 
break;
case 76:
 this.$ = false; 
break;
case 77:
 this.$ = null; 
break;
case 78:
 this.$ = NaN; 
break;
case 79:
 this.$ = Infinity; 
break;
case 82:
 this.$ = atom( 'iter', { value: $$[$0-6], key: $$[$0-4], context: $$[$0-2], exec: $$[$0] } ); 
break;
case 83:
 this.$ = atom( 'iter', { value: $$[$0-4], context: $$[$0-2], exec: $$[$0] } ); 
break;
case 84:
 this.$ = atom( 'search', { value: $$[$0-8], key: $$[$0-6], context: $$[$0-4], exec: $$[$0-2], result: $$[$0] } ); 
break;
case 85:
 this.$ = atom( 'search', { value: $$[$0-6], context: $$[$0-4], exec: $$[$0-2], result: $$[$0] } ); 
break;
case 86:
 this.$ = atom( 'search', { value: $$[$0-6], key: $$[$0-4], context: $$[$0-2], exec: $$[$0] } ); 
break;
case 87:
 this.$ = atom( 'search', { value: $$[$0-4], context: $$[$0-2], exec: $$[$0] } ); 
break;
case 88:
 this.$ = atom( 'block', { block: $$[$0-1] } ); 
break;
case 89:
 this.$ = atom( 'fdef', { name: $$[$0-4], args: $$[$0-2], list: $$[$0] } ); 
break;
case 90:
 this.$ = atom( 'case', { when_list: $$[$0-1] } ); 
break;
}
},
table: [{3:1,4:2,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{1:[3]},{5:[1,32],10:$Vp,11:$Vq},o($Vr,[2,6],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{8:62,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:63,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:64,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{14:$VT,16:$VU,22:70,23:$V3,24:67,26:66,27:65,67:[2,23]},{8:73,13:20,14:$V0,16:$V1,17:[2,27],20:$V2,22:13,23:$V3,28:72,29:71,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,66]),o($VV,[2,67]),o($VV,[2,68]),o($VV,[2,69]),o($VV,[2,70]),{8:74,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,75]),o($VV,[2,76]),o($VV,[2,77]),o($VV,[2,78]),o($VV,[2,79]),o($VV,[2,80],{15:[1,75],16:[1,76],18:[1,77],19:[1,78],32:[1,79]}),o($VV,[2,81]),{14:[1,80]},{14:[1,81]},{4:82,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{14:[1,83]},{34:84,35:[1,85]},o($VV,[2,16]),o($VW,[2,9],{20:[1,86]}),{8:87,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{14:[1,88]},{14:[1,89]},{1:[2,1]},{8:90,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:91,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:92,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:93,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:94,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:95,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:96,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:97,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:98,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:99,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:100,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:101,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:102,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:103,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:104,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:105,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:106,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:107,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:108,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:109,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:110,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:111,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:112,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:113,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:114,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:115,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:116,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:117,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:118,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,34]),o($VV,[2,35]),o($VV,[2,36]),{67:[1,119]},{10:[1,120],67:[2,22]},o($VX,[2,21]),{25:[1,121]},{22:122,23:$V3},{25:[1,123]},{17:[1,124]},{10:[1,125],17:[2,26]},o($VY,[2,25],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{9:[1,126],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},{14:[1,127]},{8:128,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{14:[1,129]},{8:130,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:131,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{10:[1,132],58:[1,133]},{10:[1,134],58:[1,135]},{10:$Vp,11:$Vq,83:[1,136]},{20:[1,137]},{35:[1,139],86:[1,138]},{8:140,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{4:142,8:3,12:141,13:20,14:$V0,16:$V1,20:$V2,21:$VZ,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{21:[1,143],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},{32:[1,144]},{32:[1,145]},o($Vr,[2,4],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($Vr,[2,5],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V_,[2,37],{40:$Vt}),o([5,7,9,10,11,17,21,25,35,36,41,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,67,73,81,83,86],[2,38],{37:$Vs,40:$Vt,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB}),o($V_,[2,39],{40:$Vt}),o($V_,[2,40],{40:$Vt}),o($V_,[2,41],{40:$Vt}),o($V$,[2,42],{40:$Vt,42:$Vv,43:$Vw,44:$Vx}),o($V$,[2,43],{40:$Vt,42:$Vv,43:$Vw,44:$Vx}),o($V01,[2,44],{37:$Vs,40:$Vt,42:$Vv,43:$Vw,44:$Vx,45:$Vy}),o($V01,[2,45],{37:$Vs,40:$Vt,42:$Vv,43:$Vw,44:$Vx,45:$Vy}),o($V01,[2,46],{37:$Vs,40:$Vt,42:$Vv,43:$Vw,44:$Vx,45:$Vy}),o($V11,[2,47],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o([5,7,9,10,11,17,21,25,35,36,50,52,53,63,64,65,67,73,81,83,86],[2,48],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,51:$VE,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o([5,7,9,10,11,17,21,25,35,36,50,51,52,53,63,64,65,67,73,81,83,86],[2,49],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o([5,7,9,10,11,17,21,25,35,36,52,53,63,64,65,67,73,81,83,86],[2,50],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o([5,7,9,10,11,17,21,25,35,36,53,63,64,65,67,73,81,83,86],[2,51],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o($V11,[2,52],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o($V11,[2,53],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o($V11,[2,54],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o($V11,[2,55],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o([5,7,9,10,11,17,21,25,35,36,49,50,51,52,53,54,55,56,57,63,64,65,67,73,81,83,86],[2,56],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,59:$VM,60:$VN,61:$VO,62:$VP}),o($V21,[2,57],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB}),o($V21,[2,58],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB}),o($V21,[2,59],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB}),o($V21,[2,60],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB}),o($V31,[2,61],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),o($V31,[2,62],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP}),{25:[1,146],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},o($VV,[2,64]),{14:$VT,16:$VU,22:70,23:$V3,24:147},{8:148,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{17:[1,149]},{8:150,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,65]),{8:151,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{4:152,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VW,[2,10]),{17:[1,153],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},o($VW,[2,12]),{17:[1,154],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},o($V41,[2,30],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{14:[1,155]},{8:156,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{14:[1,157]},{8:158,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,88]),{4:142,8:3,12:159,13:20,14:$V0,16:$V1,20:$V2,21:$VZ,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,90]),{8:160,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{25:[1,161],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},{21:[1,162]},{10:$Vp,11:$Vq,21:[2,7]},o($VW,[2,15]),{8:163,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:164,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:165,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VX,[2,20]),o($VX,[2,17],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{25:[1,166]},o($VX,[2,19],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($VY,[2,24],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{6:167,7:[1,170],10:$Vp,11:$Vq,36:[1,168],73:[1,169]},o($VW,[2,11]),o($VW,[2,13]),{58:[1,171]},{25:[1,172],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},{58:[1,173]},{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS,81:[1,174]},{21:[1,175]},{25:[1,176],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},{8:177,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VW,[2,14]),o($V41,[2,28],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V41,[2,29],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V41,[2,63],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{8:178,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{7:[1,181],36:[1,179],73:[1,180]},{4:182,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,74]),{8:183,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:184,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:185,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:186,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:187,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:188,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:189,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($V51,[2,33],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($VX,[2,18],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{4:190,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,72]),{8:191,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{10:$Vp,11:$Vq,73:[1,192]},{9:[1,193],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},{25:[1,194],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},o($V41,[2,83],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS,81:[1,195]},o($V61,[2,87],{25:[1,196],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V41,[2,89],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V51,[2,32],{36:[1,197],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),{10:$Vp,11:$Vq,73:[1,198]},{9:[1,199],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS},o($VV,[2,73]),{4:200,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:201,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:202,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:203,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},{8:204,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($VV,[2,71]),{4:205,8:3,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($V71,[2,3],{10:$Vp,11:$Vq}),o($V41,[2,82],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V61,[2,86],{25:[1,206],37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V41,[2,85],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V51,[2,31],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS}),o($V71,[2,2],{10:$Vp,11:$Vq}),{8:207,13:20,14:$V0,16:$V1,20:$V2,22:13,23:$V3,30:21,31:$V4,33:$V5,37:$V6,38:$V7,39:$V8,66:$V9,68:$Va,69:$Vb,70:$Vc,71:$Vd,72:$Ve,74:$Vf,75:$Vg,76:$Vh,77:$Vi,78:$Vj,79:$Vk,80:$Vl,82:$Vm,84:$Vn,85:$Vo},o($V41,[2,84],{37:$Vs,40:$Vt,41:$Vu,42:$Vv,43:$Vw,44:$Vx,45:$Vy,46:$Vz,47:$VA,48:$VB,49:$VC,50:$VD,51:$VE,52:$VF,53:$VG,54:$VH,55:$VI,56:$VJ,57:$VK,58:$VL,59:$VM,60:$VN,61:$VO,62:$VP,63:$VQ,64:$VR,65:$VS})],
defaultActions: {32:[2,1]},
parseError: function parseError (str, hash) {
    if (hash.recoverable) {
        this.trace(str);
    } else {
        var error = new Error(str);
        error.hash = hash;
        throw error;
    }
},
parse: function parse(input) {
    var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
    var args = lstack.slice.call(arguments, 1);
    var lexer = Object.create(this.lexer);
    var sharedState = { yy: {} };
    for (var k in this.yy) {
        if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
            sharedState.yy[k] = this.yy[k];
        }
    }
    lexer.setInput(input, sharedState.yy);
    sharedState.yy.lexer = lexer;
    sharedState.yy.parser = this;
    if (typeof lexer.yylloc == 'undefined') {
        lexer.yylloc = {};
    }
    var yyloc = lexer.yylloc;
    lstack.push(yyloc);
    var ranges = lexer.options && lexer.options.ranges;
    if (typeof sharedState.yy.parseError === 'function') {
        this.parseError = sharedState.yy.parseError;
    } else {
        this.parseError = Object.getPrototypeOf(this).parseError;
    }
    function popStack(n) {
        stack.length = stack.length - 2 * n;
        vstack.length = vstack.length - n;
        lstack.length = lstack.length - n;
    }
    _token_stack:
        var lex = function () {
            var token;
            token = lexer.lex() || EOF;
            if (typeof token !== 'number') {
                token = self.symbols_[token] || token;
            }
            return token;
        };
    var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
    while (true) {
        state = stack[stack.length - 1];
        if (this.defaultActions[state]) {
            action = this.defaultActions[state];
        } else {
            if (symbol === null || typeof symbol == 'undefined') {
                symbol = lex();
            }
            action = table[state] && table[state][symbol];
        }
                    if (typeof action === 'undefined' || !action.length || !action[0]) {
                var errStr = '';
                expected = [];
                for (p in table[state]) {
                    if (this.terminals_[p] && p > TERROR) {
                        expected.push('\'' + this.terminals_[p] + '\'');
                    }
                }
                if (lexer.showPosition) {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                } else {
                    errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                }
                this.parseError(errStr, {
                    text: lexer.match,
                    token: this.terminals_[symbol] || symbol,
                    line: lexer.yylineno,
                    loc: yyloc,
                    expected: expected
                });
            }
        if (action[0] instanceof Array && action.length > 1) {
            throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
        }
        switch (action[0]) {
        case 1:
            stack.push(symbol);
            vstack.push(lexer.yytext);
            lstack.push(lexer.yylloc);
            stack.push(action[1]);
            symbol = null;
            if (!preErrorSymbol) {
                yyleng = lexer.yyleng;
                yytext = lexer.yytext;
                yylineno = lexer.yylineno;
                yyloc = lexer.yylloc;
                if (recovering > 0) {
                    recovering--;
                }
            } else {
                symbol = preErrorSymbol;
                preErrorSymbol = null;
            }
            break;
        case 2:
            len = this.productions_[action[1]][1];
            yyval.$ = vstack[vstack.length - len];
            yyval._$ = {
                first_line: lstack[lstack.length - (len || 1)].first_line,
                last_line: lstack[lstack.length - 1].last_line,
                first_column: lstack[lstack.length - (len || 1)].first_column,
                last_column: lstack[lstack.length - 1].last_column
            };
            if (ranges) {
                yyval._$.range = [
                    lstack[lstack.length - (len || 1)].range[0],
                    lstack[lstack.length - 1].range[1]
                ];
            }
            r = this.performAction.apply(yyval, [
                yytext,
                yyleng,
                yylineno,
                sharedState.yy,
                action[1],
                vstack,
                lstack
            ].concat(args));
            if (typeof r !== 'undefined') {
                return r;
            }
            if (len) {
                stack = stack.slice(0, -1 * len * 2);
                vstack = vstack.slice(0, -1 * len);
                lstack = lstack.slice(0, -1 * len);
            }
            stack.push(this.productions_[action[1]][0]);
            vstack.push(yyval.$);
            lstack.push(yyval._$);
            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
            stack.push(newState);
            break;
        case 3:
            return true;
        }
    }
    return true;
}};

    /* Grammar 22307 */

    var buffer = "", qsep = "";

    function is_atom( v, typ ) {
        return null !== v && "object" === typeof( v ) &&
            "undefined" !== typeof v.__atom &&
            ( !typ || v.__atom === typ );
    }

    function atom( t, vs ) {
        var a = { __atom: t };
        Object.keys(vs || {}).forEach( function( key ) {
            a[key] = vs[key];
        });
        return a;
    }

    function D( ...args ) {
        console.log( ...args );
    }
/* generated by jison-lex 0.3.4 */
var lexer = (function(){
var lexer = ({

EOF:1,

parseError:function parseError(str, hash) {
        if (this.yy.parser) {
            this.yy.parser.parseError(str, hash);
        } else {
            throw new Error(str);
        }
    },

// resets the lexer, sets new input
setInput:function (input, yy) {
        this.yy = yy || this.yy || {};
        this._input = input;
        this._more = this._backtrack = this.done = false;
        this.yylineno = this.yyleng = 0;
        this.yytext = this.matched = this.match = '';
        this.conditionStack = ['INITIAL'];
        this.yylloc = {
            first_line: 1,
            first_column: 0,
            last_line: 1,
            last_column: 0
        };
        if (this.options.ranges) {
            this.yylloc.range = [0,0];
        }
        this.offset = 0;
        return this;
    },

// consumes and returns one char from the input
input:function () {
        var ch = this._input[0];
        this.yytext += ch;
        this.yyleng++;
        this.offset++;
        this.match += ch;
        this.matched += ch;
        var lines = ch.match(/(?:\r\n?|\n).*/g);
        if (lines) {
            this.yylineno++;
            this.yylloc.last_line++;
        } else {
            this.yylloc.last_column++;
        }
        if (this.options.ranges) {
            this.yylloc.range[1]++;
        }

        this._input = this._input.slice(1);
        return ch;
    },

// unshifts one char (or a string) into the input
unput:function (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 -= len;
        this.offset -= len;
        var oldLines = this.match.split(/(?:\r\n?|\n)/g);
        this.match = this.match.substr(0, this.match.length - 1);
        this.matched = this.matched.substr(0, this.matched.length - 1);

        if (lines.length - 1) {
            this.yylineno -= lines.length - 1;
        }
        var r = this.yylloc.range;

        this.yylloc = {
            first_line: this.yylloc.first_line,
            last_line: this.yylineno + 1,
            first_column: this.yylloc.first_column,
            last_column: lines ?
                (lines.length === oldLines.length ? this.yylloc.first_column : 0)
                 + oldLines[oldLines.length - lines.length].length - lines[0].length :
              this.yylloc.first_column - len
        };

        if (this.options.ranges) {
            this.yylloc.range = [r[0], r[0] + this.yyleng - len];
        }
        this.yyleng = this.yytext.length;
        return this;
    },

// When called from action, caches matched text and appends it on next action
more:function () {
        this._more = true;
        return this;
    },

// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
reject:function () {
        if (this.options.backtrack_lexer) {
            this._backtrack = true;
        } else {
            return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                text: "",
                token: null,
                line: this.yylineno
            });

        }
        return this;
    },

// retain first n characters of the match
less:function (n) {
        this.unput(this.match.slice(n));
    },

// displays already matched input, i.e. for error messages
pastInput:function () {
        var past = this.matched.substr(0, this.matched.length - this.match.length);
        return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
    },

// displays upcoming input, i.e. for error messages
upcomingInput:function () {
        var next = this.match;
        if (next.length < 20) {
            next += this._input.substr(0, 20-next.length);
        }
        return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
    },

// displays the character position where the lexing error occurred, i.e. for error messages
showPosition:function () {
        var pre = this.pastInput();
        var c = new Array(pre.length + 1).join("-");
        return pre + this.upcomingInput() + "\n" + c + "^";
    },

// test the lexed token: return FALSE when not a match, otherwise return token
test_match:function(match, indexed_rule) {
        var token,
            lines,
            backup;

        if (this.options.backtrack_lexer) {
            // save context
            backup = {
                yylineno: this.yylineno,
                yylloc: {
                    first_line: this.yylloc.first_line,
                    last_line: this.last_line,
                    first_column: this.yylloc.first_column,
                    last_column: this.yylloc.last_column
                },
                yytext: this.yytext,
                match: this.match,
                matches: this.matches,
                matched: this.matched,
                yyleng: this.yyleng,
                offset: this.offset,
                _more: this._more,
                _input: this._input,
                yy: this.yy,
                conditionStack: this.conditionStack.slice(0),
                done: this.done
            };
            if (this.options.ranges) {
                backup.yylloc.range = this.yylloc.range.slice(0);
            }
        }

        lines = match[0].match(/(?:\r\n?|\n).*/g);
        if (lines) {
            this.yylineno += lines.length;
        }
        this.yylloc = {
            first_line: this.yylloc.last_line,
            last_line: this.yylineno + 1,
            first_column: this.yylloc.last_column,
            last_column: lines ?
                         lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
                         this.yylloc.last_column + match[0].length
        };
        this.yytext += match[0];
        this.match += match[0];
        this.matches = match;
        this.yyleng = this.yytext.length;
        if (this.options.ranges) {
            this.yylloc.range = [this.offset, this.offset += this.yyleng];
        }
        this._more = false;
        this._backtrack = false;
        this._input = this._input.slice(match[0].length);
        this.matched += match[0];
        token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
        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];
            }
            return false; // rule action called reject() implying the next rule should be tested instead.
        }
        return false;
    },

// return next match in input
next:function () {
        if (this.done) {
            return this.EOF;
        }
        if (!this._input) {
            this.done = true;
        }

        var token,
            match,
            tempMatch,
            index;
        if (!this._more) {
            this.yytext = '';
            this.match = '';
        }
        var rules = this._currentRules();
        for (var i = 0; i < rules.length; i++) {
            tempMatch = this._input.match(this.rules[rules[i]]);
            if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                match = tempMatch;
                index = i;
                if (this.options.backtrack_lexer) {
                    token = this.test_match(tempMatch, rules[i]);
                    if (token !== false) {
                        return token;
                    } else if (this._backtrack) {
                        match = false;
                        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, rules[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 === "") {
            return this.EOF;
        } else {
            return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                text: "",
                token: null,
                line: this.yylineno
            });
        }
    },

// return next match that has a token
lex:function lex () {
        var r = this.next();
        if (r) {
            return r;
        } else {
            return this.lex();
        }
    },

// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
begin:function begin (condition) {
        this.conditionStack.push(condition);
    },

// pop the previously active lexer condition state off the condition stack
popState:function popState () {
        var n = this.conditionStack.length - 1;
        if (n > 0) {
            return this.conditionStack.pop();
        } else {
            return this.conditionStack[0];
        }
    },

// produce the lexer rule set which is active for the currently active lexer condition state
_currentRules:function _currentRules () {
        if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
            return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
        } else {
            return this.conditions["INITIAL"].rules;
        }
    },

// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
topState:function topState (n) {
        n = this.conditionStack.length - 1 - Math.abs(n || 0);
        if (n >= 0) {
            return this.conditionStack[n];
        } else {
            return "INITIAL";
        }
    },

// alias for begin(condition)
pushState:function pushState (condition) {
        this.begin(condition);
    },

// return the number of states currently on the stack
stateStackSize:function stateStackSize() {
        return this.conditionStack.length;
    },
options: {},
performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
var YYSTATE=YY_START;
switch($avoiding_name_collisions) {
case 0: this.begin("STRD"); buffer = ""; 
break;
case 1: this.begin("STRS"); buffer = ""; 
break;
case 2: this.begin("STRB"); buffer = ""; 
break;
case 3: buffer += String.fromCharCode( parseInt( yy_.yytext.substring( 2 ), 16 ) ); 
break;
case 4: buffer += String.fromCodePoint( parseInt( yy_.yytext.substring( 2 ), 16 ) ); 
break;
case 5: buffer += String.fromCodePoint( parseInt( yy_.yytext.slice( 3, -1 ), 16 ) ); 
break;
case 6: buffer += "\0"; 
break;
case 7: buffer += "'"; 
break;
case 8: buffer += '"'; 
break;
case 9: buffer += '`'; 
break;
case 10: buffer += "\\"; 
break;
case 11: buffer += "\n"; 
break;
case 12: buffer += "\r"; 
break;
case 13: buffer += "\v"; 
break;
case 14: buffer += "\t"; 
break;
case 15: buffer += "\b"; 
break;
case 16: buffer += "\f"; 
break;
case 17: /* escape EOL: discard */ 
break;
case 18: buffer += yy_.yytext.charAt( 1 ); /* bogus escape => literal char */ 
break;
case 19: buffer += yy_.yytext; 
break;
case 20: return 'EOF_IN_STRING'; 
break;
case 21: this.popState(); return 23; 
break;
case 22: this.popState(); return 23; 
break;
case 23: this.popState(); return 23; 
break;
case 24: buffer += yy_.yytext; 
break;
case 25: /* skip whitespace */ 
break;
case 26: /* skip */ 
break;
case 27: /* skip */ 
break;
case 28: return 10; 
break;
case 29: return 11; 
break;
case 30: return 33; 
break;
case 31: return 31; 
break;
case 32: return 84; 
break;
case 33: return 74; 
break;
case 34: return 75; 
break;
case 35: return 76; 
break;
case 36: return 80; 
break;
case 37: return 81; 
break;
case 38: return 79; 
break;
case 39: return 77; 
break;
case 40: return 78; 
break;
case 41: return 72; 
break;
case 42: return 9; 
break;
case 43: return 7; 
break;
case 44: return 7; 
break;
case 45: return 7; 
break;
case 46: return 36; 
break;
case 47: return 73; 
break;
case 48: return 85; 
break;
case 49: return 35; 
break;
case 50: return 86; 
break;
case 51: return 58; 
break;
case 52: return 83; 
break;
case 53: return 82; 
break;
case 54: return 52; 
break;
case 55: return 53; 
break;
case 56: return 38; 
break;
case 57: return 14; 
break;
case 58: return 68; 
break;
case 59: return 69; 
break;
case 60: return 70; 
break;
case 61: return 71; 
break;
case 62: return 41; 
break;
case 63: return 25; 
break;
case 64: return 40; 
break;
case 65: return 42; 
break;
case 66: return 43; 
break;
case 67: return 44; 
break;
case 68: return 37; 
break;
case 69: return 45; 
break;
case 70: return 48; 
break;
case 71: return 46; 
break;
case 72: return 47; 
break;
case 73: return 60; 
break;
case 74: return 62; 
break;
case 75: return 59; 
break;
case 76: return 61; 
break;
case 77: return 56; 
break;
case 78: return 54; 
break;
case 79: return 57; 
break;
case 80: return 55; 
break;
case 81: return 55; 
break;
case 82: return 51; 
break;
case 83: return 52; 
break;
case 84: return 53; 
break;
case 85: return 38; 
break;
case 86: return 49; 
break;
case 87: return 50; 
break;
case 88: return 39; 
break;
case 89: return 63; 
break;
case 90: return 64 
break;
case 91: return 18; 
break;
case 92: return 19; 
break;
case 93: return 65; 
break;
case 94: return 32; 
break;
case 95: return 15; 
break;
case 96: return 16; 
break;
case 97: return 17; 
break;
case 98: return 20; 
break;
case 99: return 21; 
break;
case 100: return 66; 
break;
case 101: return 67; 
break;
case 102: /* skip comment */ 
break;
case 103: return 5; 
break;
}
},
rules: [/^(?:["])/,/^(?:['])/,/^(?:[`])/,/^(?:\\x[0-9a-fA-F]{2})/,/^(?:\\u[0-9a-fA-F]{4})/,/^(?:\\u\{[0-9a-fA-F]{1,6}\})/,/^(?:\\0)/,/^(?:\\')/,/^(?:\\")/,/^(?:\\`)/,/^(?:\\\\)/,/^(?:\\n)/,/^(?:\\r)/,/^(?:\\v)/,/^(?:\\t)/,/^(?:\\b)/,/^(?:\\f)/,/^(?:[\\](\r\n|\r|\n)\s*)/,/^(?:\\.)/,/^(?:(\r\n|\r|\n)+)/,/^(?:$)/,/^(?:["])/,/^(?:['])/,/^(?:[`])/,/^(?:.)/,/^(?:\s+)/,/^(?:\r)/,/^(?:\n)/,/^(?:,)/,/^(?:;)/,/^(?:local\b)/,/^(?:global\b)/,/^(?:define\b)/,/^(?:true\b)/,/^(?:false\b)/,/^(?:null\b)/,/^(?:first\b)/,/^(?:with\b)/,/^(?:each\b)/,/^(?:NaN\b)/,/^(?:Infinity\b)/,/^(?:if\b)/,/^(?:then\b)/,/^(?:elif\b)/,/^(?:elsif\b)/,/^(?:elseif\b)/,/^(?:else\b)/,/^(?:endif\b)/,/^(?:case\b)/,/^(?:when\b)/,/^(?:end\b)/,/^(?:in\b)/,/^(?:done\b)/,/^(?:do\b)/,/^(?:and\b)/,/^(?:or\b)/,/^(?:not\b)/,/^(?:[\p{Alphabetic}_$][\p{Alphabetic}0-9_$]*\b)/u,/^(?:[0-9]+(\.[0-9]+)?([eE][+-]?[0-9]+)?\b)/,/^(?:0x[0-9A-Fa-f]+\b)/,/^(?:0o[0-7]+\b)/,/^(?:0b[01]+\b)/,/^(?:\.\.)/,/^(?::)/,/^(?:\*\*)/,/^(?:\*)/,/^(?:\/)/,/^(?:%)/,/^(?:-)/,/^(?:\+)/,/^(?:>>>)/,/^(?:<<)/,/^(?:>>)/,/^(?:<=)/,/^(?:>=)/,/^(?:<)/,/^(?:>)/,/^(?:===)/,/^(?:==)/,/^(?:!==)/,/^(?:!=)/,/^(?:<>)/,/^(?:\^)/,/^(?:&&)/,/^(?:\|\|)/,/^(?:!)/,/^(?:&)/,/^(?:\|)/,/^(?:~)/,/^(?:\?\?)/,/^(?:\?#)/,/^(?:\?\.)/,/^(?:\?\[)/,/^(?:\?)/,/^(?:=)/,/^(?:\.)/,/^(?:\[)/,/^(?:\])/,/^(?:\()/,/^(?:\))/,/^(?:\{)/,/^(?:\})/,/^(?:#[^\r\n]*)/,/^(?:$)/],
conditions: {"STRB":{"rules":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,23,24],"inclusive":false},"STRS":{"rules":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,22,24],"inclusive":false},"STRD":{"rules":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,24],"inclusive":false},"INITIAL":{"rules":[0,1,2,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],"inclusive":true}}
});
return lexer;
})();
parser.lexer = lexer;
function Parser () {
  this.yy = {};
}
Parser.prototype = parser;parser.Parser = Parser;
return new Parser;
})();
/* --------------------------------- lexp executive ------------------------------- */

    const f_min = function( ...args ) {
        let res = null;
        let n = args.length;
        for ( let i=0; i<n; i++ ) {
            let v = args[ i ];
            if ( Array.isArray( v ) ) {
                v = f_min.apply( null, v );
                if ( null !== v && ( null === res || v < res ) ) {
                    res = v;
                }
            } else if ( "number" === typeof v ) {
                if ( null === res || v < res ) {
                    res = v;
                }
            }
        }
        return res;
    }

    const f_max = function( ...args ) {
        let res = null;
        let n = args.length;
        for ( let i=0; i<n; i++ ) {
            let v = args[ i ];
            if ( Array.isArray( v ) ) {
                v = f_max.apply( null, v );
                if ( null !== v && ( null === res || v > res ) ) {
                    res = v;
                }
            } else if ( "number" === typeof v ) {
                if ( null === res || v > res ) {
                    res = v;
                }
            }
        }
        return res;
    }

    /**
     *  Helper function to handle string dates, which may be a simple time string or a date + time. This is highly
     *  simplified, taking advantage of some behaviors observed in node 16 that seem to slightly deviate from the
     *  spec. YMMV on what will parse to what, but ISO 8601 is explicitly supported by the Date() object and thus
     *  expected to always work. See further comment below.
     */
    const f_dtconv = function( s ) {
        s = String( s ); // insurance
        let r = s.match( /^\s*(\d+):(\d+)(:(\d+))?(\.(\d+))?/ ); // ??? last element could be tighter
        if ( r ) {
            /* Simple time format HH:MM[.SS[.uuu]] */
            let d = new Date();
            d.setHours( r[1] || 0, r[2] || 0, r[4] || 0, r[6] || 0 );
            return d.getTime();
        }

        /** Just let JS handle it. If it contains only a date (e.g. 7/15/2022), JS will make a midnight time for the
         *  correct date (at least in node 16.13) within the correct TZ (cool!). Otherwise, invalid date (getTime()=NaN).
         *  A date and time like "7/15/2022 12:34:56" is also handled correctly. Various date forms seem to be supported,
         *  like "2022-07-15" and "Jul 15, 2022" and "2022 July 15".
         */
        /** N.B. Humpf. nodejs 16.13.1, if the string does not contain a time component, the time generated is midnight
         *       ***UTC***, not midnight local. Oddly, if we supply midnight time, the result is midnight local. Seems
         *       like something is wrong here in JS, but we can work around it.
         */
        if ( ! s.match( /\d+:\d+/ ) ) {
            /* No time found, so add it. */
            s += ' 00:00:00.000';
        }
        let d = new Date( s ).getTime();
        if ( isNaN( d ) ) {
            throw new Error( `time() received unparseable date/time string: ${s}` );
        }
        return d;
    }

    const nativeFuncs = {
          abs       : { nargs: 1, impl: (v) => v >= 0 ? v : -v }
        , sign      : { nargs: 1, impl: Math.sign }
        , floor     : { nargs: 1, impl: Math.floor }
        , ceil      : { nargs: 1, impl: Math.ceil }
        , round     : { nargs: 2, impl: function( n, p ) { return Math.round( n * Math.pow(10, p || 0) ) / Math.pow(10, p || 0); } }
        , trunc     : { nargs: 1, impl: Math.trunc }
        , cos       : { nargs: 1, impl: Math.cos }
        , sin       : { nargs: 1, impl: Math.sin }
        , tan       : { nargs: 1, impl: Math.tan }
        , log       : { nargs: 1, impl: Math.log }
        , exp       : { nargs: 1, impl: Math.exp }
        , pow       : { nargs: 2, impl: Math.pow }
        , sqrt      : { nargs: 1, impl: Math.sqrt }
        , random    : { nargs: 0, impl: Math.random }
        , min       : { nargs: 1, impl: function( ...args ) { return f_min( null, ...args ); } }
        , max       : { nargs: 1, impl: function( ...args ) { return f_max( null, ...args ); } }
        , len       : { nargs: 1, impl: (s) => s.length }
        , substr    : { nargs: 2, impl: function( s, p, l ) { s = String(s); if (l==undefined) l=s.length; return s.substr(p,l); } }
        , upper     : { nargs: 1, impl: (s) => String(s).toUpperCase() }
        , lower     : { nargs: 1, impl: (s) => String(s).toLowerCase() }
        , match     : { nargs: 2, impl: function( s, p, n, f ) { let r = String(s).match( new RegExp( p, f ) ); return ( r === null ) ? null : r[n || 0]; } }
        , find      : { nargs: 2, impl: function( s, p, f ) { let r = String(s).match( new RegExp( p, f ) ); return ( r === null ) ? -1 : r.index; } }
        , replace   : { nargs: 3, impl: function( s, p, r, f ) { return String(s).replace( new RegExp( p, f ), r ); } }
        , rtrim     : { nargs: 1, impl: (s) => String(s).replace( /\s+$/, "" ) }
        , ltrim     : { nargs: 1, impl: (s) => String(s).replace( /^\s+/, "" ) }
        , trim      : { nargs: 1, impl: (s) => String(s).trim() }
        , split     : { nargs: 2, impl: (s,p,n) => String(s).split( p, n ) }
        , "int"     : { nargs: 1, impl: parseInt }
        , "float"   : { nargs: 1, impl: parseFloat }
        , "bool"    : { nargs: 1, impl: function( s ) { return !!s && null === String(s).match( /^\s*(0|no|off|false)\s*$/i ); } }
        , str       : { nargs: 1, impl: (s) => String(s) }
        , pad       : { nargs: 2, impl: (s,l,p) => l > 0 ? String(s)+(p||' ').repeat(Math.max(0,l-s.length)) : (p||' ').repeat(Math.max(0,-s.length-l))+String(s) }
        , quote     : { nargs: 1, impl: (s) => String(s).replace( /[\\"\b\f\n\r\t\v]/g, (t) => c_quot[t] || t ) }
        , hex       : { nargs: 1, impl: (n) => Number( n ).toString( 16 ) }
        , time      : { nargs: 0, impl: function( ...args ) {
                if ( 1 === args.length && "object" === typeof ( args[0] ) ) {
                    /* Construct from dateparts() result */
                    let obj = args[0];
                    let now = new Date();
                    let d = (v,f) => ( "undefined" === typeof v || null === v ) ? f : v;
                    return new Date( d( obj.year, now.getFullYear() ),
                        ( "undefined" === typeof obj.month || null === obj.month ) ? 0 : ( obj.month-FEATURE_MONTH_BASE ),
                        d( obj.day, 1 ), d( obj.hour, 0 ), d( obj.minute, 0 ),
                        d( obj.second, 0 ), d( obj.millis, 0 ) ).getTime();
                } else if ( args.length === 1 && "string" === typeof( args[ 0 ] ) ) {
                    return f_dtconv( args[ 0 ] );
                } else if ( args.length >= 1 && "number" === typeof( args[0] ) ) {
                    args[1] -= FEATURE_MONTH_BASE;
                } else if ( 0 !== args.length ) {
                    throw new Error( "Invalid arguments to time()" );
                }
                return new Date( ...args ).getTime();
            }
        }
        , dateparts : { nargs: 0, impl: (m) => {
                let d = "undefined" === typeof m ? new Date() : new Date(m);
                let ret = { year: d.getFullYear(), month: d.getMonth()+FEATURE_MONTH_BASE, day: d.getDate(),
                         hour: d.getHours(), minute: d.getMinutes(), second: d.getSeconds(),
                         millis: d.getMilliseconds(), weekday: d.getDay() };
                /* Day of Year; ref: https://stackoverflow.com/posts/40975730/timeline */
                ret.yday = (Date.UTC(ret.year, ret.month-FEATURE_MONTH_BASE, ret.day) - Date.UTC(ret.year,0,0)) / 24 / 60 / 60 / 1000;
                /* ISO-8601 Week Number; ref: https://www.epochconverter.com/weeknumbers */
                let t = new Date( d.valueOf() );
                let dn = ( t.getDay() + 6 ) % 7;
                t.setDate( t.getDate() - dn + 3 );
                let fth = t.valueOf();
                t.setMonth( 0, 1 );
                if ( t.getDay() != 4 ) t.setMonth( 0, 1 + (( 4 - t.getDay() ) + 7) % 7 );
                ret.isoweek = 1 + Math.ceil( ( fth - t ) / 604800000 );
                /* DST. Get the current timezone offset first. */
                const coffs = Date.UTC( ret.year, ret.month-FEATURE_MONTH_BASE, ret.day, ret.hour, ret.minute, ret.second ) - d;
                /* Now get offsets for January and June, same year, day, time */
                const offs0 = Date.UTC( ret.year, 0, ret.day, ret.hour, ret.minute, ret.second ) - d.setMonth( 0 );
                const offs5 = Date.UTC( ret.year, 5, ret.day, ret.hour, ret.minute, ret.second ) - d.setMonth( 5 );
                /* If current offset is greater than Jan or Jun offset, we're in DST */
                ret.dst = coffs > offs0 || coffs > offs5;
                return ret;
            }
        }
        , "isNaN"   : { nargs: 1, impl: (n) => null === n || "undefined" === typeof n || Number.isNaN(n) || isNaN(n) }  /* See README */
        , isnull    : { nargs: 1, impl: (s) => "undefined" === typeof s || null === s }
        , isInfinity: { nargs: 1, impl: (s) => ! isFinite(s) }
        , keys      : { nargs: 1, impl: Object.keys }
        , values    : { nargs: 1, impl: Object.values }
        , clone     : { nargs: 1, impl: (a) => JSON.parse( JSON.stringify( a ) ) }
        , join      : { nargs: 2, impl: (a,s) => a.join(s) }
        , list      : { nargs: 0, impl: function( ...args ) { return args; } }
        , indexOf   : { nargs: 2, impl: (a,el) => a.indexOf( el ) }
        , count     : { nargs: 1, impl: function( a ) {
                let n=0;
                Array.isArray( a ) ? a.forEach( el => { ( "undefined" !== typeof el && null !== el ) ? ++n : n } ) : n;
                return n;
            }
        }
        , sum       : { nargs: 1, impl: function( a ) {
                let n=0; Array.isArray( a ) ? a.forEach( el => { ( "number" === typeof el ) ? n += el : 0 } ) : 0;
                return n;
            }
        }
        , median    : { nargs: 1, impl: (a) => {
                if ( Array.isArray( a ) && a.length > 0 ) {
                    let t = a.sort( ( a, b ) => a - b ); /* Numeric sort */
                    return ( 0 === ( t.length & 1 ) ) ? ( ( t[t.length/2-1] + t[t.length/2] ) / 2 ) : t[Math.floor( t.length / 2 )];
                }
                return null;
            }
        }
        , concat    : { nargs: 2, impl: (a,b) => (a||[]).concat(b||[]) }
        , slice     : { nargs: 2, impl: (a,s,e) => (a||[]).slice( s, e ) }
        , insert    : { nargs: 2, impl: (a,p,...el) => { a.splice( p, 0, ...el ); return a; } }
        , remove    : { nargs: 2, impl: (a,s,n) => { a.splice( s, "undefined" === typeof n ? 1 : n ); return a; } }
        , push      : { nargs: 2, impl: (a,v,n) => { a = a || []; a.push(v); if ( n && a.length > n ) a.splice( 0, a.length-n ); return a; } }
        , pop       : { nargs: 1, impl: (a) => a.pop() }
        , unshift   : { nargs: 2, impl: (a,v,n) => { a = a || []; a.unshift(v); if ( n && a.length > n ) a.splice( n, a.length-n ); return a; } }
        , shift     : { nargs: 1, impl: (a) => a.shift() }
        , isArray   : { nargs: 1, impl: Array.isArray }
        , isObject  : { nargs: 1, impl: (p) => null !== p && "object" === typeof p }
        , sort      : { nargs: 1, impl: true } /* custom eval, see implementation of fref atom */
        , arrayConcat: { nargs: 2, impl: (a,b) => a.concat( b ) }
        , arrayIntersection: { nargs: 2, impl: (a,b) => a.filter( el => b.includes( el ) ) }
        , arrayDifference: { nargs: 2, impl: (a,b) => a.filter( el => ! b.includes( el ) ) }
        , arrayExclusive: { nargs: 2, impl: (a,b) => a.filter( el => ! b.includes( el ) ).concat( b.filter( el => ! a.includes( el ) ) ) }
        , arrayUnion: { nargs: 2, impl: (a,b) => a.concat( b.filter( el => ! a.includes( el ) ) ) }
        , toJSON    : { nargs: 1, impl: JSON.stringify }
        , parseJSON : { nargs: 1, impl: JSON.parse }
        , btoa      : { nargs: 1, impl: (b) => Buffer.from( b, "utf-8" ).toString( "base64" ) }
        , atob      : { nargs: 1, impl: (a) => Buffer.from( a, "base64" ).toString( "utf-8" ) }
        , urlencode : { nargs: 1, impl: encodeURIComponent }
        , urldecode : { nargs: 1, impl: decodeURIComponent }
        , "typeof"  : { nargs: 1, impl: (a) => null === a ? 'null' : ( Array.isArray(a) ? 'array' : typeof a ) }
        , "err"     : { nargs: 1, impl: (s) => { throw new Error( String(s) ) } }
/* FUTURE:
        , format
        , dateadd
        , hsltorgb
        , rgbtohsl
*/
    };

    var D = false ? console.log : function() {};

    var get_context = function( vars ) {
        var c = { __lvar: vars || {}, __depth: 0, __tag: 'global', _func: {} };
        c.__global = c;
        return c
    };

    var push_context = function( ctx, tag ) {
        return {
            __global: ctx.__global || ctx,
            __parent: ctx,
            __depth: (ctx.__depth||0)+1,
            __lvar: {},
            __tag: tag
        };
    }

    var pop_context = function( ctx ) {
        return ctx.__parent || ctx;
    }

    function locate_context( key, ctx, subkey ) {
        while ( ctx ) {
            let w = subkey ? ctx[ subkey ] : ctx;
            if ( w && key in w ) {
                return ctx;
            }
            if ( ! ctx.__parent ) {
                break;
            }
            ctx = ctx.__parent;
        }
        return false;
    }

    /**
     * Scan up from the given context for a context with the given tag. If no tag is given,
     * the first tagged context encountered is returned.
     */
    function find_context_tag( ctx, tag ) {
        if ( ctx.__tag && ( ! tag || ctx.__tag === tag ) ) {
            return ctx;
        }
        if ( ctx.__parent ) {
            return find_context_tag( ctx.__parent, tag );
        }
        return false;
    }

    function is_atom( v, typ ) {
        return null !== v && "object" === typeof( v ) &&
            "undefined" !== typeof v.__atom &&
            ( !typ || v.__atom === typ );
    }

    function N( v ) {
        return "undefined" === typeof v ? null : v;
    }

    var run = function( ce, g_ctx ) {
        g_ctx = g_ctx || get_context();

        /* Resolve a VREF atom */
        function _resolve( a, ctx ) {
            /* Scope priority: local, context, external resolver */
            var res;
            let c = locate_context( a.name, ctx, '__lvar' );
            if ( c ) {
                res = c.__lvar[ a.name ];
            } else {
                c = locate_context( '_resolve', ctx, '_func' );
                if ( c ) {
                    res = c._func._resolve( a.name, ctx );
                }
            }
            return N(res);
        }

        function _run( e, ctx ) {
            if ( !is_atom( e ) ) {
                if ( Array.isArray( e ) ) {
                    /* Run each element within array */
                    let res = [];
                    let n = e.length;
                    for ( let k=0; k<n; ++k ) {
                        res[k] = _run( e[k], ctx );
                    }
                    return res;
                } else if ( null !== e && "object" === typeof e ) {
                    let res = {};
                    Object.keys( e ).forEach( key => {
                        res[ key ] = _run( e[ key ], ctx );
                    });
                    return res;
                }
                return e; /* return primitive as it is. */
            } else {
                /* Handle atom */
                if ( is_atom( e, 'list' ) ) {
                    let v = null;
                    e.expr.forEach( function( se ) {
                        v = _run( se, ctx );
                    });
                    return N(v);
                } else if ( is_atom( e, 'vref' ) ) {
                    return N( _resolve( e, ctx ) );
                } else if ( is_atom( e, 'binop' ) ) {
                    var v2 = e.v2;
                    var v1 = e.v1;
                    var v1eval, v2eval;
                    if ( "=" !== e.op ) {
                        v1eval = _run( v1, ctx );
                    }
                    if ( e.op !== "&&" && e.op !== "||" && e.op !== '??' && e.op !== '?#' ) {
                        v2eval = _run( v2, ctx );
                    }
                    // D("binop v1=",v1,", v1eval=",v1eval,", v2=",v2,", v2eval=",v2);
                    if (e.op == '+') {
                        // Special case for plus (+): if either operand is string, treat as concat
                        if ( "string" === typeof v1eval || "string" === typeof v2eval ) {
                            v1eval = ( null === v1eval ? "" : v1eval.toString() ) + ( null === v2eval ? "" : v2eval.toString() );
                        } else {
                            v1eval += v2eval;
                        }
                    }
                    else if (e.op == '-')
                        v1eval -= v2eval;
                    else if (e.op == '*')
                        v1eval *= v2eval;
                    else if (e.op == '/')
                        v1eval /= v2eval;
                    else if (e.op == '**')
                        v1eval = v1eval**v2eval;
                    else if (e.op == '%')
                        v1eval %= v2eval;
                    else if (e.op == '&')
                        v1eval &= v2eval;
                    else if (e.op == '|')
                        v1eval |= v2eval;
                    else if (e.op == '^')
                        v1eval ^= v2eval;
                    else if (e.op == '>')
                        v1eval = v1eval > v2eval;
                    else if (e.op == '>=')
                        v1eval = v1eval >= v2eval;
                    else if (e.op == '<')
                        v1eval = v1eval < v2eval;
                    else if (e.op == '<=')
                        v1eval = v1eval <= v2eval;
                    else if (e.op == '==')
                        v1eval = v1eval == v2eval;
                    else if (e.op == '===')
                        v1eval = v1eval === v2eval;
                    else if (e.op == '!=')
                        v1eval = v1eval != v2eval;
                    else if (e.op == '!==')
                        v1eval = v1eval !== v2eval;
                    else if (e.op == '<<' )
                        v1eval = v1eval << v2eval;
                    else if (e.op == '>>' )
                        v1eval = v1eval >> v2eval;
                    else if (e.op == '>>>' )
                        v1eval = v1eval >>> v2eval;
                    else if (e.op == '&&') {
                        /* short-cut evaluation */
                        v1eval = v1eval && _run( v2, ctx );
                    } else if (e.op == '||') {
                        /* short-cut evaluation */
                        v1eval = v1eval || _run( v2, ctx );
                    } else if (e.op == 'in' ) {
                        v1eval = v1eval in v2eval;
                    } else if (e.op == '??' ) {
                        v1eval = ( null === N(v1eval) ) ? _run( v2, ctx ) : v1eval;
                    } else if (e.op == '?#' ) {
                        v1eval = parseFloat( v1eval );
                        v1eval = ( Number.isNaN(v1eval) || isNaN(v1eval) || ! Number.isFinite( v1eval ) ) ?
                            _run( v2, ctx ) : v1eval;
                    } else if ( ".." === e.op ) {
                        /* Range op */
                        let res = [];
                        if ( "number" !== typeof v1eval || "number" !== typeof v2eval ) {
                            throw new TypeError( "Non-numeric operand to range operator" );
                        }
                        let n = Math.floor( v1eval );
                        v2eval = Math.floor( v2eval );
                        let l = Math.abs( v2eval - n ) + 1;
                        if ( l > MAX_RANGE ) {
                            throw new RangeError( `Range exceeds maximum differential of ${MAX_RANGE}` );
                        }
                        if ( v2eval >= n ) {
                            while ( n <= v2eval ) {
                                res.push( n++ );
                            }
                        } else {
                            while ( n >= v2eval ) {
                                res.push( n-- );
                            }
                        }
                        v1eval = res;
                    } else if ( e.op == '=' ) {
                        /* Assignment */
                        if ( ! ( is_atom( v1, 'vref' ) || is_atom( v1, 'deref' ) ) ||
                                String( v1.name || "" ).startsWith( '__' ) || '_func' === v1.name ) {
                            throw new SyntaxError( `Invalid assignment target (${v1.name})` );
                        }
// D("run() assign",v2eval,"to",v1.name);
                        let c, res;
                        if ( is_atom( v1, 'deref' ) ) {
                            /* Assignment to member */
// D('ASSIGN deref context', v1.context, 'v2', v2);
                            var scope = _run( v1.context, ctx );
                            if ( "object" !== typeof scope || null === scope ) {
                                throw new ReferenceError( `Invalid scope in reference to member ${String(v1.member)} of (${typeof scope})${String(scope)}` );
                            }
                            var member = _run( v1.member, ctx );
                            /* Null and NaN don't pass here */
                            if ( ! ( "number" === typeof member || "string" === typeof member ) || "" === member  ) {
                                throw new ReferenceError( `Invalid reference to member (${typeof member})${String(member)} of ${String(scope)}` );
                            }
// D("ASSIGN",scope,".",member,"=",v2eval);
                            res = scope[ member ] = v2eval;
                        } else {
                            /* Simple assignment to identifier */
                            if ( e.global ) {
                                c = ctx.__global;
                            } else if ( e.local ) {
                                c = ctx;
                            } else {
                                c = locate_context( v1.name, ctx, '__lvar' ) || ctx;
                            }
                            let fc = locate_context( '_assign', ctx, '_func' );
                            if ( fc && "function" === typeof fc._func._assign ) {
                                /* If _assign returns undefined, the normal assignment will be performed. Otherwise, it is
                                 * assumed that _assign has done it.
                                 */
                                res = fc._func._assign( v1.name, v2eval, c, e );
                            }
                            if ( "undefined" === typeof res ) {
                                c.__lvar = c.__lvar || {};
                                c.__lvar[ v1.name ] = v2eval;
                                return v2eval;
                            }
                        }
                        return res;
                    } else {
                        D( e );
                        throw new Error( `BUG: unsupported op in compiled expression: ${String(e.op)}` );
                    }
                    return v1eval;
                } else if ( is_atom( e, 'unop' ) ) {
                    var veval = _run( e.val, ctx );
                    if (e.op == '-')
                        veval = -veval;
                    else if (e.op == '!')
                        veval = !veval;
                    else if (e.op == '~')
                        veval = ~veval;
                    else
                        throw new Error( `BUG: unsupported unop in compiled expression: ${String(e.op)}` );
                    return veval;
                } else if ( is_atom( e, 'deref' ) ) {
                    var scope = _run( e.context, ctx );
                    /* Watch for null-conditional operators */
                    if ( ( e.op === '?.' || e.op == '?[' ) && scope === null ) {
                        return null;
                    }
                    if ( "object" !== typeof scope || null === scope ) {
                        throw new ReferenceError( `Invalid scope in reference to member ${String(e.member)} of (${typeof scope})${String(scope)}` );
                    }
                    var member = _run( e.member, ctx );
                    /* null and NaN are OK here, will likely produce null, which is OK */
                    if ( ! ( null === member || Number.isNaN( member ) || "number" === typeof member || "string" === typeof member ) ) {
                        throw new ReferenceError( `Invalid reference to member (${typeof member})${String(member)} of (${typeof scope})${String(scope)}` );
                    }
                    var res = _run( scope[ member ], ctx );
                    //D("DEREF",scope,".",member,"=",res);
                    return N(res);
                } else if ( is_atom( e, 'if' ) ) {
                    /* Special short-cut function */
                    if ( _run( e.test, ctx ) ) {
                        return N(_run( e.tc, ctx ));  /* if -> true -> then */
                    }
                    if ( e.alts ) {
                        /* elifs */
                        for ( alt of e.alts ) {
                            if ( _run( alt.test, ctx ) ) {
                                return N(_run( alt.tc, ctx ));
                            }
                        }
                    }
                    if ( "undefined" !== typeof e.fc ) {
                        /* else */
                        return N(_run( e.fc, ctx ));
                    }
                    return null; /* default if no else */
                } else if ( is_atom( e, 'fref' ) ) {
                    // D('function ref ' + e.name + ' with ' + e.args.length + ' args');
                    var name = e.name;
                    var impl;
                    if ( "sort" === name ) {
                        /* Special implementation for sort() allows function reference or expr-
                        *  ession as second arg for custom sort. This requires a "late eval-
                        *  uation" (and multiple evaluations) of the sort function/expression.
                        */
                        let a = _run( e.args[0], ctx );
                        ctx = push_context( ctx );
                        /* See if a custom sort is supplied. */
                        if ( e.args.length > 1 ) {
                            /* Can pass reference to defined function... */
                            if ( is_atom( e.args[1], 'vref' ) ) {
                                let c = locate_context( e.args[1].name, ctx, '_func' );
                                if ( c ) {
                                    impl = ( a, b ) => c._func[ e.args[1].name ]( ctx, a, b );
                                }
                            }
                            if ( ! impl ) {
                                /* Assumed to be expression; preset $1 and $2 to comparison operands */
                                impl = function( a, b ) {
                                    ctx.__lvar.$1 = a;
                                    ctx.__lvar.$2 = b;
                                    let r = _run( e.args[1], ctx );
                                    return r;
                                }
                            }
                        }
                        if ( ! impl ) {
                            /* Default sort. Caller can define a locale-aware compare function, or
                            *  the default sort is used.
                            */
                            let c = locate_context( '_compare', ctx, '_func' );
                            if ( c ) {
                                impl = ( a, b ) => c._func._compare( ctx, a, b );
                            }
                        }
                        a = a.sort( impl );
                        ctx = pop_context( ctx );
                        return a;
                    }
                    var impl = false;
                    // Attached to context? Scan from current up.
                    let c = locate_context( name, ctx, '_func' );
                    if ( c ) {
                        impl = c._func[ name ];
                    }
                    if ( ! impl && nativeFuncs[ name ] ) {
                        impl = ( fctx, ...args ) => nativeFuncs[ name ].impl( ...args );
                    }
                    if ( ! impl ) {
                        throw new ReferenceError( `Undefined function (${name})` );
                    }

                    // Build argument list and go. Context is always first argument.
                    var a = [ ctx ];
                    e.args.forEach( function( se ) {
                        a.push( _run( se, ctx ) );
                    });
                    var r = impl.apply( null, a );
                    return N(r);
                } else if ( is_atom( e, 'iter' ) ) {
                    ctx.__lvar = ctx.__lvar || {};
                    let context = N( _run( e.context, ctx ) );
                    let res = [];
                    if ( null !== context ) {
                        // D(e);
                        if ( "object" !== typeof context ) {
                            context = [ context ];
                        }
                        // D("Iterate over",context,"using",e.value,"apply",e.exec);
                        let local_ctx = push_context( ctx );
                        try {
                            for ( [ key, value ] of Object.entries( context ) ) {
                                // D("Assigning",value,"to",e.value);
                                local_ctx.__lvar[ e.value ] = value;
                                if ( e.key ) {
                                    local_ctx.__lvar[ e.key ] = Array.isArray( context ) ? parseInt( key ) : key;
                                }
                                // D("Running",e.exec);
                                let v = _run( e.exec, local_ctx );
                                // D("result",v);
                                if ( v !== null ) {
                                    res.push( v );
                                }
                            }
                        } finally {
                            ctx = pop_context( local_ctx );
                        }
                    }
                    return res;
                } else if ( is_atom( e, 'search' ) ) {
                    let context = N( _run( e.context, ctx ) );
                    let res = null;
                    if ( null !== context ) {
                        ctx.__lvar = ctx.__lvar || {};
                        // D(e);
                        // D("Search",context,"using",e.value,"for",e.exec);
                        if ( "object" !== typeof context ) {
                            context = [ context ];
                        }
                        local_ctx = push_context( ctx );
                        try {
                            for ( const [key, value] of Object.entries( context ) ) {
                                // D("Assigning",value,"to",e.value);
                                local_ctx.__lvar[ e.value ] = value;
                                if ( e.key ) {
                                    local_ctx.__lvar[ e.key ] = key;
                                }
                                let v = _run( e.exec, local_ctx );
                                if ( !!v ) {
                                    if ( e.result ) {
                                        res = _run( e.result, local_ctx );
                                    } else {
                                        res = value;
                                    }
                                    break;
                                }
                            }
                        } finally {
                            ctx = pop_context( local_ctx );
                        }
                    }
                    return res;
                } else if ( is_atom( e, 'block' ) ) {
                    let res = null;
                    try {
                        ctx = push_context( ctx );
                        res = _run( e.block, ctx );
                    } finally {
                        ctx = pop_context( ctx );
                    }
                    return res;
                } else if ( is_atom( e, 'case' ) ) {
                    const list = e.when_list; // list atom
                    let res = null;
                    for ( let c of list.expr ) {
                        var cond = _run( c.test, ctx );
                        if ( cond ) {
                            res = _run( c.tc, ctx );
                            break;
                        }
                        if ( c.fc ) {
                            res = _run( c.fc, ctx );
                            break;
                        }
                    }
                    return res;
                } else if ( is_atom( e, 'fdef' ) ) {
                    let seen = {};
                    /* e.args is list atom */
                    e.args.expr.forEach( (a,ix) => {
                        /* a is vref atom */
                        if ( ! is_atom( a, 'vref' ) ) {
                            throw new SyntaxError( `Invalid argument ${ix}/${e.args.length}, must be identifier` );
                        }
                        if ( seen[ a.name ] ) {
                            throw new SyntaxError( `Argument name conflict (${a.name})` );
                        }
                        seen[ a.name ] = true;
                    });
                    /* Define function; closure loads arguments values passed in to local variables in
                     * new sub-scope, then runs expression list.
                     */
                    ctx._func[ e.name ] = (ctx, ...args) => {
                        let res = null;
                        ctx = push_context( ctx );
                        try {
                            /* Get each defined argument into its corresponding locally-scoped variable */
                            const n = ( e.args.expr || [] ).length;
                            for ( let ix = 0; ix < n; ++ix ) {
                                let v = ix < args.length ? _run( args[ix], ctx ) : null;
                                D( "set arg", ix, e.args.expr[ix].name, '=', v );
                                ctx.__lvar[ e.args.expr[ ix ].name ] = v;
                            }
                            res = _run( e.list, ctx );
                        } finally {
                            ctx = pop_context( ctx );
                        }
                        return res;
                    };
                    return null;
                } else {
                    D("BUG: unsupported atom:", e);
                    throw new Error( `BUG: unsupported atom (${String(e.__atom)})` );
                }
            }
        } /* function _run() */

        D("lexp.run()", ce, g_ctx);
        var result = _run( ce, g_ctx );
        D("lexp.run() finished with", result);
        return result;
    };

    function define_func_impl( ctx, name, impl ) {
        let __global = ctx.__global || ctx;
        __global._func = __global._func || {}
        __global._func[ name ] = impl;
    }

    function define_var( ctx, name, val ) {
        ctx.__lvar = ctx.__lvar || {};
        ctx.__lvar[ name ] = N(val);
        return ctx.__lvar[ name ];
    }

    function set_var( ctx, name, val ) {
        let c = locate_context( name, ctx, '__lvar' );
        if ( ! c ) {
            return define_var( ctx, name, val );
        }
        c.__lvar[ name ] = val;
    }

    function get_var( ctx, name ) {
        let c = locate_context( name, ctx, '__lvar' );
        if ( c ) {
            return c.__lvar[ name ];
        }
        return undefined;
    }

    class CompiledExpression {
        constructor( expr, b ) {
            this.expr = expr;
            this.ce = b;
        }

        toString() {
            return this.expr;
        }
    }

    class ExpressionContext {
        constructor() {
            this.ctx = get_context();
        }

        defineFunction( name, impl ) {
            return define_func_impl( this.ctx, name, impl );
        }

        defineVar( name, val ) {
            return define_var( this.ctx, name, val );
        }

        setVar( name, val ) {
            return set_var( this.ctx, name, val );
        }

        getVar( name ) {
            return get_var( this.ctx, name );
        }

        push( tag ) {
            return this.ctx = push_context( this.ctx, tag );
        }

        /** Pop contexts up to and including tag. If tag is not specified, pop one level. */
        pop( tag ) {
            while ( this.ctx.__tag !== "__global" ) {
                if ( ! tag || this.ctx.__tag === tag ) {
                    this.ctx = pop_context( this.ctx );
                    return this.ctx;
                }
                this.ctx = pop_context( this.ctx );
            }
            return this.ctx;
        }

        getTag() {
            return this.ctx.__tag;
        }

        find( tag ) {
            return find_context_tag( this.ctx, tag );
        }

        getContext() {
            return this.ctx;
        }

        toString() {
            return `[object ExpressionContext#${this.ctx.__tag || ( '<' + this.ctx.__depth + '>' )}]`;
        }
    }

    class LEXP {
        constructor() {
            throw new TypeError( "Do not construct an instance of LEXP; all methods are static" );
        }

        static compile( expr ) {
            return new CompiledExpression( expr, parser.parse( expr ) );
        }

        static run( ce, ctx ) {
            if ( ! ( ce instanceof CompiledExpression ) ) {
                throw new TypeError( "Argument 1 must be a CompiledExpression" );
            }
            if ( ctx && ! ( ctx instanceof ExpressionContext ) ) {
                throw new TypeError( "Argument 2 must be a ExpressionContext" );
            }
            return run( ce.ce, ctx?.ctx );
        }

        static evaluate( expr, ctx ) {
            if ( ctx && ! ( ctx instanceof ExpressionContext ) ) {
                throw new TypeError( "Argument 2 must be a ExpressionContext" );
            }
            return LEXP.run( LEXP.compile( expr ), ctx );
        }

        static toString() {
            return '[class LEXP]';
        }
    }

    return {
        version: version,
        get_context: get_context,
        define_func_impl: define_func_impl,
        define_var: define_var,
        set_var: set_var,
        get_var: get_var,
        push_context: push_context,
        pop_context: pop_context,
        find_context_tag: find_context_tag,
        compile: function( expr ) {
            return parser.parse( expr );
        },
        run: run,
        evaluate: function( expr, context ) {
            return run( parser.parse( expr ), context );
        },
        CompiledExpression: CompiledExpression,
        ExpressionContext: ExpressionContext,
        LEXP: LEXP
    };
}));