time-to-botec

peggyParser.js (197361B)

---

 import * as h from './peggyHelpers.js';
 function peg$subclass(child, parent) {
     function C() { this.constructor = child; }
     C.prototype = parent.prototype;
     child.prototype = new C();
 }
 function peg$SyntaxError(message, expected, found, location) {
     var self = Error.call(this, message);
     if (Object.setPrototypeOf) {
         Object.setPrototypeOf(self, peg$SyntaxError.prototype);
     }
     self.expected = expected;
     self.found = found;
     self.location = location;
     self.name = "SyntaxError";
     return self;
 }
 peg$subclass(peg$SyntaxError, Error);
 function peg$padEnd(str, targetLength, padString) {
     padString = padString || " ";
     if (str.length > targetLength) {
         return str;
     }
     targetLength -= str.length;
     padString += padString.repeat(targetLength);
     return str + padString.slice(0, targetLength);
 }
 peg$SyntaxError.prototype.format = function (sources) {
     var str = "Error: " + this.message;
     if (this.location) {
         var src = null;
         var k;
         for (k = 0; k < sources.length; k++) {
             if (sources[k].source === this.location.source) {
                 src = sources[k].text.split(/\r\n|\n|\r/g);
                 break;
             }
         }
         var s = this.location.start;
         var offset_s = (this.location.source && (typeof this.location.source.offset === "function"))
             ? this.location.source.offset(s)
             : s;
         var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
         if (src) {
             var e = this.location.end;
             var filler = peg$padEnd("", offset_s.line.toString().length, ' ');
             var line = src[s.line - 1];
             var last = s.line === e.line ? e.column : line.length + 1;
             var hatLen = (last - s.column) || 1;
             str += "\n --> " + loc + "\n"
                 + filler + " |\n"
                 + offset_s.line + " | " + line + "\n"
                 + filler + " | " + peg$padEnd("", s.column - 1, ' ')
                 + peg$padEnd("", hatLen, "^");
         }
         else {
             str += "\n at " + loc;
         }
     }
     return str;
 };
 peg$SyntaxError.buildMessage = function (expected, found) {
     var DESCRIBE_EXPECTATION_FNS = {
         literal: function (expectation) {
             return "\"" + literalEscape(expectation.text) + "\"";
         },
         class: function (expectation) {
             var escapedParts = expectation.parts.map(function (part) {
                 return Array.isArray(part)
                     ? classEscape(part[0]) + "-" + classEscape(part[1])
                     : classEscape(part);
             });
             return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
         },
         any: function () {
             return "any character";
         },
         end: function () {
             return "end of input";
         },
         other: function (expectation) {
             return expectation.description;
         }
     };
     function hex(ch) {
         return ch.charCodeAt(0).toString(16).toUpperCase();
     }
     function literalEscape(s) {
         return s
             .replace(/\\/g, "\\\\")
             .replace(/"/g, "\\\"")
             .replace(/\0/g, "\\0")
             .replace(/\t/g, "\\t")
             .replace(/\n/g, "\\n")
             .replace(/\r/g, "\\r")
             .replace(/[\x00-\x0F]/g, function (ch) { return "\\x0" + hex(ch); })
             .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) { return "\\x" + hex(ch); });
     }
     function classEscape(s) {
         return s
             .replace(/\\/g, "\\\\")
             .replace(/\]/g, "\\]")
             .replace(/\^/g, "\\^")
             .replace(/-/g, "\\-")
             .replace(/\0/g, "\\0")
             .replace(/\t/g, "\\t")
             .replace(/\n/g, "\\n")
             .replace(/\r/g, "\\r")
             .replace(/[\x00-\x0F]/g, function (ch) { return "\\x0" + hex(ch); })
             .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) { return "\\x" + hex(ch); });
     }
     function describeExpectation(expectation) {
         return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
     }
     function describeExpected(expected) {
         var descriptions = expected.map(describeExpectation);
         var i, j;
         descriptions.sort();
         if (descriptions.length > 0) {
             for (i = 1, j = 1; i < descriptions.length; i++) {
                 if (descriptions[i - 1] !== descriptions[i]) {
                     descriptions[j] = descriptions[i];
                     j++;
                 }
             }
             descriptions.length = j;
         }
         switch (descriptions.length) {
             case 1:
                 return descriptions[0];
             case 2:
                 return descriptions[0] + " or " + descriptions[1];
             default:
                 return descriptions.slice(0, -1).join(", ")
                     + ", or "
                     + descriptions[descriptions.length - 1];
         }
     }
     function describeFound(found) {
         return found ? "\"" + literalEscape(found) + "\"" : "end of input";
     }
     return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
 };
 function peg$parse(input, options) {
     options = options !== undefined ? options : {};
     var peg$FAILED = {};
     var peg$source = options.grammarSource;
     var peg$startRuleFunctions = { start: peg$parsestart };
     var peg$startRuleFunction = peg$parsestart;
     var peg$c0 = "import";
     var peg$c1 = "as";
     var peg$c2 = "{";
     var peg$c3 = "}";
     var peg$c4 = "call";
     var peg$c5 = "export";
     var peg$c6 = "(";
     var peg$c7 = ")";
     var peg$c8 = "=";
     var peg$c9 = ":";
     var peg$c10 = "if";
     var peg$c11 = "then";
     var peg$c12 = "else";
     var peg$c13 = "?";
     var peg$c14 = "||";
     var peg$c15 = "&&";
     var peg$c16 = "==";
     var peg$c17 = "!=";
     var peg$c18 = "<=";
     var peg$c19 = "<";
     var peg$c20 = ">=";
     var peg$c21 = ">";
     var peg$c22 = "to";
     var peg$c23 = "+";
     var peg$c24 = "-";
     var peg$c25 = ".+";
     var peg$c26 = ".-";
     var peg$c27 = "*";
     var peg$c28 = "/";
     var peg$c29 = ".*";
     var peg$c30 = "./";
     var peg$c31 = "^";
     var peg$c32 = ".^";
     var peg$c33 = "->";
     var peg$c34 = "!";
     var peg$c35 = "[";
     var peg$c36 = ".";
     var peg$c37 = "]";
     var peg$c38 = "()";
     var peg$c39 = "minutes";
     var peg$c40 = "hours";
     var peg$c41 = "days";
     var peg$c42 = "years";
     var peg$c43 = "n";
     var peg$c44 = "m";
     var peg$c45 = "k";
     var peg$c46 = "M";
     var peg$c47 = "B";
     var peg$c48 = "G";
     var peg$c49 = "T";
     var peg$c50 = "P";
     var peg$c51 = "%";
     var peg$c52 = "\\";
     var peg$c53 = "u";
     var peg$c54 = "'";
     var peg$c55 = "\"";
     var peg$c56 = "true";
     var peg$c57 = "false";
     var peg$c58 = "|";
     var peg$c59 = ";";
     var peg$c60 = ",";
     var peg$c61 = "//";
     var peg$c62 = "/*";
     var peg$c63 = "*/";
     var peg$r0 = /^[A-Z]/;
     var peg$r1 = /^[_a-z0-9]/i;
     var peg$r2 = /^[_a-z]/;
     var peg$r3 = /^[$_a-z]/;
     var peg$r4 = /^[$_a-z0-9]/i;
     var peg$r5 = /^[^u]/;
     var peg$r6 = /^[e]/i;
     var peg$r7 = /^[0-9]/;
     var peg$r8 = /^[a-z]/i;
     var peg$r9 = /^[_$]/;
     var peg$r10 = /^[\n\r]/;
     var peg$r11 = /^[^\r\n]/;
     var peg$r12 = /^[^*]/;
     var peg$r13 = /^[*]/;
     var peg$r14 = /^[^\/]/;
     var peg$r15 = /^[ \t]/;
     var peg$e0 = peg$literalExpectation("import", false);
     var peg$e1 = peg$literalExpectation("as", false);
     var peg$e2 = peg$literalExpectation("{", false);
     var peg$e3 = peg$literalExpectation("}", false);
     var peg$e4 = peg$literalExpectation("call", false);
     var peg$e5 = peg$literalExpectation("export", false);
     var peg$e6 = peg$literalExpectation("(", false);
     var peg$e7 = peg$literalExpectation(")", false);
     var peg$e8 = peg$otherExpectation("assignment");
     var peg$e9 = peg$literalExpectation("=", false);
     var peg$e10 = peg$literalExpectation(":", false);
     var peg$e11 = peg$literalExpectation("if", false);
     var peg$e12 = peg$literalExpectation("then", false);
     var peg$e13 = peg$literalExpectation("else", false);
     var peg$e14 = peg$literalExpectation("?", false);
     var peg$e15 = peg$otherExpectation("operator");
     var peg$e16 = peg$literalExpectation("||", false);
     var peg$e17 = peg$literalExpectation("&&", false);
     var peg$e18 = peg$literalExpectation("==", false);
     var peg$e19 = peg$literalExpectation("!=", false);
     var peg$e20 = peg$literalExpectation("<=", false);
     var peg$e21 = peg$literalExpectation("<", false);
     var peg$e22 = peg$literalExpectation(">=", false);
     var peg$e23 = peg$literalExpectation(">", false);
     var peg$e24 = peg$literalExpectation("to", false);
     var peg$e25 = peg$literalExpectation("+", false);
     var peg$e26 = peg$literalExpectation("-", false);
     var peg$e27 = peg$literalExpectation(".+", false);
     var peg$e28 = peg$literalExpectation(".-", false);
     var peg$e29 = peg$literalExpectation("*", false);
     var peg$e30 = peg$literalExpectation("/", false);
     var peg$e31 = peg$literalExpectation(".*", false);
     var peg$e32 = peg$literalExpectation("./", false);
     var peg$e33 = peg$literalExpectation("^", false);
     var peg$e34 = peg$literalExpectation(".^", false);
     var peg$e35 = peg$literalExpectation("->", false);
     var peg$e36 = peg$otherExpectation("unary operator");
     var peg$e37 = peg$literalExpectation("!", false);
     var peg$e38 = peg$literalExpectation("[", false);
     var peg$e39 = peg$literalExpectation(".", false);
     var peg$e40 = peg$literalExpectation("]", false);
     var peg$e41 = peg$otherExpectation("void");
     var peg$e42 = peg$literalExpectation("()", false);
     var peg$e43 = peg$otherExpectation("identifier");
     var peg$e44 = peg$classExpectation([["A", "Z"]], false, false);
     var peg$e45 = peg$classExpectation(["_", ["a", "z"], ["0", "9"]], false, true);
     var peg$e46 = peg$classExpectation(["_", ["a", "z"]], false, false);
     var peg$e47 = peg$literalExpectation("minutes", false);
     var peg$e48 = peg$literalExpectation("hours", false);
     var peg$e49 = peg$literalExpectation("days", false);
     var peg$e50 = peg$literalExpectation("years", false);
     var peg$e51 = peg$literalExpectation("n", false);
     var peg$e52 = peg$literalExpectation("m", false);
     var peg$e53 = peg$literalExpectation("k", false);
     var peg$e54 = peg$literalExpectation("M", false);
     var peg$e55 = peg$literalExpectation("B", false);
     var peg$e56 = peg$literalExpectation("G", false);
     var peg$e57 = peg$literalExpectation("T", false);
     var peg$e58 = peg$literalExpectation("P", false);
     var peg$e59 = peg$literalExpectation("%", false);
     var peg$e60 = peg$classExpectation(["$", "_", ["a", "z"]], false, false);
     var peg$e61 = peg$classExpectation(["$", "_", ["a", "z"], ["0", "9"]], false, true);
     var peg$e62 = peg$otherExpectation("escape sequence");
     var peg$e63 = peg$literalExpectation("\\", false);
     var peg$e64 = peg$classExpectation(["u"], true, false);
     var peg$e65 = peg$literalExpectation("u", false);
     var peg$e66 = peg$anyExpectation();
     var peg$e67 = peg$otherExpectation("string");
     var peg$e68 = peg$literalExpectation("'", false);
     var peg$e69 = peg$literalExpectation("\"", false);
     var peg$e70 = peg$otherExpectation("number");
     var peg$e71 = peg$classExpectation(["e"], false, true);
     var peg$e72 = peg$classExpectation([["0", "9"]], false, false);
     var peg$e73 = peg$otherExpectation("boolean");
     var peg$e74 = peg$literalExpectation("true", false);
     var peg$e75 = peg$literalExpectation("false", false);
     var peg$e76 = peg$classExpectation([["a", "z"]], false, true);
     var peg$e77 = peg$classExpectation(["_", "$"], false, false);
     var peg$e78 = peg$literalExpectation("|", false);
     var peg$e79 = peg$otherExpectation("array");
     var peg$e80 = peg$otherExpectation("dict");
     var peg$e81 = peg$otherExpectation("whitespace");
     var peg$e82 = peg$otherExpectation(";");
     var peg$e83 = peg$literalExpectation(";", false);
     var peg$e84 = peg$otherExpectation(",");
     var peg$e85 = peg$literalExpectation(",", false);
     var peg$e86 = peg$otherExpectation("newline");
     var peg$e87 = peg$classExpectation(["\n", "\r"], false, false);
     var peg$e88 = peg$otherExpectation("line comment");
     var peg$e89 = peg$literalExpectation("//", false);
     var peg$e90 = peg$classExpectation(["\r", "\n"], true, false);
     var peg$e91 = peg$otherExpectation("comment");
     var peg$e92 = peg$literalExpectation("/*", false);
     var peg$e93 = peg$classExpectation(["*"], true, false);
     var peg$e94 = peg$classExpectation(["*"], false, false);
     var peg$e95 = peg$classExpectation(["/"], true, false);
     var peg$e96 = peg$literalExpectation("*/", false);
     var peg$e97 = peg$classExpectation([" ", "\t"], false, false);
     var peg$f0 = function (start) { return start; };
     var peg$f1 = function (imports, statements, finalExpression) {
         if (finalExpression) {
             statements.push(finalExpression);
         }
         return h.nodeProgram(imports, statements, location());
     };
     var peg$f2 = function (imports, finalExpression) { return h.nodeProgram(imports, [finalExpression], location()); };
     var peg$f3 = function (file, variable) { return [file, variable]; };
     var peg$f4 = function (finalExpression) { return h.nodeBlock([finalExpression], location()); };
     var peg$f5 = function (statements, finalExpression) {
         if (finalExpression) {
             statements.push(finalExpression);
         }
         return h.nodeBlock(statements, location());
     };
     var peg$f6 = function (finalExpression) { return h.nodeBlock([finalExpression], location()); };
     var peg$f7 = function (value) {
         const variable = h.nodeIdentifier("_", location());
         return h.nodeLetStatement(variable, value, false, location());
     };
     var peg$f8 = function (exported, variable, value) { return h.nodeLetStatement(variable, value, Boolean(exported), location()); };
     var peg$f9 = function (exported, variable, args, body) {
         const value = h.nodeLambda(args, body, location(), variable);
         return h.nodeDefunStatement(variable, value, Boolean(exported), location());
     };
     var peg$f10 = function (id, annotation) {
         return annotation ? h.nodeIdentifierWithAnnotation(id.value, annotation, location()) : id;
     };
     var peg$f11 = function (condition, trueExpression, falseExpression) { return h.nodeTernary(condition, trueExpression, falseExpression, 'IfThenElse', location()); };
     var peg$f12 = function (condition, trueExpression, falseExpression) { return h.nodeTernary(condition, trueExpression, falseExpression, 'C', location()); };
     var peg$f13 = function (head, tail) { return h.makeInfixChain(head, tail, location()); };
     var peg$f14 = function (head, tail) { return h.makeInfixChain(head, tail, location()); };
     var peg$f15 = function (left, operator, right) { return h.nodeInfixCall(operator, left, right, location()); };
     var peg$f16 = function (left, operator, right) { return h.nodeInfixCall(operator, left, right, location()); };
     var peg$f17 = function (head, tail) { return h.makeInfixChain(head, tail, location()); };
     var peg$f18 = function (head, tail) { return h.makeInfixChain(head, tail, location()); };
     var peg$f19 = function (head, tail) { return h.makeInfixChain(head, tail, location()); };
     var peg$f20 = function (left, operator, right) { return h.nodeInfixCall(operator, left, right, location()); };
     var peg$f21 = function (head, tail) {
         return tail.reduce(function (result, element) {
             return h.nodePipe(result, element.callable, element.args, location());
         }, head);
     };
     var peg$f22 = function (fn, args) { return { callable: fn, args }; };
     var peg$f23 = function (fn) { return { callable: fn, args: [] }; };
     var peg$f24 = function (unaryOperator, right) { return h.nodeUnaryCall(unaryOperator, right, location()); };
     var peg$f25 = function (head, arg) { return { mode: 'bracket', arg }; };
     var peg$f26 = function (head, arg) { return { mode: 'dot', arg }; };
     var peg$f27 = function (head, tail) {
         return tail.reduce(function (result, element) {
             switch (element.mode) {
                 case 'dot':
                     return h.nodeDotLookup(result, element.arg, location());
                 case 'bracket':
                     return h.nodeBracketLookup(result, element.arg, location());
                 default:
                     throw new Error("Parser implementation error");
             }
         }, head);
     };
     var peg$f28 = function (head, args) { return { mode: 'call', args }; };
     var peg$f29 = function (head, arg) { return { mode: 'bracket', arg }; };
     var peg$f30 = function (head, arg) { return { mode: 'dot', arg }; };
     var peg$f31 = function (head, tail) {
         return tail.reduce(function (result, element) {
             switch (element.mode) {
                 case 'call':
                     return h.nodeCall(result, element.args, location());
                 case 'dot':
                     return h.nodeDotLookup(result, element.arg, location());
                 case 'bracket':
                     return h.nodeBracketLookup(result, element.arg, location());
                 default:
                     throw new Error("Parser implementation error");
             }
         }, head);
     };
     var peg$f32 = function () { return h.nodeVoid(location()); };
     var peg$f33 = function (head, tail, final) {
         const modifiers = [head, ...tail, final];
         const modifiedIdentifier = modifiers.join('.');
         return h.nodeIdentifier(modifiedIdentifier, location());
     };
     var peg$f34 = function () { return h.nodeIdentifier(text(), location()); };
     var peg$f35 = function () { return h.nodeIdentifier(text(), location()); };
     var peg$f36 = function (esc) { return h.parseEscapeSequence([esc], location(), error); };
     var peg$f37 = function (esc) { return h.parseEscapeSequence(esc, location(), error); };
     var peg$f38 = function (characters) { return h.nodeString(characters.join(""), location()); };
     var peg$f39 = function (characters) { return h.nodeString(characters.join(""), location()); };
     var peg$f40 = function (number, unit) {
         if (unit === null) {
             return number;
         }
         else {
             return h.nodeUnitValue(number, unit, location());
         }
     };
     var peg$f41 = function (significand, exponent) {
         return h.nodeFloat({
             integer: significand.integer,
             fractional: significand.fractional,
             exponent,
         }, location());
     };
     var peg$f42 = function (integer, fractional) {
         return {
             integer,
             fractional,
         };
     };
     var peg$f43 = function (integer) {
         return {
             integer,
             fractional: null,
         };
     };
     var peg$f44 = function (fractional) {
         return {
             integer: 0,
             fractional,
         };
     };
     var peg$f45 = function () { return parseInt(text(), 10); };
     var peg$f46 = function () { return parseInt(text(), 10); };
     var peg$f47 = function () { return h.nodeBoolean(text() === 'true', location()); };
     var peg$f48 = function (args, statements, finalExpression) {
         statements.push(finalExpression);
         return h.nodeLambda(args, h.nodeBlock(statements, location()), location(), undefined);
     };
     var peg$f49 = function (args, finalExpression) { return h.nodeLambda(args, finalExpression, location(), undefined); };
     var peg$f50 = function () { return h.nodeArray([], location()); };
     var peg$f51 = function (args) { return h.nodeArray(args, location()); };
     var peg$f52 = function () { return h.nodeDict([], location()); };
     var peg$f53 = function (args) { return h.nodeDict(args, location()); };
     var peg$f54 = function (key, value) { return h.nodeKeyValue(key, value, location()); };
     var peg$f55 = function (comment) { options.comments.push(h.lineComment(comment, location())); };
     var peg$f56 = function (comment) { options.comments.push(h.blockComment(comment, location())); };
     var peg$currPos = 0;
     var peg$savedPos = 0;
     var peg$posDetailsCache = [{ line: 1, column: 1 }];
     var peg$maxFailPos = 0;
     var peg$maxFailExpected = [];
     var peg$silentFails = 0;
     var peg$resultsCache = {};
     var peg$result;
     if ("startRule" in options) {
         if (!(options.startRule in peg$startRuleFunctions)) {
             throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
         }
         peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
     }
     function text() {
         return input.substring(peg$savedPos, peg$currPos);
     }
     function offset() {
         return peg$savedPos;
     }
     function range() {
         return {
             source: peg$source,
             start: peg$savedPos,
             end: peg$currPos
         };
     }
     function location() {
         return peg$computeLocation(peg$savedPos, peg$currPos);
     }
     function expected(description, location) {
         location = location !== undefined
             ? location
             : peg$computeLocation(peg$savedPos, peg$currPos);
         throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location);
     }
     function error(message, location) {
         location = location !== undefined
             ? location
             : peg$computeLocation(peg$savedPos, peg$currPos);
         throw peg$buildSimpleError(message, location);
     }
     function peg$literalExpectation(text, ignoreCase) {
         return { type: "literal", text: text, ignoreCase: ignoreCase };
     }
     function peg$classExpectation(parts, inverted, ignoreCase) {
         return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
     }
     function peg$anyExpectation() {
         return { type: "any" };
     }
     function peg$endExpectation() {
         return { type: "end" };
     }
     function peg$otherExpectation(description) {
         return { type: "other", description: description };
     }
     function peg$computePosDetails(pos) {
         var details = peg$posDetailsCache[pos];
         var p;
         if (details) {
             return details;
         }
         else {
             p = pos - 1;
             while (!peg$posDetailsCache[p]) {
                 p--;
             }
             details = peg$posDetailsCache[p];
             details = {
                 line: details.line,
                 column: details.column
             };
             while (p < pos) {
                 if (input.charCodeAt(p) === 10) {
                     details.line++;
                     details.column = 1;
                 }
                 else {
                     details.column++;
                 }
                 p++;
             }
             peg$posDetailsCache[pos] = details;
             return details;
         }
     }
     function peg$computeLocation(startPos, endPos, offset) {
         var startPosDetails = peg$computePosDetails(startPos);
         var endPosDetails = peg$computePosDetails(endPos);
         var res = {
             source: peg$source,
             start: {
                 offset: startPos,
                 line: startPosDetails.line,
                 column: startPosDetails.column
             },
             end: {
                 offset: endPos,
                 line: endPosDetails.line,
                 column: endPosDetails.column
             }
         };
         if (offset && peg$source && (typeof peg$source.offset === "function")) {
             res.start = peg$source.offset(res.start);
             res.end = peg$source.offset(res.end);
         }
         return res;
     }
     function peg$fail(expected) {
         if (peg$currPos < peg$maxFailPos) {
             return;
         }
         if (peg$currPos > peg$maxFailPos) {
             peg$maxFailPos = peg$currPos;
             peg$maxFailExpected = [];
         }
         peg$maxFailExpected.push(expected);
     }
     function peg$buildSimpleError(message, location) {
         return new peg$SyntaxError(message, null, null, location);
     }
     function peg$buildStructuredError(expected, found, location) {
         return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
     }
     function peg$parsestart() {
         var s0, s1, s2, s3, s4;
         var key = peg$currPos * 82 + 0;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parse_nl();
         s2 = peg$parseouterBlock();
         if (s2 !== peg$FAILED) {
             s3 = peg$parse_nl();
             s4 = peg$parsefinalComment();
             if (s4 === peg$FAILED) {
                 s4 = null;
             }
             peg$savedPos = s0;
             s0 = peg$f0(s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsezeroOMoreArgumentsBlockOrExpression() {
         var s0;
         var key = peg$currPos * 82 + 1;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parselambda();
         if (s0 === peg$FAILED) {
             s0 = peg$parseinnerBlockOrExpression();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseouterBlock() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 2;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseimportStatementsList();
         s2 = peg$parsestatementsList();
         if (s2 !== peg$FAILED) {
             s3 = peg$currPos;
             s4 = peg$parsestatementSeparator();
             if (s4 !== peg$FAILED) {
                 s5 = peg$parseexpression();
                 if (s5 !== peg$FAILED) {
                     s3 = s5;
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             if (s3 === peg$FAILED) {
                 s3 = null;
             }
             peg$savedPos = s0;
             s0 = peg$f1(s1, s2, s3);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = peg$parseimportStatementsList();
             s2 = peg$parseexpression();
             if (s2 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f2(s1, s2);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseimportStatementsList() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 3;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = [];
         s1 = peg$currPos;
         s2 = peg$parseimportStatement();
         if (s2 !== peg$FAILED) {
             s3 = peg$parse__nl();
             if (s3 !== peg$FAILED) {
                 s1 = s2;
             }
             else {
                 peg$currPos = s1;
                 s1 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         while (s1 !== peg$FAILED) {
             s0.push(s1);
             s1 = peg$currPos;
             s2 = peg$parseimportStatement();
             if (s2 !== peg$FAILED) {
                 s3 = peg$parse__nl();
                 if (s3 !== peg$FAILED) {
                     s1 = s2;
                 }
                 else {
                     peg$currPos = s1;
                     s1 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s1;
                 s1 = peg$FAILED;
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseimportStatement() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
         var key = peg$currPos * 82 + 4;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parse_nl();
         if (input.substr(peg$currPos, 6) === peg$c0) {
             s2 = peg$c0;
             peg$currPos += 6;
         }
         else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e0);
             }
         }
         if (s2 !== peg$FAILED) {
             s3 = peg$parse__();
             if (s3 !== peg$FAILED) {
                 s4 = peg$parsestring();
                 if (s4 !== peg$FAILED) {
                     s5 = peg$currPos;
                     s6 = peg$parse__();
                     if (s6 !== peg$FAILED) {
                         if (input.substr(peg$currPos, 2) === peg$c1) {
                             s7 = peg$c1;
                             peg$currPos += 2;
                         }
                         else {
                             s7 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e1);
                             }
                         }
                         if (s7 !== peg$FAILED) {
                             s8 = peg$parse__();
                             if (s8 !== peg$FAILED) {
                                 s9 = peg$parseidentifier();
                                 if (s9 !== peg$FAILED) {
                                     s5 = s9;
                                 }
                                 else {
                                     peg$currPos = s5;
                                     s5 = peg$FAILED;
                                 }
                             }
                             else {
                                 peg$currPos = s5;
                                 s5 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s5;
                             s5 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s5;
                         s5 = peg$FAILED;
                     }
                     if (s5 !== peg$FAILED) {
                         peg$savedPos = s0;
                         s0 = peg$f3(s4, s5);
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseinnerBlockOrExpression() {
         var s0, s1;
         var key = peg$currPos * 82 + 5;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsequotedInnerBlock();
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = peg$parseexpression();
             if (s1 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s1 = peg$f4(s1);
             }
             s0 = s1;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsequotedInnerBlock() {
         var s0, s1, s2, s3, s4, s5, s6;
         var key = peg$currPos * 82 + 6;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 123) {
             s1 = peg$c2;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e2);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             s3 = peg$parsestatementsList();
             if (s3 !== peg$FAILED) {
                 s4 = peg$currPos;
                 s5 = peg$parsestatementSeparator();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parseexpression();
                     if (s6 !== peg$FAILED) {
                         s4 = s6;
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s4;
                     s4 = peg$FAILED;
                 }
                 if (s4 !== peg$FAILED) {
                     s5 = peg$parse_nl();
                     if (input.charCodeAt(peg$currPos) === 125) {
                         s6 = peg$c3;
                         peg$currPos++;
                     }
                     else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e3);
                         }
                     }
                     if (s6 !== peg$FAILED) {
                         peg$savedPos = s0;
                         s0 = peg$f5(s3, s4);
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 123) {
                 s1 = peg$c2;
                 peg$currPos++;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e2);
                 }
             }
             if (s1 !== peg$FAILED) {
                 s2 = peg$parse_nl();
                 s3 = peg$parseexpression();
                 if (s3 !== peg$FAILED) {
                     s4 = peg$parse_nl();
                     if (input.charCodeAt(peg$currPos) === 125) {
                         s5 = peg$c3;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e3);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         peg$savedPos = s0;
                         s0 = peg$f6(s3);
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsestatementsList() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 7;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = [];
         s2 = peg$parsestatement();
         while (s2 !== peg$FAILED) {
             s1.push(s2);
             s2 = peg$currPos;
             s3 = peg$parsestatementSeparator();
             if (s3 !== peg$FAILED) {
                 s3 = peg$parsestatement();
                 if (s3 === peg$FAILED) {
                     peg$currPos = s2;
                     s2 = peg$FAILED;
                 }
                 else {
                     s2 = s3;
                 }
             }
             else {
                 s2 = s3;
             }
         }
         if (s1.length < 1) {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         else {
             s0 = s1;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsestatement() {
         var s0;
         var key = peg$currPos * 82 + 8;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parseletStatement();
         if (s0 === peg$FAILED) {
             s0 = peg$parsedefunStatement();
             if (s0 === peg$FAILED) {
                 s0 = peg$parsevoidStatement();
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsevoidStatement() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 9;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (input.substr(peg$currPos, 4) === peg$c4) {
             s1 = peg$c4;
             peg$currPos += 4;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e4);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             s3 = peg$parsezeroOMoreArgumentsBlockOrExpression();
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f7(s3);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseletStatement() {
         var s0, s1, s2, s3, s4, s5, s6;
         var key = peg$currPos * 82 + 10;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$currPos;
         if (input.substr(peg$currPos, 6) === peg$c5) {
             s2 = peg$c5;
             peg$currPos += 6;
         }
         else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e5);
             }
         }
         if (s2 !== peg$FAILED) {
             s3 = peg$parse__nl();
             if (s3 !== peg$FAILED) {
                 s2 = [s2, s3];
                 s1 = s2;
             }
             else {
                 peg$currPos = s1;
                 s1 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         if (s1 === peg$FAILED) {
             s1 = null;
         }
         s2 = peg$parsevariable();
         if (s2 !== peg$FAILED) {
             s3 = peg$parse_();
             s4 = peg$parseassignmentOp();
             if (s4 !== peg$FAILED) {
                 s5 = peg$parse_nl();
                 s6 = peg$parsezeroOMoreArgumentsBlockOrExpression();
                 if (s6 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f8(s1, s2, s6);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsedefunStatement() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
         var key = peg$currPos * 82 + 11;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$currPos;
         if (input.substr(peg$currPos, 6) === peg$c5) {
             s2 = peg$c5;
             peg$currPos += 6;
         }
         else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e5);
             }
         }
         if (s2 !== peg$FAILED) {
             s3 = peg$parse__nl();
             if (s3 !== peg$FAILED) {
                 s2 = [s2, s3];
                 s1 = s2;
             }
             else {
                 peg$currPos = s1;
                 s1 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         if (s1 === peg$FAILED) {
             s1 = null;
         }
         s2 = peg$parsevariable();
         if (s2 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 40) {
                 s3 = peg$c6;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e6);
                 }
             }
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parsefunctionParameters();
                 s6 = peg$parse_nl();
                 if (input.charCodeAt(peg$currPos) === 41) {
                     s7 = peg$c7;
                     peg$currPos++;
                 }
                 else {
                     s7 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e7);
                     }
                 }
                 if (s7 !== peg$FAILED) {
                     s8 = peg$parse_();
                     s9 = peg$parseassignmentOp();
                     if (s9 !== peg$FAILED) {
                         s10 = peg$parse_nl();
                         s11 = peg$parseinnerBlockOrExpression();
                         if (s11 !== peg$FAILED) {
                             peg$savedPos = s0;
                             s0 = peg$f9(s1, s2, s5, s11);
                         }
                         else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseassignmentOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 12;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 61) {
             s0 = peg$c8;
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e9);
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e8);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefunctionParameters() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 13;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = [];
         s1 = peg$parsefunctionParameter();
         while (s1 !== peg$FAILED) {
             s0.push(s1);
             s1 = peg$currPos;
             s2 = peg$parsecommaSeparator();
             if (s2 !== peg$FAILED) {
                 s2 = peg$parsefunctionParameter();
                 if (s2 === peg$FAILED) {
                     peg$currPos = s1;
                     s1 = peg$FAILED;
                 }
                 else {
                     s1 = s2;
                 }
             }
             else {
                 s1 = s2;
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefunctionParameter() {
         var s0, s1, s2, s3, s4, s5, s6;
         var key = peg$currPos * 82 + 14;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsedollarIdentifier();
         if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
             s3 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 58) {
                 s4 = peg$c9;
                 peg$currPos++;
             }
             else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e10);
                 }
             }
             if (s4 !== peg$FAILED) {
                 s5 = peg$parse_nl();
                 s6 = peg$parseexpression();
                 if (s6 !== peg$FAILED) {
                     s2 = s6;
                 }
                 else {
                     peg$currPos = s2;
                     s2 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s2;
                 s2 = peg$FAILED;
             }
             if (s2 === peg$FAILED) {
                 s2 = null;
             }
             peg$savedPos = s0;
             s0 = peg$f10(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseexpression() {
         var s0;
         var key = peg$currPos * 82 + 15;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parseifthenelse();
         if (s0 === peg$FAILED) {
             s0 = peg$parseternary();
             if (s0 === peg$FAILED) {
                 s0 = peg$parselogicalOr();
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseifthenelse() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
         var key = peg$currPos * 82 + 16;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (input.substr(peg$currPos, 2) === peg$c10) {
             s1 = peg$c10;
             peg$currPos += 2;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e11);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse__nl();
             if (s2 !== peg$FAILED) {
                 s3 = peg$parselogicalOr();
                 if (s3 !== peg$FAILED) {
                     s4 = peg$parse__nl();
                     if (s4 !== peg$FAILED) {
                         if (input.substr(peg$currPos, 4) === peg$c11) {
                             s5 = peg$c11;
                             peg$currPos += 4;
                         }
                         else {
                             s5 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e12);
                             }
                         }
                         if (s5 !== peg$FAILED) {
                             s6 = peg$parse__nl();
                             if (s6 !== peg$FAILED) {
                                 s7 = peg$parseinnerBlockOrExpression();
                                 if (s7 !== peg$FAILED) {
                                     s8 = peg$parse__nl();
                                     if (s8 !== peg$FAILED) {
                                         if (input.substr(peg$currPos, 4) === peg$c12) {
                                             s9 = peg$c12;
                                             peg$currPos += 4;
                                         }
                                         else {
                                             s9 = peg$FAILED;
                                             if (peg$silentFails === 0) {
                                                 peg$fail(peg$e13);
                                             }
                                         }
                                         if (s9 !== peg$FAILED) {
                                             s10 = peg$parse__nl();
                                             if (s10 !== peg$FAILED) {
                                                 s11 = peg$parseifthenelse();
                                                 if (s11 === peg$FAILED) {
                                                     s11 = peg$parseinnerBlockOrExpression();
                                                 }
                                                 if (s11 !== peg$FAILED) {
                                                     peg$savedPos = s0;
                                                     s0 = peg$f11(s3, s7, s11);
                                                 }
                                                 else {
                                                     peg$currPos = s0;
                                                     s0 = peg$FAILED;
                                                 }
                                             }
                                             else {
                                                 peg$currPos = s0;
                                                 s0 = peg$FAILED;
                                             }
                                         }
                                         else {
                                             peg$currPos = s0;
                                             s0 = peg$FAILED;
                                         }
                                     }
                                     else {
                                         peg$currPos = s0;
                                         s0 = peg$FAILED;
                                     }
                                 }
                                 else {
                                     peg$currPos = s0;
                                     s0 = peg$FAILED;
                                 }
                             }
                             else {
                                 peg$currPos = s0;
                                 s0 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseternary() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
         var key = peg$currPos * 82 + 17;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parselogicalOr();
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 63) {
                 s3 = peg$c13;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e14);
                 }
             }
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parselogicalOr();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 58) {
                         s7 = peg$c9;
                         peg$currPos++;
                     }
                     else {
                         s7 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e10);
                         }
                     }
                     if (s7 !== peg$FAILED) {
                         s8 = peg$parse_nl();
                         s9 = peg$parseternary();
                         if (s9 === peg$FAILED) {
                             s9 = peg$parselogicalOr();
                         }
                         if (s9 !== peg$FAILED) {
                             peg$savedPos = s0;
                             s0 = peg$f12(s1, s5, s9);
                         }
                         else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parselogicalOr() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 18;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parselogicalAnd();
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = peg$parselogicalOrOp();
             if (s5 !== peg$FAILED) {
                 s6 = peg$parse_nl();
                 s7 = peg$parselogicalAnd();
                 if (s7 !== peg$FAILED) {
                     s3 = [s5, s7];
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 s5 = peg$parselogicalOrOp();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse_nl();
                     s7 = peg$parselogicalAnd();
                     if (s7 !== peg$FAILED) {
                         s3 = [s5, s7];
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             peg$savedPos = s0;
             s0 = peg$f13(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parselogicalOrOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 19;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.substr(peg$currPos, 2) === peg$c14) {
             s0 = peg$c14;
             peg$currPos += 2;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e16);
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parselogicalAnd() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 20;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseequality();
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = peg$parselogicalAndOp();
             if (s5 !== peg$FAILED) {
                 s6 = peg$parse_nl();
                 s7 = peg$parseequality();
                 if (s7 !== peg$FAILED) {
                     s3 = [s5, s7];
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 s5 = peg$parselogicalAndOp();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse_nl();
                     s7 = peg$parseequality();
                     if (s7 !== peg$FAILED) {
                         s3 = [s5, s7];
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             peg$savedPos = s0;
             s0 = peg$f14(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parselogicalAndOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 21;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.substr(peg$currPos, 2) === peg$c15) {
             s0 = peg$c15;
             peg$currPos += 2;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e17);
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseequality() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 22;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parserelational();
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             s3 = peg$parseequalityOp();
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parserelational();
                 if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f15(s1, s3, s5);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$parserelational();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseequalityOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 23;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.substr(peg$currPos, 2) === peg$c16) {
             s0 = peg$c16;
             peg$currPos += 2;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e18);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.substr(peg$currPos, 2) === peg$c17) {
                 s0 = peg$c17;
                 peg$currPos += 2;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e19);
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parserelational() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 24;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsecredibleInterval();
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             s3 = peg$parserelationalOp();
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parsecredibleInterval();
                 if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f16(s1, s3, s5);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$parsecredibleInterval();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parserelationalOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 25;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.substr(peg$currPos, 2) === peg$c18) {
             s0 = peg$c18;
             peg$currPos += 2;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e20);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 60) {
                 s0 = peg$c19;
                 peg$currPos++;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e21);
                 }
             }
             if (s0 === peg$FAILED) {
                 if (input.substr(peg$currPos, 2) === peg$c20) {
                     s0 = peg$c20;
                     peg$currPos += 2;
                 }
                 else {
                     s0 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e22);
                     }
                 }
                 if (s0 === peg$FAILED) {
                     if (input.charCodeAt(peg$currPos) === 62) {
                         s0 = peg$c21;
                         peg$currPos++;
                     }
                     else {
                         s0 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e23);
                         }
                     }
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsecredibleInterval() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 26;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseadditive();
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$parse__();
             if (s4 !== peg$FAILED) {
                 s5 = peg$parsecredibleIntervalOp();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse__nl();
                     if (s6 !== peg$FAILED) {
                         s7 = peg$parseadditive();
                         if (s7 !== peg$FAILED) {
                             s3 = [s5, s7];
                         }
                         else {
                             peg$currPos = s3;
                             s3 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$parse__();
                 if (s4 !== peg$FAILED) {
                     s5 = peg$parsecredibleIntervalOp();
                     if (s5 !== peg$FAILED) {
                         s6 = peg$parse__nl();
                         if (s6 !== peg$FAILED) {
                             s7 = peg$parseadditive();
                             if (s7 !== peg$FAILED) {
                                 s3 = [s5, s7];
                             }
                             else {
                                 peg$currPos = s3;
                                 s3 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s3;
                             s3 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             peg$savedPos = s0;
             s0 = peg$f17(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsecredibleIntervalOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 27;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.substr(peg$currPos, 2) === peg$c22) {
             s0 = peg$c22;
             peg$currPos += 2;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e24);
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseadditive() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 28;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsemultiplicative();
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = peg$parseadditiveOp();
             if (s5 !== peg$FAILED) {
                 s6 = peg$parse_nl();
                 s7 = peg$parsemultiplicative();
                 if (s7 !== peg$FAILED) {
                     s3 = [s5, s7];
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 s5 = peg$parseadditiveOp();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse_nl();
                     s7 = peg$parsemultiplicative();
                     if (s7 !== peg$FAILED) {
                         s3 = [s5, s7];
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             peg$savedPos = s0;
             s0 = peg$f18(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseadditiveOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 29;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 43) {
             s0 = peg$c23;
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e25);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 45) {
                 s0 = peg$c24;
                 peg$currPos++;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e26);
                 }
             }
             if (s0 === peg$FAILED) {
                 if (input.substr(peg$currPos, 2) === peg$c25) {
                     s0 = peg$c25;
                     peg$currPos += 2;
                 }
                 else {
                     s0 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e27);
                     }
                 }
                 if (s0 === peg$FAILED) {
                     if (input.substr(peg$currPos, 2) === peg$c26) {
                         s0 = peg$c26;
                         peg$currPos += 2;
                     }
                     else {
                         s0 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e28);
                         }
                     }
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsemultiplicative() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 30;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsepower();
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$parse_();
             s5 = peg$parsemultiplicativeOp();
             if (s5 !== peg$FAILED) {
                 s6 = peg$parse_nl();
                 s7 = peg$parsepower();
                 if (s7 !== peg$FAILED) {
                     s3 = [s5, s7];
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 s5 = peg$parsemultiplicativeOp();
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse_nl();
                     s7 = peg$parsepower();
                     if (s7 !== peg$FAILED) {
                         s3 = [s5, s7];
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             peg$savedPos = s0;
             s0 = peg$f19(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsemultiplicativeOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 31;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 42) {
             s0 = peg$c27;
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e29);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 47) {
                 s0 = peg$c28;
                 peg$currPos++;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e30);
                 }
             }
             if (s0 === peg$FAILED) {
                 if (input.substr(peg$currPos, 2) === peg$c29) {
                     s0 = peg$c29;
                     peg$currPos += 2;
                 }
                 else {
                     s0 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e31);
                     }
                 }
                 if (s0 === peg$FAILED) {
                     if (input.substr(peg$currPos, 2) === peg$c30) {
                         s0 = peg$c30;
                         peg$currPos += 2;
                     }
                     else {
                         s0 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e32);
                         }
                     }
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsepower() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 32;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsechainFunctionCall();
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             s3 = peg$parsepowerOp();
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parsepower();
                 if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f20(s1, s3, s5);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$parsechainFunctionCall();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsepowerOp() {
         var s0, s1;
         var key = peg$currPos * 82 + 33;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 94) {
             s0 = peg$c31;
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e33);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.substr(peg$currPos, 2) === peg$c32) {
                 s0 = peg$c32;
                 peg$currPos += 2;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e34);
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e15);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsechainFunctionCall() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 34;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseunary();
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$parse_();
             if (input.substr(peg$currPos, 2) === peg$c33) {
                 s5 = peg$c33;
                 peg$currPos += 2;
             }
             else {
                 s5 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e35);
                 }
             }
             if (s5 !== peg$FAILED) {
                 s6 = peg$parse_nl();
                 s7 = peg$parsechainedFunction();
                 if (s7 !== peg$FAILED) {
                     s3 = s7;
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$parse_();
                 if (input.substr(peg$currPos, 2) === peg$c33) {
                     s5 = peg$c33;
                     peg$currPos += 2;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e35);
                     }
                 }
                 if (s5 !== peg$FAILED) {
                     s6 = peg$parse_nl();
                     s7 = peg$parsechainedFunction();
                     if (s7 !== peg$FAILED) {
                         s3 = s7;
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             peg$savedPos = s0;
             s0 = peg$f21(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsechainedFunction() {
         var s0, s1, s2, s3, s4, s5, s6;
         var key = peg$currPos * 82 + 35;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsecallableBasicValue();
         if (s1 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 40) {
                 s2 = peg$c6;
                 peg$currPos++;
             }
             else {
                 s2 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e6);
                 }
             }
             if (s2 !== peg$FAILED) {
                 s3 = peg$parse_nl();
                 s4 = peg$parsefunctionArguments();
                 s5 = peg$parse_nl();
                 if (input.charCodeAt(peg$currPos) === 41) {
                     s6 = peg$c7;
                     peg$currPos++;
                 }
                 else {
                     s6 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e7);
                     }
                 }
                 if (s6 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f22(s1, s4);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = peg$parsecallableBasicValue();
             if (s1 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s1 = peg$f23(s1);
             }
             s0 = s1;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsecallableBasicValue() {
         var s0;
         var key = peg$currPos * 82 + 36;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsestaticCollectionElement();
         if (s0 === peg$FAILED) {
             s0 = peg$parsevalueConstructor();
             if (s0 === peg$FAILED) {
                 s0 = peg$parsevariable();
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseunary() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 37;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseunaryOperator();
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             s3 = peg$parseunary();
             if (s3 === peg$FAILED) {
                 s3 = peg$parsepostOperator();
             }
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f24(s1, s3);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$parsepostOperator();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseunaryOperator() {
         var s0, s1;
         var key = peg$currPos * 82 + 38;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.charCodeAt(peg$currPos) === 45) {
             s0 = peg$c24;
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e26);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.substr(peg$currPos, 2) === peg$c26) {
                 s0 = peg$c26;
                 peg$currPos += 2;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e28);
                 }
             }
             if (s0 === peg$FAILED) {
                 if (input.charCodeAt(peg$currPos) === 33) {
                     s0 = peg$c34;
                     peg$currPos++;
                 }
                 else {
                     s0 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e37);
                     }
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e36);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsepostOperator() {
         var s0;
         var key = peg$currPos * 82 + 39;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsecollectionElement();
         if (s0 === peg$FAILED) {
             s0 = peg$parseatom();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsestaticCollectionElement() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
         var key = peg$currPos * 82 + 40;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseatom();
         if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 91) {
                 s3 = peg$c35;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e38);
                 }
             }
             if (s3 === peg$FAILED) {
                 if (input.charCodeAt(peg$currPos) === 46) {
                     s3 = peg$c36;
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e39);
                     }
                 }
             }
             peg$silentFails--;
             if (s3 !== peg$FAILED) {
                 peg$currPos = s2;
                 s2 = undefined;
             }
             else {
                 s2 = peg$FAILED;
             }
             if (s2 !== peg$FAILED) {
                 s3 = [];
                 s4 = peg$currPos;
                 s5 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 91) {
                     s6 = peg$c35;
                     peg$currPos++;
                 }
                 else {
                     s6 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e38);
                     }
                 }
                 if (s6 !== peg$FAILED) {
                     s7 = peg$parse_nl();
                     s8 = peg$parseexpression();
                     if (s8 !== peg$FAILED) {
                         s9 = peg$parse_nl();
                         if (input.charCodeAt(peg$currPos) === 93) {
                             s10 = peg$c37;
                             peg$currPos++;
                         }
                         else {
                             s10 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e40);
                             }
                         }
                         if (s10 !== peg$FAILED) {
                             peg$savedPos = s4;
                             s4 = peg$f25(s1, s8);
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s4;
                     s4 = peg$FAILED;
                 }
                 if (s4 === peg$FAILED) {
                     s4 = peg$currPos;
                     if (input.charCodeAt(peg$currPos) === 46) {
                         s5 = peg$c36;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e39);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         s6 = peg$currPos;
                         s7 = peg$parsedollarIdentifier();
                         if (s7 !== peg$FAILED) {
                             s6 = input.substring(s6, peg$currPos);
                         }
                         else {
                             s6 = s7;
                         }
                         if (s6 !== peg$FAILED) {
                             peg$savedPos = s4;
                             s4 = peg$f26(s1, s6);
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                 }
                 while (s4 !== peg$FAILED) {
                     s3.push(s4);
                     s4 = peg$currPos;
                     s5 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 91) {
                         s6 = peg$c35;
                         peg$currPos++;
                     }
                     else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e38);
                         }
                     }
                     if (s6 !== peg$FAILED) {
                         s7 = peg$parse_nl();
                         s8 = peg$parseexpression();
                         if (s8 !== peg$FAILED) {
                             s9 = peg$parse_nl();
                             if (input.charCodeAt(peg$currPos) === 93) {
                                 s10 = peg$c37;
                                 peg$currPos++;
                             }
                             else {
                                 s10 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e40);
                                 }
                             }
                             if (s10 !== peg$FAILED) {
                                 peg$savedPos = s4;
                                 s4 = peg$f25(s1, s8);
                             }
                             else {
                                 peg$currPos = s4;
                                 s4 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                     if (s4 === peg$FAILED) {
                         s4 = peg$currPos;
                         if (input.charCodeAt(peg$currPos) === 46) {
                             s5 = peg$c36;
                             peg$currPos++;
                         }
                         else {
                             s5 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e39);
                             }
                         }
                         if (s5 !== peg$FAILED) {
                             s6 = peg$currPos;
                             s7 = peg$parsedollarIdentifier();
                             if (s7 !== peg$FAILED) {
                                 s6 = input.substring(s6, peg$currPos);
                             }
                             else {
                                 s6 = s7;
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s4;
                                 s4 = peg$f26(s1, s6);
                             }
                             else {
                                 peg$currPos = s4;
                                 s4 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                 }
                 peg$savedPos = s0;
                 s0 = peg$f27(s1, s3);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsecollectionElement() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
         var key = peg$currPos * 82 + 41;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseatom();
         if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 91) {
                 s3 = peg$c35;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e38);
                 }
             }
             if (s3 === peg$FAILED) {
                 if (input.charCodeAt(peg$currPos) === 40) {
                     s3 = peg$c6;
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e6);
                     }
                 }
                 if (s3 === peg$FAILED) {
                     if (input.charCodeAt(peg$currPos) === 46) {
                         s3 = peg$c36;
                         peg$currPos++;
                     }
                     else {
                         s3 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e39);
                         }
                     }
                 }
             }
             peg$silentFails--;
             if (s3 !== peg$FAILED) {
                 peg$currPos = s2;
                 s2 = undefined;
             }
             else {
                 s2 = peg$FAILED;
             }
             if (s2 !== peg$FAILED) {
                 s3 = [];
                 s4 = peg$currPos;
                 s5 = peg$parse_();
                 if (input.charCodeAt(peg$currPos) === 40) {
                     s6 = peg$c6;
                     peg$currPos++;
                 }
                 else {
                     s6 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e6);
                     }
                 }
                 if (s6 !== peg$FAILED) {
                     s7 = peg$parse_nl();
                     s8 = peg$parsefunctionArguments();
                     s9 = peg$parse_nl();
                     if (input.charCodeAt(peg$currPos) === 41) {
                         s10 = peg$c7;
                         peg$currPos++;
                     }
                     else {
                         s10 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e7);
                         }
                     }
                     if (s10 !== peg$FAILED) {
                         peg$savedPos = s4;
                         s4 = peg$f28(s1, s8);
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s4;
                     s4 = peg$FAILED;
                 }
                 if (s4 === peg$FAILED) {
                     s4 = peg$currPos;
                     s5 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 91) {
                         s6 = peg$c35;
                         peg$currPos++;
                     }
                     else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e38);
                         }
                     }
                     if (s6 !== peg$FAILED) {
                         s7 = peg$parse_nl();
                         s8 = peg$parseexpression();
                         if (s8 !== peg$FAILED) {
                             s9 = peg$parse_nl();
                             if (input.charCodeAt(peg$currPos) === 93) {
                                 s10 = peg$c37;
                                 peg$currPos++;
                             }
                             else {
                                 s10 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e40);
                                 }
                             }
                             if (s10 !== peg$FAILED) {
                                 peg$savedPos = s4;
                                 s4 = peg$f29(s1, s8);
                             }
                             else {
                                 peg$currPos = s4;
                                 s4 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                     if (s4 === peg$FAILED) {
                         s4 = peg$currPos;
                         if (input.charCodeAt(peg$currPos) === 46) {
                             s5 = peg$c36;
                             peg$currPos++;
                         }
                         else {
                             s5 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e39);
                             }
                         }
                         if (s5 !== peg$FAILED) {
                             s6 = peg$currPos;
                             s7 = peg$parsedollarIdentifier();
                             if (s7 !== peg$FAILED) {
                                 s6 = input.substring(s6, peg$currPos);
                             }
                             else {
                                 s6 = s7;
                             }
                             if (s6 !== peg$FAILED) {
                                 peg$savedPos = s4;
                                 s4 = peg$f30(s1, s6);
                             }
                             else {
                                 peg$currPos = s4;
                                 s4 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                 }
                 while (s4 !== peg$FAILED) {
                     s3.push(s4);
                     s4 = peg$currPos;
                     s5 = peg$parse_();
                     if (input.charCodeAt(peg$currPos) === 40) {
                         s6 = peg$c6;
                         peg$currPos++;
                     }
                     else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e6);
                         }
                     }
                     if (s6 !== peg$FAILED) {
                         s7 = peg$parse_nl();
                         s8 = peg$parsefunctionArguments();
                         s9 = peg$parse_nl();
                         if (input.charCodeAt(peg$currPos) === 41) {
                             s10 = peg$c7;
                             peg$currPos++;
                         }
                         else {
                             s10 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e7);
                             }
                         }
                         if (s10 !== peg$FAILED) {
                             peg$savedPos = s4;
                             s4 = peg$f28(s1, s8);
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                     if (s4 === peg$FAILED) {
                         s4 = peg$currPos;
                         s5 = peg$parse_();
                         if (input.charCodeAt(peg$currPos) === 91) {
                             s6 = peg$c35;
                             peg$currPos++;
                         }
                         else {
                             s6 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e38);
                             }
                         }
                         if (s6 !== peg$FAILED) {
                             s7 = peg$parse_nl();
                             s8 = peg$parseexpression();
                             if (s8 !== peg$FAILED) {
                                 s9 = peg$parse_nl();
                                 if (input.charCodeAt(peg$currPos) === 93) {
                                     s10 = peg$c37;
                                     peg$currPos++;
                                 }
                                 else {
                                     s10 = peg$FAILED;
                                     if (peg$silentFails === 0) {
                                         peg$fail(peg$e40);
                                     }
                                 }
                                 if (s10 !== peg$FAILED) {
                                     peg$savedPos = s4;
                                     s4 = peg$f29(s1, s8);
                                 }
                                 else {
                                     peg$currPos = s4;
                                     s4 = peg$FAILED;
                                 }
                             }
                             else {
                                 peg$currPos = s4;
                                 s4 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                         if (s4 === peg$FAILED) {
                             s4 = peg$currPos;
                             if (input.charCodeAt(peg$currPos) === 46) {
                                 s5 = peg$c36;
                                 peg$currPos++;
                             }
                             else {
                                 s5 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e39);
                                 }
                             }
                             if (s5 !== peg$FAILED) {
                                 s6 = peg$currPos;
                                 s7 = peg$parsedollarIdentifier();
                                 if (s7 !== peg$FAILED) {
                                     s6 = input.substring(s6, peg$currPos);
                                 }
                                 else {
                                     s6 = s7;
                                 }
                                 if (s6 !== peg$FAILED) {
                                     peg$savedPos = s4;
                                     s4 = peg$f30(s1, s6);
                                 }
                                 else {
                                     peg$currPos = s4;
                                     s4 = peg$FAILED;
                                 }
                             }
                             else {
                                 peg$currPos = s4;
                                 s4 = peg$FAILED;
                             }
                         }
                     }
                 }
                 peg$savedPos = s0;
                 s0 = peg$f31(s1, s3);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefunctionArguments() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 42;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = [];
         s1 = peg$parseexpression();
         while (s1 !== peg$FAILED) {
             s0.push(s1);
             s1 = peg$currPos;
             s2 = peg$parsecommaSeparator();
             if (s2 !== peg$FAILED) {
                 s2 = peg$parseexpression();
                 if (s2 === peg$FAILED) {
                     peg$currPos = s1;
                     s1 = peg$FAILED;
                 }
                 else {
                     s1 = s2;
                 }
             }
             else {
                 s1 = s2;
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseatom() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 43;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 40) {
             s1 = peg$c6;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e6);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             s3 = peg$parseexpression();
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 if (input.charCodeAt(peg$currPos) === 41) {
                     s5 = peg$c7;
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e7);
                     }
                 }
                 if (s5 !== peg$FAILED) {
                     s0 = s3;
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$parsebasicValue();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsebasicValue() {
         var s0;
         var key = peg$currPos * 82 + 44;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsevalueConstructor();
         if (s0 === peg$FAILED) {
             s0 = peg$parsebasicLiteral();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsebasicLiteral() {
         var s0;
         var key = peg$currPos * 82 + 45;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsestring();
         if (s0 === peg$FAILED) {
             s0 = peg$parsenumber();
             if (s0 === peg$FAILED) {
                 s0 = peg$parseboolean();
                 if (s0 === peg$FAILED) {
                     s0 = peg$parsevariable();
                     if (s0 === peg$FAILED) {
                         s0 = peg$parsevoidLiteral();
                     }
                 }
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsevoidLiteral() {
         var s0, s1;
         var key = peg$currPos * 82 + 46;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.substr(peg$currPos, 2) === peg$c38) {
             s1 = peg$c38;
             peg$currPos += 2;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e42);
             }
         }
         if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
             s1 = peg$f32();
         }
         s0 = s1;
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e41);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsevariable() {
         var s0;
         var key = peg$currPos * 82 + 47;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsedollarIdentifierWithModule();
         if (s0 === peg$FAILED) {
             s0 = peg$parsedollarIdentifier();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsedollarIdentifierWithModule() {
         var s0, s1, s2, s3, s4, s5, s6, s7;
         var key = peg$currPos * 82 + 48;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$currPos;
         s2 = peg$parsemoduleIdentifier();
         if (s2 !== peg$FAILED) {
             s1 = input.substring(s1, peg$currPos);
         }
         else {
             s1 = s2;
         }
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 46) {
                 s4 = peg$c36;
                 peg$currPos++;
             }
             else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e39);
                 }
             }
             if (s4 !== peg$FAILED) {
                 s5 = peg$parse_nl();
                 s6 = peg$currPos;
                 s7 = peg$parsemoduleIdentifier();
                 if (s7 !== peg$FAILED) {
                     s6 = input.substring(s6, peg$currPos);
                 }
                 else {
                     s6 = s7;
                 }
                 if (s6 !== peg$FAILED) {
                     s3 = s6;
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 46) {
                     s4 = peg$c36;
                     peg$currPos++;
                 }
                 else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e39);
                     }
                 }
                 if (s4 !== peg$FAILED) {
                     s5 = peg$parse_nl();
                     s6 = peg$currPos;
                     s7 = peg$parsemoduleIdentifier();
                     if (s7 !== peg$FAILED) {
                         s6 = input.substring(s6, peg$currPos);
                     }
                     else {
                         s6 = s7;
                     }
                     if (s6 !== peg$FAILED) {
                         s3 = s6;
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             if (input.charCodeAt(peg$currPos) === 46) {
                 s3 = peg$c36;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e39);
                 }
             }
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$currPos;
                 s6 = peg$parsedollarIdentifier();
                 if (s6 !== peg$FAILED) {
                     s5 = input.substring(s5, peg$currPos);
                 }
                 else {
                     s5 = s6;
                 }
                 if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f33(s1, s2, s5);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e43);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsemoduleIdentifier() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 49;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = [];
         if (peg$r0.test(input.charAt(peg$currPos))) {
             s2 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e44);
             }
         }
         if (s2 !== peg$FAILED) {
             while (s2 !== peg$FAILED) {
                 s1.push(s2);
                 if (peg$r0.test(input.charAt(peg$currPos))) {
                     s2 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s2 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e44);
                     }
                 }
             }
         }
         else {
             s1 = peg$FAILED;
         }
         if (s1 !== peg$FAILED) {
             s2 = [];
             if (peg$r1.test(input.charAt(peg$currPos))) {
                 s3 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e45);
                 }
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 if (peg$r1.test(input.charAt(peg$currPos))) {
                     s3 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e45);
                     }
                 }
             }
             s1 = [s1, s2];
             s0 = s1;
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e43);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseidentifier() {
         var s0, s1, s2, s3, s4;
         var key = peg$currPos * 82 + 50;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$currPos;
         s2 = [];
         if (peg$r2.test(input.charAt(peg$currPos))) {
             s3 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s3 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e46);
             }
         }
         if (s3 !== peg$FAILED) {
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 if (peg$r2.test(input.charAt(peg$currPos))) {
                     s3 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e46);
                     }
                 }
             }
         }
         else {
             s2 = peg$FAILED;
         }
         if (s2 !== peg$FAILED) {
             s3 = [];
             if (peg$r1.test(input.charAt(peg$currPos))) {
                 s4 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e45);
                 }
             }
             while (s4 !== peg$FAILED) {
                 s3.push(s4);
                 if (peg$r1.test(input.charAt(peg$currPos))) {
                     s4 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e45);
                     }
                 }
             }
             s2 = [s2, s3];
             s1 = s2;
         }
         else {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
             s1 = peg$f34();
         }
         s0 = s1;
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e43);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseunitIdentifier() {
         var s0, s1;
         var key = peg$currPos * 82 + 51;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (input.substr(peg$currPos, 7) === peg$c39) {
             s0 = peg$c39;
             peg$currPos += 7;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e47);
             }
         }
         if (s0 === peg$FAILED) {
             if (input.substr(peg$currPos, 5) === peg$c40) {
                 s0 = peg$c40;
                 peg$currPos += 5;
             }
             else {
                 s0 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e48);
                 }
             }
             if (s0 === peg$FAILED) {
                 if (input.substr(peg$currPos, 4) === peg$c41) {
                     s0 = peg$c41;
                     peg$currPos += 4;
                 }
                 else {
                     s0 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e49);
                     }
                 }
                 if (s0 === peg$FAILED) {
                     if (input.substr(peg$currPos, 5) === peg$c42) {
                         s0 = peg$c42;
                         peg$currPos += 5;
                     }
                     else {
                         s0 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e50);
                         }
                     }
                     if (s0 === peg$FAILED) {
                         if (input.charCodeAt(peg$currPos) === 110) {
                             s0 = peg$c43;
                             peg$currPos++;
                         }
                         else {
                             s0 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e51);
                             }
                         }
                         if (s0 === peg$FAILED) {
                             if (input.charCodeAt(peg$currPos) === 109) {
                                 s0 = peg$c44;
                                 peg$currPos++;
                             }
                             else {
                                 s0 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e52);
                                 }
                             }
                             if (s0 === peg$FAILED) {
                                 if (input.charCodeAt(peg$currPos) === 107) {
                                     s0 = peg$c45;
                                     peg$currPos++;
                                 }
                                 else {
                                     s0 = peg$FAILED;
                                     if (peg$silentFails === 0) {
                                         peg$fail(peg$e53);
                                     }
                                 }
                                 if (s0 === peg$FAILED) {
                                     if (input.charCodeAt(peg$currPos) === 77) {
                                         s0 = peg$c46;
                                         peg$currPos++;
                                     }
                                     else {
                                         s0 = peg$FAILED;
                                         if (peg$silentFails === 0) {
                                             peg$fail(peg$e54);
                                         }
                                     }
                                     if (s0 === peg$FAILED) {
                                         if (input.charCodeAt(peg$currPos) === 66) {
                                             s0 = peg$c47;
                                             peg$currPos++;
                                         }
                                         else {
                                             s0 = peg$FAILED;
                                             if (peg$silentFails === 0) {
                                                 peg$fail(peg$e55);
                                             }
                                         }
                                         if (s0 === peg$FAILED) {
                                             if (input.charCodeAt(peg$currPos) === 71) {
                                                 s0 = peg$c48;
                                                 peg$currPos++;
                                             }
                                             else {
                                                 s0 = peg$FAILED;
                                                 if (peg$silentFails === 0) {
                                                     peg$fail(peg$e56);
                                                 }
                                             }
                                             if (s0 === peg$FAILED) {
                                                 if (input.charCodeAt(peg$currPos) === 84) {
                                                     s0 = peg$c49;
                                                     peg$currPos++;
                                                 }
                                                 else {
                                                     s0 = peg$FAILED;
                                                     if (peg$silentFails === 0) {
                                                         peg$fail(peg$e57);
                                                     }
                                                 }
                                                 if (s0 === peg$FAILED) {
                                                     if (input.charCodeAt(peg$currPos) === 80) {
                                                         s0 = peg$c50;
                                                         peg$currPos++;
                                                     }
                                                     else {
                                                         s0 = peg$FAILED;
                                                         if (peg$silentFails === 0) {
                                                             peg$fail(peg$e58);
                                                         }
                                                     }
                                                     if (s0 === peg$FAILED) {
                                                         if (input.charCodeAt(peg$currPos) === 37) {
                                                             s0 = peg$c51;
                                                             peg$currPos++;
                                                         }
                                                         else {
                                                             s0 = peg$FAILED;
                                                             if (peg$silentFails === 0) {
                                                                 peg$fail(peg$e59);
                                                             }
                                                         }
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e43);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsedollarIdentifier() {
         var s0, s1, s2, s3, s4;
         var key = peg$currPos * 82 + 52;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$currPos;
         s2 = [];
         if (peg$r3.test(input.charAt(peg$currPos))) {
             s3 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s3 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e60);
             }
         }
         if (s3 !== peg$FAILED) {
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 if (peg$r3.test(input.charAt(peg$currPos))) {
                     s3 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e60);
                     }
                 }
             }
         }
         else {
             s2 = peg$FAILED;
         }
         if (s2 !== peg$FAILED) {
             s3 = [];
             if (peg$r4.test(input.charAt(peg$currPos))) {
                 s4 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e61);
                 }
             }
             while (s4 !== peg$FAILED) {
                 s3.push(s4);
                 if (peg$r4.test(input.charAt(peg$currPos))) {
                     s4 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e61);
                     }
                 }
             }
             s2 = [s2, s3];
             s1 = s2;
         }
         else {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
             s1 = peg$f35();
         }
         s0 = s1;
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e43);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseescapeSeq() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8;
         var key = peg$currPos * 82 + 53;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 92) {
             s1 = peg$c52;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e63);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
             if (peg$r5.test(input.charAt(peg$currPos))) {
                 s3 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e64);
                 }
             }
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s2;
                 s3 = peg$f36(s3);
             }
             s2 = s3;
             if (s2 === peg$FAILED) {
                 s2 = peg$currPos;
                 s3 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 117) {
                     s4 = peg$c53;
                     peg$currPos++;
                 }
                 else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e65);
                     }
                 }
                 if (s4 !== peg$FAILED) {
                     if (input.length > peg$currPos) {
                         s5 = input.charAt(peg$currPos);
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e66);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         if (input.length > peg$currPos) {
                             s6 = input.charAt(peg$currPos);
                             peg$currPos++;
                         }
                         else {
                             s6 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e66);
                             }
                         }
                         if (s6 !== peg$FAILED) {
                             if (input.length > peg$currPos) {
                                 s7 = input.charAt(peg$currPos);
                                 peg$currPos++;
                             }
                             else {
                                 s7 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e66);
                                 }
                             }
                             if (s7 !== peg$FAILED) {
                                 if (input.length > peg$currPos) {
                                     s8 = input.charAt(peg$currPos);
                                     peg$currPos++;
                                 }
                                 else {
                                     s8 = peg$FAILED;
                                     if (peg$silentFails === 0) {
                                         peg$fail(peg$e66);
                                     }
                                 }
                                 if (s8 !== peg$FAILED) {
                                     s4 = [s4, s5, s6, s7, s8];
                                     s3 = s4;
                                 }
                                 else {
                                     peg$currPos = s3;
                                     s3 = peg$FAILED;
                                 }
                             }
                             else {
                                 peg$currPos = s3;
                                 s3 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s3;
                             s3 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
                 if (s3 !== peg$FAILED) {
                     peg$savedPos = s2;
                     s3 = peg$f37(s3);
                 }
                 s2 = s3;
             }
             if (s2 !== peg$FAILED) {
                 s0 = s2;
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e62);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsestring() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 54;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 39) {
             s1 = peg$c54;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e68);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = [];
             s3 = peg$currPos;
             s4 = peg$currPos;
             peg$silentFails++;
             if (input.charCodeAt(peg$currPos) === 39) {
                 s5 = peg$c54;
                 peg$currPos++;
             }
             else {
                 s5 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e68);
                 }
             }
             if (s5 === peg$FAILED) {
                 if (input.charCodeAt(peg$currPos) === 92) {
                     s5 = peg$c52;
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e63);
                     }
                 }
             }
             peg$silentFails--;
             if (s5 === peg$FAILED) {
                 s4 = undefined;
             }
             else {
                 peg$currPos = s4;
                 s4 = peg$FAILED;
             }
             if (s4 !== peg$FAILED) {
                 if (input.length > peg$currPos) {
                     s5 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e66);
                     }
                 }
                 if (s5 !== peg$FAILED) {
                     s3 = s5;
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s3;
                 s3 = peg$FAILED;
             }
             if (s3 === peg$FAILED) {
                 s3 = peg$parseescapeSeq();
             }
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$currPos;
                 s4 = peg$currPos;
                 peg$silentFails++;
                 if (input.charCodeAt(peg$currPos) === 39) {
                     s5 = peg$c54;
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e68);
                     }
                 }
                 if (s5 === peg$FAILED) {
                     if (input.charCodeAt(peg$currPos) === 92) {
                         s5 = peg$c52;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e63);
                         }
                     }
                 }
                 peg$silentFails--;
                 if (s5 === peg$FAILED) {
                     s4 = undefined;
                 }
                 else {
                     peg$currPos = s4;
                     s4 = peg$FAILED;
                 }
                 if (s4 !== peg$FAILED) {
                     if (input.length > peg$currPos) {
                         s5 = input.charAt(peg$currPos);
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e66);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         s3 = s5;
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
                 if (s3 === peg$FAILED) {
                     s3 = peg$parseescapeSeq();
                 }
             }
             if (input.charCodeAt(peg$currPos) === 39) {
                 s3 = peg$c54;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e68);
                 }
             }
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f38(s2);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 34) {
                 s1 = peg$c55;
                 peg$currPos++;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e69);
                 }
             }
             if (s1 !== peg$FAILED) {
                 s2 = [];
                 s3 = peg$currPos;
                 s4 = peg$currPos;
                 peg$silentFails++;
                 if (input.charCodeAt(peg$currPos) === 34) {
                     s5 = peg$c55;
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e69);
                     }
                 }
                 if (s5 === peg$FAILED) {
                     if (input.charCodeAt(peg$currPos) === 92) {
                         s5 = peg$c52;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e63);
                         }
                     }
                 }
                 peg$silentFails--;
                 if (s5 === peg$FAILED) {
                     s4 = undefined;
                 }
                 else {
                     peg$currPos = s4;
                     s4 = peg$FAILED;
                 }
                 if (s4 !== peg$FAILED) {
                     if (input.length > peg$currPos) {
                         s5 = input.charAt(peg$currPos);
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e66);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         s3 = s5;
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
                 if (s3 === peg$FAILED) {
                     s3 = peg$parseescapeSeq();
                 }
                 while (s3 !== peg$FAILED) {
                     s2.push(s3);
                     s3 = peg$currPos;
                     s4 = peg$currPos;
                     peg$silentFails++;
                     if (input.charCodeAt(peg$currPos) === 34) {
                         s5 = peg$c55;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e69);
                         }
                     }
                     if (s5 === peg$FAILED) {
                         if (input.charCodeAt(peg$currPos) === 92) {
                             s5 = peg$c52;
                             peg$currPos++;
                         }
                         else {
                             s5 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e63);
                             }
                         }
                     }
                     peg$silentFails--;
                     if (s5 === peg$FAILED) {
                         s4 = undefined;
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                     if (s4 !== peg$FAILED) {
                         if (input.length > peg$currPos) {
                             s5 = input.charAt(peg$currPos);
                             peg$currPos++;
                         }
                         else {
                             s5 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e66);
                             }
                         }
                         if (s5 !== peg$FAILED) {
                             s3 = s5;
                         }
                         else {
                             peg$currPos = s3;
                             s3 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s3;
                         s3 = peg$FAILED;
                     }
                     if (s3 === peg$FAILED) {
                         s3 = peg$parseescapeSeq();
                     }
                 }
                 if (input.charCodeAt(peg$currPos) === 34) {
                     s3 = peg$c55;
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e69);
                     }
                 }
                 if (s3 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f39(s2);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e67);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsenumber() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 55;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsefloat();
         if (s1 !== peg$FAILED) {
             s2 = peg$parseunitIdentifier();
             if (s2 === peg$FAILED) {
                 s2 = null;
             }
             peg$savedPos = s0;
             s0 = peg$f40(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefloat() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 56;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$parsefloatSignificand();
         if (s1 !== peg$FAILED) {
             s2 = peg$parsefloatExponent();
             if (s2 === peg$FAILED) {
                 s2 = null;
             }
             peg$savedPos = s0;
             s0 = peg$f41(s1, s2);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e70);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefloatSignificand() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 57;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseintLiteral();
         if (s1 !== peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 46) {
                 s2 = peg$c36;
                 peg$currPos++;
             }
             else {
                 s2 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e39);
                 }
             }
             if (s2 !== peg$FAILED) {
                 s3 = peg$currPos;
                 s4 = [];
                 s5 = peg$parsed();
                 if (s5 !== peg$FAILED) {
                     while (s5 !== peg$FAILED) {
                         s4.push(s5);
                         s5 = peg$parsed();
                     }
                 }
                 else {
                     s4 = peg$FAILED;
                 }
                 if (s4 !== peg$FAILED) {
                     s3 = input.substring(s3, peg$currPos);
                 }
                 else {
                     s3 = s4;
                 }
                 if (s3 === peg$FAILED) {
                     s3 = null;
                 }
                 peg$savedPos = s0;
                 s0 = peg$f42(s1, s3);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             s1 = peg$parseintLiteral();
             if (s1 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s1 = peg$f43(s1);
             }
             s0 = s1;
             if (s0 === peg$FAILED) {
                 s0 = peg$currPos;
                 if (input.charCodeAt(peg$currPos) === 46) {
                     s1 = peg$c36;
                     peg$currPos++;
                 }
                 else {
                     s1 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e39);
                     }
                 }
                 if (s1 !== peg$FAILED) {
                     s2 = peg$currPos;
                     s3 = [];
                     s4 = peg$parsed();
                     if (s4 !== peg$FAILED) {
                         while (s4 !== peg$FAILED) {
                             s3.push(s4);
                             s4 = peg$parsed();
                         }
                     }
                     else {
                         s3 = peg$FAILED;
                     }
                     if (s3 !== peg$FAILED) {
                         s2 = input.substring(s2, peg$currPos);
                     }
                     else {
                         s2 = s3;
                     }
                     if (s2 !== peg$FAILED) {
                         peg$savedPos = s0;
                         s0 = peg$f44(s2);
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefloatExponent() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 58;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (peg$r6.test(input.charAt(peg$currPos))) {
             s1 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e71);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parsesignedIntLiteral();
             if (s2 !== peg$FAILED) {
                 s0 = s2;
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseintLiteral() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 59;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = [];
         s2 = peg$parsed();
         if (s2 !== peg$FAILED) {
             while (s2 !== peg$FAILED) {
                 s1.push(s2);
                 s2 = peg$parsed();
             }
         }
         else {
             s1 = peg$FAILED;
         }
         if (s1 !== peg$FAILED) {
             peg$savedPos = s0;
             s1 = peg$f45();
         }
         s0 = s1;
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsesignedIntLiteral() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 60;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 45) {
             s1 = peg$c24;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e26);
             }
         }
         if (s1 === peg$FAILED) {
             if (input.charCodeAt(peg$currPos) === 43) {
                 s1 = peg$c23;
                 peg$currPos++;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e25);
                 }
             }
         }
         if (s1 === peg$FAILED) {
             s1 = null;
         }
         s2 = [];
         s3 = peg$parsed();
         if (s3 !== peg$FAILED) {
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 s3 = peg$parsed();
             }
         }
         else {
             s2 = peg$FAILED;
         }
         if (s2 !== peg$FAILED) {
             peg$savedPos = s0;
             s0 = peg$f46();
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsed() {
         var s0;
         var key = peg$currPos * 82 + 61;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         if (peg$r7.test(input.charAt(peg$currPos))) {
             s0 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e72);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parseboolean() {
         var s0, s1, s2, s3, s4;
         var key = peg$currPos * 82 + 62;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.substr(peg$currPos, 4) === peg$c56) {
             s1 = peg$c56;
             peg$currPos += 4;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e74);
             }
         }
         if (s1 === peg$FAILED) {
             if (input.substr(peg$currPos, 5) === peg$c57) {
                 s1 = peg$c57;
                 peg$currPos += 5;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e75);
                 }
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
             peg$silentFails++;
             if (peg$r8.test(input.charAt(peg$currPos))) {
                 s3 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e76);
                 }
             }
             peg$silentFails--;
             if (s3 === peg$FAILED) {
                 s2 = undefined;
             }
             else {
                 peg$currPos = s2;
                 s2 = peg$FAILED;
             }
             if (s2 !== peg$FAILED) {
                 s3 = peg$currPos;
                 peg$silentFails++;
                 if (peg$r9.test(input.charAt(peg$currPos))) {
                     s4 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e77);
                     }
                 }
                 peg$silentFails--;
                 if (s4 === peg$FAILED) {
                     s3 = undefined;
                 }
                 else {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
                 if (s3 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f47();
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e73);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsevalueConstructor() {
         var s0;
         var key = peg$currPos * 82 + 63;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsearrayConstructor();
         if (s0 === peg$FAILED) {
             s0 = peg$parselambda();
             if (s0 === peg$FAILED) {
                 s0 = peg$parsequotedInnerBlock();
                 if (s0 === peg$FAILED) {
                     s0 = peg$parsedictConstructor();
                 }
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parselambda() {
         var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
         var key = peg$currPos * 82 + 64;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 123) {
             s1 = peg$c2;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e2);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             if (input.charCodeAt(peg$currPos) === 124) {
                 s3 = peg$c58;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e78);
                 }
             }
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parsefunctionParameters();
                 s6 = peg$parse_nl();
                 if (input.charCodeAt(peg$currPos) === 124) {
                     s7 = peg$c58;
                     peg$currPos++;
                 }
                 else {
                     s7 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e78);
                     }
                 }
                 if (s7 !== peg$FAILED) {
                     s8 = peg$parse_nl();
                     s9 = peg$parsestatementsList();
                     if (s9 !== peg$FAILED) {
                         s10 = peg$currPos;
                         s11 = peg$parsestatementSeparator();
                         if (s11 !== peg$FAILED) {
                             s12 = peg$parseexpression();
                             if (s12 !== peg$FAILED) {
                                 s10 = s12;
                             }
                             else {
                                 peg$currPos = s10;
                                 s10 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s10;
                             s10 = peg$FAILED;
                         }
                         if (s10 !== peg$FAILED) {
                             s11 = peg$parse_nl();
                             if (input.charCodeAt(peg$currPos) === 125) {
                                 s12 = peg$c3;
                                 peg$currPos++;
                             }
                             else {
                                 s12 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e3);
                                 }
                             }
                             if (s12 !== peg$FAILED) {
                                 peg$savedPos = s0;
                                 s0 = peg$f48(s5, s9, s10);
                             }
                             else {
                                 peg$currPos = s0;
                                 s0 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 123) {
                 s1 = peg$c2;
                 peg$currPos++;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e2);
                 }
             }
             if (s1 !== peg$FAILED) {
                 s2 = peg$parse_nl();
                 if (input.charCodeAt(peg$currPos) === 124) {
                     s3 = peg$c58;
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e78);
                     }
                 }
                 if (s3 !== peg$FAILED) {
                     s4 = peg$parse_nl();
                     s5 = peg$parsefunctionParameters();
                     s6 = peg$parse_nl();
                     if (input.charCodeAt(peg$currPos) === 124) {
                         s7 = peg$c58;
                         peg$currPos++;
                     }
                     else {
                         s7 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e78);
                         }
                     }
                     if (s7 !== peg$FAILED) {
                         s8 = peg$parse_nl();
                         s9 = peg$parseexpression();
                         if (s9 !== peg$FAILED) {
                             s10 = peg$parse_nl();
                             if (input.charCodeAt(peg$currPos) === 125) {
                                 s11 = peg$c3;
                                 peg$currPos++;
                             }
                             else {
                                 s11 = peg$FAILED;
                                 if (peg$silentFails === 0) {
                                     peg$fail(peg$e3);
                                 }
                             }
                             if (s11 !== peg$FAILED) {
                                 peg$savedPos = s0;
                                 s0 = peg$f49(s5, s9);
                             }
                             else {
                                 peg$currPos = s0;
                                 s0 = peg$FAILED;
                             }
                         }
                         else {
                             peg$currPos = s0;
                             s0 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsearrayConstructor() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 65;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 91) {
             s1 = peg$c35;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e38);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             if (input.charCodeAt(peg$currPos) === 93) {
                 s3 = peg$c37;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e40);
                 }
             }
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f50();
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 91) {
                 s1 = peg$c35;
                 peg$currPos++;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e38);
                 }
             }
             if (s1 !== peg$FAILED) {
                 s2 = peg$parse_nl();
                 s3 = peg$parsearray_elements();
                 if (s3 !== peg$FAILED) {
                     s4 = peg$parse_nl();
                     if (input.charCodeAt(peg$currPos) === 93) {
                         s5 = peg$c37;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e40);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         peg$savedPos = s0;
                         s0 = peg$f51(s3);
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e79);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsearray_elements() {
         var s0, s1, s2, s3, s4;
         var key = peg$currPos * 82 + 66;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$currPos;
         s2 = [];
         s3 = peg$parseexpression();
         while (s3 !== peg$FAILED) {
             s2.push(s3);
             s3 = peg$currPos;
             s4 = peg$parsecommaSeparator();
             if (s4 !== peg$FAILED) {
                 s4 = peg$parseexpression();
                 if (s4 === peg$FAILED) {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
                 else {
                     s3 = s4;
                 }
             }
             else {
                 s3 = s4;
             }
         }
         if (s2.length < 1) {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         else {
             s1 = s2;
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parsecommaSeparator();
             if (s2 === peg$FAILED) {
                 s2 = null;
             }
             s0 = s1;
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsedictConstructor() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 67;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.charCodeAt(peg$currPos) === 123) {
             s1 = peg$c2;
             peg$currPos++;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e2);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_nl();
             if (input.charCodeAt(peg$currPos) === 125) {
                 s3 = peg$c3;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e3);
                 }
             }
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f52();
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         if (s0 === peg$FAILED) {
             s0 = peg$currPos;
             if (input.charCodeAt(peg$currPos) === 123) {
                 s1 = peg$c2;
                 peg$currPos++;
             }
             else {
                 s1 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e2);
                 }
             }
             if (s1 !== peg$FAILED) {
                 s2 = peg$parse_nl();
                 s3 = peg$parsearray_dictEntries();
                 if (s3 !== peg$FAILED) {
                     s4 = peg$parse_nl();
                     if (input.charCodeAt(peg$currPos) === 125) {
                         s5 = peg$c3;
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e3);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         peg$savedPos = s0;
                         s0 = peg$f53(s3);
                     }
                     else {
                         peg$currPos = s0;
                         s0 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e80);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsearray_dictEntries() {
         var s0, s1, s2, s3, s4;
         var key = peg$currPos * 82 + 68;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$currPos;
         s2 = [];
         s3 = peg$parsekeyValuePair();
         if (s3 === peg$FAILED) {
             s3 = peg$parseidentifier();
         }
         while (s3 !== peg$FAILED) {
             s2.push(s3);
             s3 = peg$currPos;
             s4 = peg$parsecommaSeparator();
             if (s4 !== peg$FAILED) {
                 s4 = peg$parsekeyValuePair();
                 if (s4 === peg$FAILED) {
                     s4 = peg$parseidentifier();
                 }
                 if (s4 === peg$FAILED) {
                     peg$currPos = s3;
                     s3 = peg$FAILED;
                 }
                 else {
                     s3 = s4;
                 }
             }
             else {
                 s3 = s4;
             }
         }
         if (s2.length < 1) {
             peg$currPos = s1;
             s1 = peg$FAILED;
         }
         else {
             s1 = s2;
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$parsecommaSeparator();
             if (s2 === peg$FAILED) {
                 s2 = null;
             }
             s0 = s1;
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsekeyValuePair() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 69;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parseexpression();
         if (s1 !== peg$FAILED) {
             s2 = peg$parse_();
             if (input.charCodeAt(peg$currPos) === 58) {
                 s3 = peg$c9;
                 peg$currPos++;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e10);
                 }
             }
             if (s3 !== peg$FAILED) {
                 s4 = peg$parse_nl();
                 s5 = peg$parseexpression();
                 if (s5 !== peg$FAILED) {
                     peg$savedPos = s0;
                     s0 = peg$f54(s1, s5);
                 }
                 else {
                     peg$currPos = s0;
                     s0 = peg$FAILED;
                 }
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parse_() {
         var s0, s1;
         var key = peg$currPos * 82 + 70;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = [];
         s1 = peg$parsewhiteSpaceCharactersOrComment();
         while (s1 !== peg$FAILED) {
             s0.push(s1);
             s1 = peg$parsewhiteSpaceCharactersOrComment();
         }
         peg$silentFails--;
         s1 = peg$FAILED;
         if (peg$silentFails === 0) {
             peg$fail(peg$e81);
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parse_nl() {
         var s0, s1;
         var key = peg$currPos * 82 + 71;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = [];
         s1 = peg$parsewhiteSpaceCharactersOrComment();
         if (s1 === peg$FAILED) {
             s1 = peg$parsecommentOrNewLine();
         }
         while (s1 !== peg$FAILED) {
             s0.push(s1);
             s1 = peg$parsewhiteSpaceCharactersOrComment();
             if (s1 === peg$FAILED) {
                 s1 = peg$parsecommentOrNewLine();
             }
         }
         peg$silentFails--;
         s1 = peg$FAILED;
         if (peg$silentFails === 0) {
             peg$fail(peg$e81);
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parse__() {
         var s0, s1;
         var key = peg$currPos * 82 + 72;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = [];
         s1 = peg$parsewhiteSpaceCharactersOrComment();
         if (s1 !== peg$FAILED) {
             while (s1 !== peg$FAILED) {
                 s0.push(s1);
                 s1 = peg$parsewhiteSpaceCharactersOrComment();
             }
         }
         else {
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e81);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parse__nl() {
         var s0, s1;
         var key = peg$currPos * 82 + 73;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = [];
         s1 = peg$parsewhiteSpaceCharactersOrComment();
         if (s1 === peg$FAILED) {
             s1 = peg$parsecommentOrNewLine();
         }
         if (s1 !== peg$FAILED) {
             while (s1 !== peg$FAILED) {
                 s0.push(s1);
                 s1 = peg$parsewhiteSpaceCharactersOrComment();
                 if (s1 === peg$FAILED) {
                     s1 = peg$parsecommentOrNewLine();
                 }
             }
         }
         else {
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e81);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsestatementSeparator() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 74;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$parse_();
         s2 = [];
         if (input.charCodeAt(peg$currPos) === 59) {
             s3 = peg$c59;
             peg$currPos++;
         }
         else {
             s3 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e83);
             }
         }
         if (s3 === peg$FAILED) {
             s3 = peg$parsecommentOrNewLine();
         }
         if (s3 !== peg$FAILED) {
             while (s3 !== peg$FAILED) {
                 s2.push(s3);
                 if (input.charCodeAt(peg$currPos) === 59) {
                     s3 = peg$c59;
                     peg$currPos++;
                 }
                 else {
                     s3 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e83);
                     }
                 }
                 if (s3 === peg$FAILED) {
                     s3 = peg$parsecommentOrNewLine();
                 }
             }
         }
         else {
             s2 = peg$FAILED;
         }
         if (s2 !== peg$FAILED) {
             s3 = peg$parse_nl();
             s1 = [s1, s2, s3];
             s0 = s1;
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e82);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsecommaSeparator() {
         var s0, s1, s2, s3;
         var key = peg$currPos * 82 + 75;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$parse_();
         if (input.charCodeAt(peg$currPos) === 44) {
             s2 = peg$c60;
             peg$currPos++;
         }
         else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e85);
             }
         }
         if (s2 !== peg$FAILED) {
             s3 = peg$parse_nl();
             s1 = [s1, s2, s3];
             s0 = s1;
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e84);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsecommentOrNewLine() {
         var s0, s1, s2;
         var key = peg$currPos * 82 + 76;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$currPos;
         s1 = peg$parsefinalComment();
         if (s1 === peg$FAILED) {
             s1 = null;
         }
         s2 = peg$parsenewLine();
         if (s2 !== peg$FAILED) {
             s1 = [s1, s2];
             s0 = s1;
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsenewLine() {
         var s0, s1;
         var key = peg$currPos * 82 + 77;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         if (peg$r10.test(input.charAt(peg$currPos))) {
             s0 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e87);
             }
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e86);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsefinalComment() {
         var s0, s1, s2, s3, s4, s5;
         var key = peg$currPos * 82 + 78;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         s1 = peg$parse_();
         if (input.substr(peg$currPos, 2) === peg$c61) {
             s2 = peg$c61;
             peg$currPos += 2;
         }
         else {
             s2 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e89);
             }
         }
         if (s2 !== peg$FAILED) {
             s3 = peg$currPos;
             s4 = [];
             if (peg$r11.test(input.charAt(peg$currPos))) {
                 s5 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s5 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e90);
                 }
             }
             while (s5 !== peg$FAILED) {
                 s4.push(s5);
                 if (peg$r11.test(input.charAt(peg$currPos))) {
                     s5 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e90);
                     }
                 }
             }
             s3 = input.substring(s3, peg$currPos);
             peg$savedPos = s0;
             s0 = peg$f55(s3);
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e88);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsewhiteSpaceCharactersOrComment() {
         var s0;
         var key = peg$currPos * 82 + 79;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         s0 = peg$parsewhiteSpaceCharacters();
         if (s0 === peg$FAILED) {
             s0 = peg$parsedelimitedComment();
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsedelimitedComment() {
         var s0, s1, s2, s3, s4, s5, s6;
         var key = peg$currPos * 82 + 80;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         peg$silentFails++;
         s0 = peg$currPos;
         if (input.substr(peg$currPos, 2) === peg$c62) {
             s1 = peg$c62;
             peg$currPos += 2;
         }
         else {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e92);
             }
         }
         if (s1 !== peg$FAILED) {
             s2 = peg$currPos;
             s3 = [];
             if (peg$r12.test(input.charAt(peg$currPos))) {
                 s4 = input.charAt(peg$currPos);
                 peg$currPos++;
             }
             else {
                 s4 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e93);
                 }
             }
             if (s4 === peg$FAILED) {
                 s4 = peg$currPos;
                 if (peg$r13.test(input.charAt(peg$currPos))) {
                     s5 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s5 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e94);
                     }
                 }
                 if (s5 !== peg$FAILED) {
                     if (peg$r14.test(input.charAt(peg$currPos))) {
                         s6 = input.charAt(peg$currPos);
                         peg$currPos++;
                     }
                     else {
                         s6 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e95);
                         }
                     }
                     if (s6 !== peg$FAILED) {
                         s5 = [s5, s6];
                         s4 = s5;
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                 }
                 else {
                     peg$currPos = s4;
                     s4 = peg$FAILED;
                 }
             }
             while (s4 !== peg$FAILED) {
                 s3.push(s4);
                 if (peg$r12.test(input.charAt(peg$currPos))) {
                     s4 = input.charAt(peg$currPos);
                     peg$currPos++;
                 }
                 else {
                     s4 = peg$FAILED;
                     if (peg$silentFails === 0) {
                         peg$fail(peg$e93);
                     }
                 }
                 if (s4 === peg$FAILED) {
                     s4 = peg$currPos;
                     if (peg$r13.test(input.charAt(peg$currPos))) {
                         s5 = input.charAt(peg$currPos);
                         peg$currPos++;
                     }
                     else {
                         s5 = peg$FAILED;
                         if (peg$silentFails === 0) {
                             peg$fail(peg$e94);
                         }
                     }
                     if (s5 !== peg$FAILED) {
                         if (peg$r14.test(input.charAt(peg$currPos))) {
                             s6 = input.charAt(peg$currPos);
                             peg$currPos++;
                         }
                         else {
                             s6 = peg$FAILED;
                             if (peg$silentFails === 0) {
                                 peg$fail(peg$e95);
                             }
                         }
                         if (s6 !== peg$FAILED) {
                             s5 = [s5, s6];
                             s4 = s5;
                         }
                         else {
                             peg$currPos = s4;
                             s4 = peg$FAILED;
                         }
                     }
                     else {
                         peg$currPos = s4;
                         s4 = peg$FAILED;
                     }
                 }
             }
             s2 = input.substring(s2, peg$currPos);
             if (input.substr(peg$currPos, 2) === peg$c63) {
                 s3 = peg$c63;
                 peg$currPos += 2;
             }
             else {
                 s3 = peg$FAILED;
                 if (peg$silentFails === 0) {
                     peg$fail(peg$e96);
                 }
             }
             if (s3 !== peg$FAILED) {
                 peg$savedPos = s0;
                 s0 = peg$f56(s2);
             }
             else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
             }
         }
         else {
             peg$currPos = s0;
             s0 = peg$FAILED;
         }
         peg$silentFails--;
         if (s0 === peg$FAILED) {
             s1 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e91);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     function peg$parsewhiteSpaceCharacters() {
         var s0;
         var key = peg$currPos * 82 + 81;
         var cached = peg$resultsCache[key];
         if (cached) {
             peg$currPos = cached.nextPos;
             return cached.result;
         }
         if (peg$r15.test(input.charAt(peg$currPos))) {
             s0 = input.charAt(peg$currPos);
             peg$currPos++;
         }
         else {
             s0 = peg$FAILED;
             if (peg$silentFails === 0) {
                 peg$fail(peg$e97);
             }
         }
         peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
         return s0;
     }
     peg$result = peg$startRuleFunction();
     if (peg$result !== peg$FAILED && peg$currPos === input.length) {
         return peg$result;
     }
     else {
         if (peg$result !== peg$FAILED && peg$currPos < input.length) {
             peg$fail(peg$endExpectation());
         }
         throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length
             ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
             : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
     }
 }
 export { peg$SyntaxError as SyntaxError, peg$parse as parse };
 //# sourceMappingURL=peggyParser.js.map