ember-legacy-class-transform/.node_modules.ember-try/@glimmer/compiler/dist/commonjs/es5/lib/template-compiler.js

The default blueprint for ember-cli addons.

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _templateVisitor = require("./template-visitor");

var _templateVisitor2 = _interopRequireDefault(_templateVisitor);

var _javascriptCompiler = require("./javascript-compiler");

var _javascriptCompiler2 = _interopRequireDefault(_javascriptCompiler);

var _util = require("@glimmer/util");

var _syntax = require("@glimmer/syntax");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _createClass = function () {
    function defineProperties(target, props) {
        for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
        }
    }return function (Constructor, protoProps, staticProps) {
        if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
    };
}();

function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}

function isTrustedValue(value) {
    return value.escaped !== undefined && !value.escaped;
}

var TemplateCompiler = function () {
    function TemplateCompiler(options) {
        _classCallCheck(this, TemplateCompiler);

        this.templateId = 0;
        this.templateIds = [];
        this.symbolStack = new _util.Stack();
        this.opcodes = [];
        this.includeMeta = false;
        this.options = options || {};
    }

    TemplateCompiler.compile = function compile(options, ast) {
        var templateVisitor = new _templateVisitor2.default();
        templateVisitor.visit(ast);
        var compiler = new TemplateCompiler(options);
        var opcodes = compiler.process(templateVisitor.actions);
        return _javascriptCompiler2.default.process(opcodes, ast['symbols'], options.meta);
    };

    TemplateCompiler.prototype.process = function process(actions) {
        var _this = this;

        actions.forEach(function (_ref) {
            var name = _ref[0],
                args = _ref.slice(1);

            if (!_this[name]) {
                throw new Error("Unimplemented " + name + " on TemplateCompiler");
            }
            _this[name].apply(_this, args);
        });
        return this.opcodes;
    };

    TemplateCompiler.prototype.startProgram = function startProgram(program) {
        this.symbolStack.push(program[0]['symbols']);
        this.opcode('startProgram', program, program);
    };

    TemplateCompiler.prototype.endProgram = function endProgram() {
        this.symbolStack.pop();
        this.opcode('endProgram', null);
    };

    TemplateCompiler.prototype.startBlock = function startBlock(program) {
        this.symbolStack.push(program[0]['symbols']);
        this.templateId++;
        this.opcode('startBlock', program, program);
    };

    TemplateCompiler.prototype.endBlock = function endBlock() {
        this.symbolStack.pop();
        this.templateIds.push(this.templateId - 1);
        this.opcode('endBlock', null);
    };

    TemplateCompiler.prototype.text = function text(_ref2) {
        var action = _ref2[0];

        this.opcode('text', action, action.chars);
    };

    TemplateCompiler.prototype.comment = function comment(_ref3) {
        var action = _ref3[0];

        this.opcode('comment', action, action.value);
    };

    TemplateCompiler.prototype.openElement = function openElement(_ref4) {
        var action = _ref4[0];

        this.opcode('openElement', action, action);
        for (var i = 0; i < action.attributes.length; i++) {
            this.attribute([action.attributes[i]]);
        }
        for (var _i = 0; _i < action.modifiers.length; _i++) {
            this.modifier([action.modifiers[_i]]);
        }
        this.opcode('flushElement', null);
        this.symbolStack.push(action['symbols']);
    };

    TemplateCompiler.prototype.closeElement = function closeElement(_ref5) {
        var action = _ref5[0];

        this.symbolStack.pop();
        this.opcode('closeElement', null, action);
    };

    TemplateCompiler.prototype.attribute = function attribute(_ref6) {
        var action = _ref6[0];
        var name = action.name,
            value = action.value;

        var namespace = (0, _util.getAttrNamespace)(name);
        var isStatic = this.prepareAttributeValue(value);
        if (name.charAt(0) === '@') {
            // Arguments
            if (isStatic) {
                this.opcode('staticArg', action, name);
            } else if (action.value.type === 'MustacheStatement') {
                this.opcode('dynamicArg', action, name);
            } else {
                this.opcode('dynamicArg', action, name);
            }
        } else {
            var isTrusting = isTrustedValue(value);
            if (isStatic) {
                this.opcode('staticAttr', action, name, namespace);
            } else if (isTrusting) {
                this.opcode('trustingAttr', action, name, namespace);
            } else if (action.value.type === 'MustacheStatement') {
                this.opcode('dynamicAttr', action, name);
            } else {
                this.opcode('dynamicAttr', action, name, namespace);
            }
        }
    };

    TemplateCompiler.prototype.modifier = function modifier(_ref7) {
        var action = _ref7[0];

        assertIsSimplePath(action.path, action.loc, 'modifier');
        var parts = action.path.parts;

        this.prepareHelper(action);
        this.opcode('modifier', action, parts[0]);
    };

    TemplateCompiler.prototype.mustache = function mustache(_ref8) {
        var action = _ref8[0];
        var path = action.path;

        if ((0, _syntax.isLiteral)(path)) {
            this.mustacheExpression(action);
            this.opcode('append', action, !action.escaped);
        } else if (isYield(path)) {
            var to = assertValidYield(action);
            this.yield(to, action);
        } else if (isPartial(path)) {
            var params = assertValidPartial(action);
            this.partial(params, action);
        } else if (isDebugger(path)) {
            assertValidDebuggerUsage(action);
            this.debugger('debugger', action);
        } else {
            this.mustacheExpression(action);
            this.opcode('append', action, !action.escaped);
        }
    };

    TemplateCompiler.prototype.block = function block(_ref9) {
        var action /*, index, count*/ = _ref9[0];

        this.prepareHelper(action);
        var templateId = this.templateIds.pop();
        var inverseId = action.inverse === null ? null : this.templateIds.pop();
        this.opcode('block', action, action.path.parts[0], templateId, inverseId);
    };
    /// Internal actions, not found in the original processed actions


    TemplateCompiler.prototype.arg = function arg(_ref10) {
        var path = _ref10[0];

        var _path$parts = path.parts,
            head = _path$parts[0],
            rest = _path$parts.slice(1);

        var symbol = this.symbols.allocateNamed(head);
        this.opcode('get', path, symbol, rest);
    };

    TemplateCompiler.prototype.mustacheExpression = function mustacheExpression(expr) {
        var path = expr.path;

        if ((0, _syntax.isLiteral)(path)) {
            this.opcode('literal', expr, path.value);
        } else if (isBuiltInHelper(path)) {
            this.builtInHelper(expr);
        } else if (isArg(path)) {
            this.arg([path]);
        } else if (isHelperInvocation(expr)) {
            this.prepareHelper(expr);
            this.opcode('helper', expr, path.parts[0]);
        } else if (path.this) {
            this.opcode('get', expr, 0, path.parts);
        } else if (isLocal(path, this.symbols)) {
            var _path$parts2 = path.parts,
                head = _path$parts2[0],
                parts = _path$parts2.slice(1);

            this.opcode('get', expr, this.symbols.get(head), parts);
        } else if (isSimplePath(path)) {
            this.opcode('unknown', expr, path.parts[0]);
        } else {
            this.opcode('maybeLocal', expr, path.parts);
        }
    };
    /// Internal Syntax


    TemplateCompiler.prototype.yield = function _yield(to, action) {
        this.prepareParams(action.params);
        this.opcode('yield', action, this.symbols.allocateBlock(to));
    };

    TemplateCompiler.prototype.debugger = function _debugger(_name, action) {
        this.opcode('debugger', action, this.symbols.getEvalInfo());
    };

    TemplateCompiler.prototype.hasBlock = function hasBlock(name, action) {
        this.opcode('hasBlock', action, this.symbols.allocateBlock(name));
    };

    TemplateCompiler.prototype.hasBlockParams = function hasBlockParams(name, action) {
        this.opcode('hasBlockParams', action, this.symbols.allocateBlock(name));
    };

    TemplateCompiler.prototype.partial = function partial(_params, action) {
        this.prepareParams(action.params);
        this.opcode('partial', action, this.symbols.getEvalInfo());
    };

    TemplateCompiler.prototype.builtInHelper = function builtInHelper(expr) {
        var path = expr.path;

        if (isHasBlock(path)) {
            var name = assertValidHasBlockUsage(expr.path.original, expr);
            this.hasBlock(name, expr);
        } else if (isHasBlockParams(path)) {
            var _name2 = assertValidHasBlockUsage(expr.path.original, expr);
            this.hasBlockParams(_name2, expr);
        }
    };
    /// Expressions, invoked recursively from prepareParams and prepareHash


    TemplateCompiler.prototype.SubExpression = function SubExpression(expr) {
        if (isBuiltInHelper(expr.path)) {
            this.builtInHelper(expr);
        } else {
            this.prepareHelper(expr);
            this.opcode('helper', expr, expr.path.parts[0]);
        }
    };

    TemplateCompiler.prototype.PathExpression = function PathExpression(expr) {
        if (expr.data) {
            this.arg([expr]);
        } else {
            var symbols = this.symbols;
            var _expr$parts = expr.parts,
                head = _expr$parts[0];

            if (expr.this) {
                this.opcode('get', expr, 0, expr.parts);
            } else if (symbols.has(head)) {
                this.opcode('get', expr, symbols.get(head), expr.parts.slice(1));
            } else {
                this.opcode('get', expr, 0, expr.parts);
            }
        }
    };

    TemplateCompiler.prototype.StringLiteral = function StringLiteral(action) {
        this.opcode('literal', null, action.value);
    };

    TemplateCompiler.prototype.BooleanLiteral = function BooleanLiteral(action) {
        this.opcode('literal', null, action.value);
    };

    TemplateCompiler.prototype.NumberLiteral = function NumberLiteral(action) {
        this.opcode('literal', null, action.value);
    };

    TemplateCompiler.prototype.NullLiteral = function NullLiteral(action) {
        this.opcode('literal', null, action.value);
    };

    TemplateCompiler.prototype.UndefinedLiteral = function UndefinedLiteral(action) {
        this.opcode('literal', null, action.value);
    };
    /// Utilities


    TemplateCompiler.prototype.opcode = function opcode(name, action) {
        for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
        }

        var opcode = [name].concat(args);
        if (this.includeMeta && action) {
            opcode.push(this.meta(action));
        }
        this.opcodes.push(opcode);
    };

    TemplateCompiler.prototype.prepareHelper = function prepareHelper(expr) {
        assertIsSimplePath(expr.path, expr.loc, 'helper');
        var params = expr.params,
            hash = expr.hash;

        this.prepareHash(hash);
        this.prepareParams(params);
    };

    TemplateCompiler.prototype.prepareParams = function prepareParams(params) {
        if (!params.length) {
            this.opcode('literal', null, null);
            return;
        }
        for (var i = params.length - 1; i >= 0; i--) {
            var param = params[i];
            (0, _util.assert)(this[param.type], "Unimplemented " + param.type + " on TemplateCompiler");
            this[param.type](param);
        }
        this.opcode('prepareArray', null, params.length);
    };

    TemplateCompiler.prototype.prepareHash = function prepareHash(hash) {
        var pairs = hash.pairs;
        if (!pairs.length) {
            this.opcode('literal', null, null);
            return;
        }
        for (var i = pairs.length - 1; i >= 0; i--) {
            var _pairs$i = pairs[i],
                key = _pairs$i.key,
                value = _pairs$i.value;

            (0, _util.assert)(this[value.type], "Unimplemented " + value.type + " on TemplateCompiler");
            this[value.type](value);
            this.opcode('literal', null, key);
        }
        this.opcode('prepareObject', null, pairs.length);
    };

    TemplateCompiler.prototype.prepareAttributeValue = function prepareAttributeValue(value) {
        // returns the static value if the value is static
        switch (value.type) {
            case 'TextNode':
                this.opcode('literal', value, value.chars);
                return true;
            case 'MustacheStatement':
                this.attributeMustache([value]);
                return false;
            case 'ConcatStatement':
                this.prepareConcatParts(value.parts);
                this.opcode('concat', value);
                return false;
        }
    };

    TemplateCompiler.prototype.prepareConcatParts = function prepareConcatParts(parts) {
        for (var i = parts.length - 1; i >= 0; i--) {
            var part = parts[i];
            if (part.type === 'MustacheStatement') {
                this.attributeMustache([part]);
            } else if (part.type === 'TextNode') {
                this.opcode('literal', null, part.chars);
            }
        }
        this.opcode('prepareArray', null, parts.length);
    };

    TemplateCompiler.prototype.attributeMustache = function attributeMustache(_ref11) {
        var action = _ref11[0];

        this.mustacheExpression(action);
    };

    TemplateCompiler.prototype.meta = function meta(node) {
        var loc = node.loc;
        if (!loc) {
            return [];
        }
        var source = loc.source,
            start = loc.start,
            end = loc.end;

        return ['loc', [source || null, [start.line, start.column], [end.line, end.column]]];
    };

    _createClass(TemplateCompiler, [{
        key: "symbols",
        get: function () {
            return this.symbolStack.current;
        }
    }]);

    return TemplateCompiler;
}();

exports.default = TemplateCompiler;


function isHelperInvocation(mustache) {
    return mustache.params && mustache.params.length > 0 || mustache.hash && mustache.hash.pairs.length > 0;
}
function isSimplePath(_ref12) {
    var parts = _ref12.parts;

    return parts.length === 1;
}
function isLocal(_ref13, symbols) {
    var parts = _ref13.parts;

    return symbols && symbols.has(parts[0]);
}
function isYield(path) {
    return path.original === 'yield';
}
function isPartial(path) {
    return path.original === 'partial';
}
function isDebugger(path) {
    return path.original === 'debugger';
}
function isHasBlock(path) {
    return path.original === 'has-block';
}
function isHasBlockParams(path) {
    return path.original === 'has-block-params';
}
function isBuiltInHelper(path) {
    return isHasBlock(path) || isHasBlockParams(path);
}
function isArg(path) {
    return !!path['data'];
}
function assertIsSimplePath(path, loc, context) {
    if (!isSimplePath(path)) {
        throw new _syntax.SyntaxError("`" + path.original + "` is not a valid name for a " + context + " on line " + loc.start.line + ".", path.loc);
    }
}
function assertValidYield(statement) {
    var pairs = statement.hash.pairs;

    if (pairs.length === 1 && pairs[0].key !== 'to' || pairs.length > 1) {
        throw new _syntax.SyntaxError("yield only takes a single named argument: 'to'", statement.loc);
    } else if (pairs.length === 1 && pairs[0].value.type !== 'StringLiteral') {
        throw new _syntax.SyntaxError("you can only yield to a literal value", statement.loc);
    } else if (pairs.length === 0) {
        return 'default';
    } else {
        return pairs[0].value.value;
    }
}
function assertValidPartial(statement) {
    var params = statement.params,
        hash = statement.hash,
        escaped = statement.escaped,
        loc = statement.loc;

    if (params && params.length !== 1) {
        throw new _syntax.SyntaxError("Partial found with no arguments. You must specify a template name. (on line " + loc.start.line + ")", statement.loc);
    } else if (hash && hash.pairs.length > 0) {
        throw new _syntax.SyntaxError("partial does not take any named arguments (on line " + loc.start.line + ")", statement.loc);
    } else if (!escaped) {
        throw new _syntax.SyntaxError("{{{partial ...}}} is not supported, please use {{partial ...}} instead (on line " + loc.start.line + ")", statement.loc);
    }
    return params;
}
function assertValidHasBlockUsage(type, call) {
    var params = call.params,
        hash = call.hash,
        loc = call.loc;

    if (hash && hash.pairs.length > 0) {
        throw new _syntax.SyntaxError(type + " does not take any named arguments", call.loc);
    }
    if (params.length === 0) {
        return 'default';
    } else if (params.length === 1) {
        var param = params[0];
        if (param.type === 'StringLiteral') {
            return param.value;
        } else {
            throw new _syntax.SyntaxError("you can only yield to a literal value (on line " + loc.start.line + ")", call.loc);
        }
    } else {
        throw new _syntax.SyntaxError(type + " only takes a single positional argument (on line " + loc.start.line + ")", call.loc);
    }
}
function assertValidDebuggerUsage(statement) {
    var params = statement.params,
        hash = statement.hash;

    if (hash && hash.pairs.length > 0) {
        throw new _syntax.SyntaxError("debugger does not take any named arguments", statement.loc);
    }
    if (params.length === 0) {
        return 'default';
    } else {
        throw new _syntax.SyntaxError("debugger does not take any positional arguments", statement.loc);
    }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi90ZW1wbGF0ZS1jb21waWxlci5qcyJdLCJuYW1lcyI6WyJUZW1wbGF0ZVZpc2l0b3IiLCJKYXZhU2NyaXB0Q29tcGlsZXIiLCJTdGFjayIsImdldEF0dHJOYW1lc3BhY2UiLCJhc3NlcnQiLCJpc0xpdGVyYWwiLCJTeW50YXhFcnJvciIsImlzVHJ1c3RlZFZhbHVlIiwidmFsdWUiLCJlc2NhcGVkIiwidW5kZWZpbmVkIiwiVGVtcGxhdGVDb21waWxlciIsIm9wdGlvbnMiLCJ0ZW1wbGF0ZUlkIiwidGVtcGxhdGVJZHMiLCJzeW1ib2xTdGFjayIsIm9wY29kZXMiLCJpbmNsdWRlTWV0YSIsImNvbXBpbGUiLCJhc3QiLCJ0ZW1wbGF0ZVZpc2l0b3IiLCJ2aXNpdCIsImNvbXBpbGVyIiwicHJvY2VzcyIsImFjdGlvbnMiLCJtZXRhIiwiZm9yRWFjaCIsIm5hbWUiLCJhcmdzIiwiRXJyb3IiLCJzdGFydFByb2dyYW0iLCJwcm9ncmFtIiwicHVzaCIsIm9wY29kZSIsImVuZFByb2dyYW0iLCJwb3AiLCJzdGFydEJsb2NrIiwiZW5kQmxvY2siLCJ0ZXh0IiwiYWN0aW9uIiwiY2hhcnMiLCJjb21tZW50Iiwib3BlbkVsZW1lbnQiLCJpIiwiYXR0cmlidXRlcyIsImxlbmd0aCIsImF0dHJpYnV0ZSIsIm1vZGlmaWVycyIsIm1vZGlmaWVyIiwiY2xvc2VFbGVtZW50IiwibmFtZXNwYWNlIiwiaXNTdGF0aWMiLCJwcmVwYXJlQXR0cmlidXRlVmFsdWUiLCJjaGFyQXQiLCJ0eXBlIiwiaXNUcnVzdGluZyIsImFzc2VydElzU2ltcGxlUGF0aCIsInBhdGgiLCJsb2MiLCJwYXJ0cyIsInByZXBhcmVIZWxwZXIiLCJtdXN0YWNoZSIsIm11c3RhY2hlRXhwcmVzc2lvbiIsImlzWWllbGQiLCJ0byIsImFzc2VydFZhbGlkWWllbGQiLCJ5aWVsZCIsImlzUGFydGlhbCIsInBhcmFtcyIsImFzc2VydFZhbGlkUGFydGlhbCIsInBhcnRpYWwiLCJpc0RlYnVnZ2VyIiwiYXNzZXJ0VmFsaWREZWJ1Z2dlclVzYWdlIiwiZGVidWdnZXIiLCJibG9jayIsImludmVyc2VJZCIsImludmVyc2UiLCJhcmciLCJoZWFkIiwicmVzdCIsInN5bWJvbCIsInN5bWJvbHMiLCJhbGxvY2F0ZU5hbWVkIiwiZXhwciIsImlzQnVpbHRJbkhlbHBlciIsImJ1aWx0SW5IZWxwZXIiLCJpc0FyZyIsImlzSGVscGVySW52b2NhdGlvbiIsInRoaXMiLCJpc0xvY2FsIiwiZ2V0IiwiaXNTaW1wbGVQYXRoIiwicHJlcGFyZVBhcmFtcyIsImFsbG9jYXRlQmxvY2siLCJfbmFtZSIsImdldEV2YWxJbmZvIiwiaGFzQmxvY2siLCJoYXNCbG9ja1BhcmFtcyIsIl9wYXJhbXMiLCJpc0hhc0Jsb2NrIiwiYXNzZXJ0VmFsaWRIYXNCbG9ja1VzYWdlIiwib3JpZ2luYWwiLCJpc0hhc0Jsb2NrUGFyYW1zIiwiU3ViRXhwcmVzc2lvbiIsIlBhdGhFeHByZXNzaW9uIiwiZGF0YSIsImhhcyIsInNsaWNlIiwiU3RyaW5nTGl0ZXJhbCIsIkJvb2xlYW5MaXRlcmFsIiwiTnVtYmVyTGl0ZXJhbCIsIk51bGxMaXRlcmFsIiwiVW5kZWZpbmVkTGl0ZXJhbCIsImhhc2giLCJwcmVwYXJlSGFzaCIsInBhcmFtIiwicGFpcnMiLCJrZXkiLCJhdHRyaWJ1dGVNdXN0YWNoZSIsInByZXBhcmVDb25jYXRQYXJ0cyIsInBhcnQiLCJub2RlIiwic291cmNlIiwic3RhcnQiLCJlbmQiLCJsaW5lIiwiY29sdW1uIiwiY3VycmVudCIsImNvbnRleHQiLCJzdGF0ZW1lbnQiLCJjYWxsIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxBQUFPLEFBQXFCOzs7O0FBQzVCLEFBQU8sQUFBd0I7Ozs7QUFDL0IsQUFBUyxBQUFPLEFBQXdCLEFBQ3hDLEFBQVMsQUFBc0I7O0FBQy9CLEFBQVMsQUFBVyxBQUFtQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFDdkMsU0FBQSxBQUFTLGVBQVQsQUFBd0IsT0FBTyxBQUMzQjtXQUFPLE1BQUEsQUFBTSxZQUFOLEFBQWtCLGFBQWEsQ0FBQyxNQUF2QyxBQUE2QyxBQUNoRDs7O0ksQUFDb0IsK0JBQ2pCOzhCQUFBLEFBQVksU0FBUzs4QkFDakI7O2FBQUEsQUFBSyxhQUFMLEFBQWtCLEFBQ2xCO2FBQUEsQUFBSyxjQUFMLEFBQW1CLEFBQ25CO2FBQUEsQUFBSyxjQUFMLEFBQW1CLEFBQUksQUFDdkI7YUFBQSxBQUFLLFVBQUwsQUFBZSxBQUNmO2FBQUEsQUFBSyxjQUFMLEFBQW1CLEFBQ25CO2FBQUEsQUFBSyxVQUFVLFdBQWYsQUFBMEIsQUFDN0I7OztxQixBQUNNLDJCQUFRLEEsU0FBUyxBLEtBQUssQUFDekI7WUFBSSxrQkFBSixBQUFzQixBQUFJLEFBQzFCO3dCQUFBLEFBQWdCLE1BQWhCLEFBQXNCLEFBQ3RCO1lBQUksV0FBVyxJQUFBLEFBQUksaUJBQW5CLEFBQWUsQUFBcUIsQUFDcEM7WUFBSSxVQUFVLFNBQUEsQUFBUyxRQUFRLGdCQUEvQixBQUFjLEFBQWlDLEFBQy9DO2VBQU8sNkJBQUEsQUFBbUIsUUFBbkIsQUFBMkIsU0FBUyxJQUFwQyxBQUFvQyxBQUFJLFlBQVksUUFBM0QsQUFBTyxBQUE0RCxBQUN0RTtBOzsrQkFJRCxBLDJCLEFBQVEsU0FBUztvQkFDYjs7Z0JBQUEsQUFBUSxRQUFRLGdCQUFxQjtnQkFBbkIsQUFBbUIsWUFBQTtnQkFBVixBQUFVLGtCQUNqQzs7Z0JBQUksQ0FBQyxNQUFMLEFBQUssQUFBSyxPQUFPLEFBQ2I7c0JBQU0sSUFBQSxBQUFJLHlCQUFKLEFBQTJCLE9BQWpDLEFBQ0g7QUFDRDtrQkFBQSxBQUFLLG1CQUFMLEFBQWMsQUFDakI7QUFMRCxBQU1BO2VBQU8sS0FBUCxBQUFZLEFBQ2Y7QTs7K0IsQUFDRCxxQyxBQUFhLFNBQVMsQUFDbEI7YUFBQSxBQUFLLFlBQUwsQUFBaUIsS0FBSyxRQUFBLEFBQVEsR0FBOUIsQUFBc0IsQUFBVyxBQUNqQzthQUFBLEFBQUssT0FBTCxBQUFZLGdCQUFaLEFBQTRCLFNBQTVCLEFBQXFDLEFBQ3hDO0E7OytCLEFBQ0QsbUNBQWEsQUFDVDthQUFBLEFBQUssWUFBTCxBQUFpQixBQUNqQjthQUFBLEFBQUssT0FBTCxBQUFZLGNBQVosQUFBMEIsQUFDN0I7QTs7K0JBQ0QsQSxpQyxBQUFXLFNBQVMsQUFDaEI7YUFBQSxBQUFLLFlBQUwsQUFBaUIsS0FBSyxRQUFBLEFBQVEsR0FBOUIsQUFBc0IsQUFBVyxBQUNqQzthQUFBLEFBQUssQUFDTDthQUFBLEFBQUssT0FBTCxBQUFZLGNBQVosQUFBMEIsU0FBMUIsQUFBbUMsQUFDdEM7QTs7K0JBQ0QsQSwrQkFBVyxBQUNQO2FBQUEsQUFBSyxZQUFMLEFBQWlCLEFBQ2pCO2FBQUEsQUFBSyxZQUFMLEFBQWlCLEtBQUssS0FBQSxBQUFLLGFBQTNCLEFBQXdDLEFBQ3hDO2FBQUEsQUFBSyxPQUFMLEFBQVksWUFBWixBQUF3QixBQUMzQjtBOzsrQixBQUNELDRCQUFlO1lBQVQsQUFBUyxlQUNYOzthQUFBLEFBQUssT0FBTCxBQUFZLFFBQVosQUFBb0IsUUFBUSxPQUE1QixBQUFtQyxBQUN0QztBOzsrQixBQUNELGtDQUFrQjtZQUFULEFBQVMsZUFDZDs7YUFBQSxBQUFLLE9BQUwsQUFBWSxXQUFaLEFBQXVCLFFBQVEsT0FBL0IsQUFBc0MsQUFDekM7QTs7K0IsQUFDRCwwQ0FBc0I7WUFBVCxBQUFTLGVBQ2xCOzthQUFBLEFBQUssT0FBTCxBQUFZLGVBQVosQUFBMkIsUUFBM0IsQUFBbUMsQUFDbkM7YUFBSyxJQUFJLElBQVQsQUFBYSxHQUFHLElBQUksT0FBQSxBQUFPLFdBQTNCLEFBQXNDLFFBQXRDLEFBQThDLEtBQUssQUFDL0M7aUJBQUEsQUFBSyxVQUFVLENBQUMsT0FBQSxBQUFPLFdBQXZCLEFBQWUsQUFBQyxBQUFrQixBQUNyQztBQUNEO2FBQUssSUFBSSxLQUFULEFBQWEsR0FBRyxLQUFJLE9BQUEsQUFBTyxVQUEzQixBQUFxQyxRQUFyQyxBQUE2QyxNQUFLLEFBQzlDO2lCQUFBLEFBQUssU0FBUyxDQUFDLE9BQUEsQUFBTyxVQUF0QixBQUFjLEFBQUMsQUFBaUIsQUFDbkM7QUFDRDthQUFBLEFBQUssT0FBTCxBQUFZLGdCQUFaLEFBQTRCLEFBQzVCO2FBQUEsQUFBSyxZQUFMLEFBQWlCLEtBQUssT0FBdEIsQUFBc0IsQUFBTyxBQUNoQztBOzsrQkFDRCxBLDRDQUF1QjtZQUFULEFBQVMsZUFDbkI7O2FBQUEsQUFBSyxZQUFMLEFBQWlCLEFBQ2pCO2FBQUEsQUFBSyxPQUFMLEFBQVksZ0JBQVosQUFBNEIsTUFBNUIsQUFBa0MsQUFDckM7QTs7K0JBQ0QsQSxzQ0FBb0I7WUFBVCxBQUFTLGVBQUE7WUFBQSxBQUNWLE9BRFUsQUFDTSxPQUROLEFBQ1Y7WUFEVSxBQUNKLFFBREksQUFDTSxPQUROLEFBQ0osQUFDWjs7WUFBSSxZQUFZLDRCQUFoQixBQUFnQixBQUFpQixBQUNqQztZQUFJLFdBQVcsS0FBQSxBQUFLLHNCQUFwQixBQUFlLEFBQTJCLEFBQzFDO1lBQUksS0FBQSxBQUFLLE9BQUwsQUFBWSxPQUFoQixBQUF1QixLQUFLLEFBQ3hCO0FBQ0E7Z0JBQUEsQUFBSSxVQUFVLEFBQ1Y7cUJBQUEsQUFBSyxPQUFMLEFBQVksYUFBWixBQUF5QixRQUF6QixBQUFpQyxBQUNwQztBQUZELHVCQUVXLE9BQUEsQUFBTyxNQUFQLEFBQWEsU0FBakIsQUFBMEIscUJBQXFCLEFBQ2xEO3FCQUFBLEFBQUssT0FBTCxBQUFZLGNBQVosQUFBMEIsUUFBMUIsQUFBa0MsQUFDckM7QUFGTSxhQUFBLE1BRUEsQUFDSDtxQkFBQSxBQUFLLE9BQUwsQUFBWSxjQUFaLEFBQTBCLFFBQTFCLEFBQWtDLEFBQ3JDO0FBQ0o7QUFURCxlQVNPLEFBQ0g7Z0JBQUksYUFBYSxlQUFqQixBQUFpQixBQUFlLEFBQ2hDO2dCQUFBLEFBQUksVUFBVSxBQUNWO3FCQUFBLEFBQUssT0FBTCxBQUFZLGNBQVosQUFBMEIsUUFBMUIsQUFBa0MsTUFBbEMsQUFBd0MsQUFDM0M7QUFGRCx1QkFFTyxBQUFJLFlBQVksQUFDbkI7cUJBQUEsQUFBSyxPQUFMLEFBQVksZ0JBQVosQUFBNEIsUUFBNUIsQUFBb0MsTUFBcEMsQUFBMEMsQUFDN0M7QUFGTSxhQUFBLFVBRUksT0FBQSxBQUFPLE1BQVAsQUFBYSxTQUFqQixBQUEwQixxQkFBcUIsQUFDbEQ7cUJBQUEsQUFBSyxPQUFMLEFBQVksZUFBWixBQUEyQixRQUEzQixBQUFtQyxBQUN0QztBQUZNLGFBQUEsTUFFQSxBQUNIO3FCQUFBLEFBQUssT0FBTCxBQUFZLGVBQVosQUFBMkIsUUFBM0IsQUFBbUMsTUFBbkMsQUFBeUMsQUFDNUM7QUFDSjtBQUNKO0E7OytCLEFBQ0Qsb0NBQW1CO1lBQVQsQUFBUyxlQUNmOzsyQkFBbUIsT0FBbkIsQUFBMEIsTUFBTSxPQUFoQyxBQUF1QyxLQUR4QixBQUNmLEFBQTRDO1lBRDdCLEFBRUQsUUFGQyxBQUVXLE9BRlgsQUFFVCxLQUZTLEFBRUQsQUFDZDs7YUFBQSxBQUFLLGNBQUwsQUFBbUIsQUFDbkI7YUFBQSxBQUFLLE9BQUwsQUFBWSxZQUFaLEFBQXdCLFFBQVEsTUFBaEMsQUFBZ0MsQUFBTSxBQUN6QztBOzsrQixBQUNELG9DQUFtQjtZQUFULEFBQVMsZUFBQTtZQUFBLEFBQ1QsT0FEUyxBQUNBLE9BREEsQUFDVCxBQUNOOztZQUFJLHVCQUFKLEFBQUksQUFBVSxPQUFPLEFBQ2pCO2lCQUFBLEFBQUssbUJBQUwsQUFBd0IsQUFDeEI7aUJBQUEsQUFBSyxPQUFMLEFBQVksVUFBWixBQUFzQixRQUFRLENBQUMsT0FBL0IsQUFBc0MsQUFDekM7QUFIRCxtQkFHVyxRQUFKLEFBQUksQUFBUSxPQUFPLEFBQ3RCO2dCQUFJLEtBQUssaUJBQVQsQUFBUyxBQUFpQixBQUMxQjtpQkFBQSxBQUFLLE1BQUwsQUFBVyxJQUFYLEFBQWUsQUFDbEI7QUFITSxTQUFBLFVBR0ksVUFBSixBQUFJLEFBQVUsT0FBTyxBQUN4QjtnQkFBSSxTQUFTLG1CQUFiLEFBQWEsQUFBbUIsQUFDaEM7aUJBQUEsQUFBSyxRQUFMLEFBQWEsUUFBYixBQUFxQixBQUN4QjtBQUhNLFNBQUEsVUFHSSxXQUFKLEFBQUksQUFBVyxPQUFPLEFBQ3pCO3FDQUFBLEFBQXlCLEFBQ3pCO2lCQUFBLEFBQUssU0FBTCxBQUFjLFlBQWQsQUFBMEIsQUFDN0I7QUFITSxTQUFBLE1BR0EsQUFDSDtpQkFBQSxBQUFLLG1CQUFMLEFBQXdCLEFBQ3hCO2lCQUFBLEFBQUssT0FBTCxBQUFZLFVBQVosQUFBc0IsUUFBUSxDQUFDLE9BQS9CLEFBQXNDLEFBQ3pDO0FBQ0o7QTs7K0JBQ0QsQSw4QkFBbUM7WUFBNUIsQUFBNEIsT0FBckIsQUFBcUIsMkJBQy9COzthQUFBLEFBQUssY0FBTCxBQUFtQixBQUNuQjtZQUFJLGFBQWEsS0FBQSxBQUFLLFlBQXRCLEFBQWlCLEFBQWlCLEFBQ2xDO1lBQUksWUFBWSxPQUFBLEFBQU8sWUFBUCxBQUFtQixPQUFuQixBQUEwQixPQUFPLEtBQUEsQUFBSyxZQUF0RCxBQUFpRCxBQUFpQixBQUNsRTthQUFBLEFBQUssT0FBTCxBQUFZLFNBQVosQUFBcUIsUUFBUSxPQUFBLEFBQU8sS0FBUCxBQUFZLE1BQXpDLEFBQTZCLEFBQWtCLElBQS9DLEFBQW1ELFlBQW5ELEFBQStELEFBQ2xFO0FBQ0QsQTs7OzsrQkFDQSxBLDJCQUFZO1lBQVAsQUFBTyxjQUFBOzswQkFBQSxBQUN5QixLQUR6QixBQUNGO1lBREUsQUFDTSxtQkFETjtZQUFBLEFBQ2UseUJBQ3ZCOztZQUFJLFNBQVMsS0FBQSxBQUFLLFFBQUwsQUFBYSxjQUExQixBQUFhLEFBQTJCLEFBQ3hDO2FBQUEsQUFBSyxPQUFMLEFBQVksT0FBWixBQUFtQixNQUFuQixBQUF5QixRQUF6QixBQUFpQyxBQUNwQztBOzsrQixBQUNELGlELEFBQW1CLE1BQU07WUFBQSxBQUNmLE9BRGUsQUFDTixLQURNLEFBQ2YsQUFDTjs7WUFBSSx1QkFBSixBQUFJLEFBQVUsT0FBTyxBQUNqQjtpQkFBQSxBQUFLLE9BQUwsQUFBWSxXQUFaLEFBQXVCLE1BQU0sS0FBN0IsQUFBa0MsQUFDckM7QUFGRCxtQkFFVyxnQkFBSixBQUFJLEFBQWdCLE9BQU8sQUFDOUI7aUJBQUEsQUFBSyxjQUFMLEFBQW1CLEFBQ3RCO0FBRk0sU0FBQSxVQUVJLE1BQUosQUFBSSxBQUFNLE9BQU8sQUFDcEI7aUJBQUEsQUFBSyxJQUFJLENBQVQsQUFBUyxBQUFDLEFBQ2I7QUFGTSxTQUFBLFVBRUksbUJBQUosQUFBSSxBQUFtQixPQUFPLEFBQ2pDO2lCQUFBLEFBQUssY0FBTCxBQUFtQixBQUNuQjtpQkFBQSxBQUFLLE9BQUwsQUFBWSxVQUFaLEFBQXNCLE1BQU0sS0FBQSxBQUFLLE1BQWpDLEFBQTRCLEFBQVcsQUFDMUM7QUFITSxTQUFBLFVBR0ksS0FBSixBQUFTLE1BQU0sQUFDbEI7aUJBQUEsQUFBSyxPQUFMLEFBQVksT0FBWixBQUFtQixNQUFuQixBQUF5QixHQUFHLEtBQTVCLEFBQWlDLEFBQ3BDO0FBRk0sU0FBQSxVQUVJLFFBQUEsQUFBUSxNQUFNLEtBQWxCLEFBQUksQUFBbUIsVUFBVTsrQkFDYixLQURhLEFBQ1I7Z0JBRFEsQUFDL0Isb0JBRCtCO2dCQUFBLEFBQ3RCLDJCQUNkOztpQkFBQSxBQUFLLE9BQUwsQUFBWSxPQUFaLEFBQW1CLE1BQU0sS0FBQSxBQUFLLFFBQUwsQUFBYSxJQUF0QyxBQUF5QixBQUFpQixPQUExQyxBQUFpRCxBQUNwRDtBQUhNLFNBQUEsVUFHSSxhQUFKLEFBQUksQUFBYSxPQUFPLEFBQzNCO2lCQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsTUFBTSxLQUFBLEFBQUssTUFBbEMsQUFBNkIsQUFBVyxBQUMzQztBQUZNLFNBQUEsTUFFQSxBQUNIO2lCQUFBLEFBQUssT0FBTCxBQUFZLGNBQVosQUFBMEIsTUFBTSxLQUFoQyxBQUFxQyxBQUN4QztBQUNKO0EsQUFDRDs7OzsrQkFDQSxBLHdCLEFBQU0sSUFBSSxBLFFBQVEsQUFDZDthQUFBLEFBQUssY0FBYyxPQUFuQixBQUEwQixBQUMxQjthQUFBLEFBQUssT0FBTCxBQUFZLFNBQVosQUFBcUIsUUFBUSxLQUFBLEFBQUssUUFBTCxBQUFhLGNBQTFDLEFBQTZCLEFBQTJCLEFBQzNEO0E7OytCQUNELEEsOEJBQVMsQSxPLEFBQU8sUUFBUSxBQUNwQjthQUFBLEFBQUssT0FBTCxBQUFZLFlBQVosQUFBd0IsUUFBUSxLQUFBLEFBQUssUUFBckMsQUFBZ0MsQUFBYSxBQUNoRDtBOzsrQkFDRCxBLDZCLEFBQVMsTSxBQUFNLFFBQVEsQUFDbkI7YUFBQSxBQUFLLE9BQUwsQUFBWSxZQUFaLEFBQXdCLFFBQVEsS0FBQSxBQUFLLFFBQUwsQUFBYSxjQUE3QyxBQUFnQyxBQUEyQixBQUM5RDtBOzsrQixBQUNELHlDLEFBQWUsTUFBTSxBLFFBQVEsQUFDekI7YUFBQSxBQUFLLE9BQUwsQUFBWSxrQkFBWixBQUE4QixRQUFRLEtBQUEsQUFBSyxRQUFMLEFBQWEsY0FBbkQsQUFBc0MsQUFBMkIsQUFDcEU7QTs7K0JBQ0QsQSwyQixBQUFRLFMsQUFBUyxRQUFRLEFBQ3JCO2FBQUEsQUFBSyxjQUFjLE9BQW5CLEFBQTBCLEFBQzFCO2FBQUEsQUFBSyxPQUFMLEFBQVksV0FBWixBQUF1QixRQUFRLEtBQUEsQUFBSyxRQUFwQyxBQUErQixBQUFhLEFBQy9DO0E7OytCLEFBQ0QsdUMsQUFBYyxNQUFNO1lBQUEsQUFDVixPQURVLEFBQ0QsS0FEQyxBQUNWLEFBQ047O1lBQUksV0FBSixBQUFJLEFBQVcsT0FBTyxBQUNsQjtnQkFBSSxPQUFPLHlCQUF5QixLQUFBLEFBQUssS0FBOUIsQUFBbUMsVUFBOUMsQUFBVyxBQUE2QyxBQUN4RDtpQkFBQSxBQUFLLFNBQUwsQUFBYyxNQUFkLEFBQW9CLEFBQ3ZCO0FBSEQsZUFHTyxJQUFJLGlCQUFKLEFBQUksQUFBaUIsT0FBTyxBQUMvQjtnQkFBSSxTQUFPLHlCQUF5QixLQUFBLEFBQUssS0FBOUIsQUFBbUMsVUFBOUMsQUFBVyxBQUE2QyxBQUN4RDtpQkFBQSxBQUFLLGVBQUwsQUFBb0IsUUFBcEIsQUFBMEIsQUFDN0I7QUFDSjtBQUNELEE7Ozs7K0IsQUFDQSx1Q0FBYyxBLE1BQU0sQUFDaEI7WUFBSSxnQkFBZ0IsS0FBcEIsQUFBSSxBQUFxQixPQUFPLEFBQzVCO2lCQUFBLEFBQUssY0FBTCxBQUFtQixBQUN0QjtBQUZELGVBRU8sQUFDSDtpQkFBQSxBQUFLLGNBQUwsQUFBbUIsQUFDbkI7aUJBQUEsQUFBSyxPQUFMLEFBQVksVUFBWixBQUFzQixNQUFNLEtBQUEsQUFBSyxLQUFMLEFBQVUsTUFBdEMsQUFBNEIsQUFBZ0IsQUFDL0M7QUFDSjtBOzsrQixBQUNELHlDQUFlLEEsTUFBTSxBQUNqQjtZQUFJLEtBQUosQUFBUyxNQUFNLEFBQ1g7aUJBQUEsQUFBSyxJQUFJLENBQVQsQUFBUyxBQUFDLEFBQ2I7QUFGRCxlQUVPO2dCQUFBLEFBQ0csVUFESCxBQUNlLEtBRGYsQUFDRzs4QkFDTyxLQUZWLEFBRWU7Z0JBRmYsQUFFRSxtQkFDTDs7Z0JBQUksS0FBSixBQUFTLE1BQU0sQUFDWDtxQkFBQSxBQUFLLE9BQUwsQUFBWSxPQUFaLEFBQW1CLE1BQW5CLEFBQXlCLEdBQUcsS0FBNUIsQUFBaUMsQUFDcEM7QUFGRCx1QkFFVyxRQUFBLEFBQVEsSUFBWixBQUFJLEFBQVksT0FBTyxBQUMxQjtxQkFBQSxBQUFLLE9BQUwsQUFBWSxPQUFaLEFBQW1CLE1BQU0sUUFBQSxBQUFRLElBQWpDLEFBQXlCLEFBQVksT0FBTyxLQUFBLEFBQUssTUFBTCxBQUFXLE1BQXZELEFBQTRDLEFBQWlCLEFBQ2hFO0FBRk0sYUFBQSxNQUVBLEFBQ0g7cUJBQUEsQUFBSyxPQUFMLEFBQVksT0FBWixBQUFtQixNQUFuQixBQUF5QixHQUFHLEtBQTVCLEFBQWlDLEFBQ3BDO0FBQ0o7QUFDSjtBOzsrQixBQUNELHVDLEFBQWMsUUFBUSxBQUNsQjthQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsTUFBTSxPQUE3QixBQUFvQyxBQUN2QztBOzsrQkFDRCxBLHlDQUFlLEEsUUFBUSxBQUNuQjthQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsTUFBTSxPQUE3QixBQUFvQyxBQUN2QztBOzsrQixBQUNELHVDLEFBQWMsUUFBUSxBQUNsQjthQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsTUFBTSxPQUE3QixBQUFvQyxBQUN2QztBOzsrQkFDRCxBLG1DLEFBQVksUUFBUSxBQUNoQjthQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsTUFBTSxPQUE3QixBQUFvQyxBQUN2QztBOzsrQixBQUNELDZDLEFBQWlCLFFBQVEsQUFDckI7YUFBQSxBQUFLLE9BQUwsQUFBWSxXQUFaLEFBQXVCLE1BQU0sT0FBN0IsQUFBb0MsQUFDdkM7QUFDRCxBOzs7OytCLEFBQ0EseUJBQU8sQSxNLEFBQU0sUUFBaUI7MENBQU4sQUFBTSxzRUFBTjtBQUFNLHVDQUFBO0FBQzFCOztZQUFJLFVBQUEsQUFBVSxhQUFkLEFBQUksQUFBbUIsQUFDdkI7WUFBSSxLQUFBLEFBQUssZUFBVCxBQUF3QixRQUFRLEFBQzVCO21CQUFBLEFBQU8sS0FBSyxLQUFBLEFBQUssS0FBakIsQUFBWSxBQUFVLEFBQ3pCO0FBQ0Q7YUFBQSxBQUFLLFFBQUwsQUFBYSxLQUFiLEFBQWtCLEFBQ3JCO0E7OytCQUNELEEsdUNBQWMsQSxNQUFNLEFBQ2hCOzJCQUFtQixLQUFuQixBQUF3QixNQUFNLEtBQTlCLEFBQW1DLEtBRG5CLEFBQ2hCLEFBQXdDO1lBRHhCLEFBRVYsU0FGVSxBQUVPLEtBRlAsQUFFVjtZQUZVLEFBRUYsT0FGRSxBQUVPLEtBRlAsQUFFRixBQUNkOzthQUFBLEFBQUssWUFBTCxBQUFpQixBQUNqQjthQUFBLEFBQUssY0FBTCxBQUFtQixBQUN0QjtBOzsrQixBQUNELHVDQUFjLEEsUUFBUSxBQUNsQjtZQUFJLENBQUMsT0FBTCxBQUFZLFFBQVEsQUFDaEI7aUJBQUEsQUFBSyxPQUFMLEFBQVksV0FBWixBQUF1QixNQUF2QixBQUE2QixBQUM3QjtBQUNIO0FBQ0Q7YUFBSyxJQUFJLElBQUksT0FBQSxBQUFPLFNBQXBCLEFBQTZCLEdBQUcsS0FBaEMsQUFBcUMsR0FBckMsQUFBd0MsS0FBSyxBQUN6QztnQkFBSSxRQUFRLE9BQVosQUFBWSxBQUFPLEFBQ25COzhCQUFPLEtBQUssTUFBWixBQUFPLEFBQVcsMEJBQXdCLE1BQTFDLEFBQWdELE9BQ2hEO2lCQUFLLE1BQUwsQUFBVyxNQUFYLEFBQWlCLEFBQ3BCO0FBQ0Q7YUFBQSxBQUFLLE9BQUwsQUFBWSxnQkFBWixBQUE0QixNQUFNLE9BQWxDLEFBQXlDLEFBQzVDO0E7OytCLEFBQ0QsbUMsQUFBWSxNQUFNLEFBQ2Q7WUFBSSxRQUFRLEtBQVosQUFBaUIsQUFDakI7WUFBSSxDQUFDLE1BQUwsQUFBVyxRQUFRLEFBQ2Y7aUJBQUEsQUFBSyxPQUFMLEFBQVksV0FBWixBQUF1QixNQUF2QixBQUE2QixBQUM3QjtBQUNIO0FBQ0Q7YUFBSyxJQUFJLElBQUksTUFBQSxBQUFNLFNBQW5CLEFBQTRCLEdBQUcsS0FBL0IsQUFBb0MsR0FBcEMsQUFBdUMsS0FBSzsyQkFDbkIsTUFEbUIsQUFDbkIsQUFBTTtnQkFEYSxBQUNsQyxlQURrQyxBQUNsQztnQkFEa0MsQUFDN0IsaUJBRDZCLEFBQzdCLEFBQ1g7OzhCQUFPLEtBQUssTUFBWixBQUFPLEFBQVcsMEJBQXdCLE1BQTFDLEFBQWdELE9BQ2hEO2lCQUFLLE1BQUwsQUFBVyxNQUFYLEFBQWlCLEFBQ2pCO2lCQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsTUFBdkIsQUFBNkIsQUFDaEM7QUFDRDthQUFBLEFBQUssT0FBTCxBQUFZLGlCQUFaLEFBQTZCLE1BQU0sTUFBbkMsQUFBeUMsQUFDNUM7QTs7K0IsQUFDRCx1RCxBQUFzQixPQUFPLEFBQ3pCO0FBQ0E7Z0JBQVEsTUFBUixBQUFjLEFBQ1Y7aUJBQUEsQUFBSyxBQUNEO3FCQUFBLEFBQUssT0FBTCxBQUFZLFdBQVosQUFBdUIsT0FBTyxNQUE5QixBQUFvQyxBQUNwQzt1QkFBQSxBQUFPLEFBQ1g7aUJBQUEsQUFBSyxBQUNEO3FCQUFBLEFBQUssa0JBQWtCLENBQXZCLEFBQXVCLEFBQUMsQUFDeEI7dUJBQUEsQUFBTyxBQUNYO2lCQUFBLEFBQUssQUFDRDtxQkFBQSxBQUFLLG1CQUFtQixNQUF4QixBQUE4QixBQUM5QjtxQkFBQSxBQUFLLE9BQUwsQUFBWSxVQUFaLEFBQXNCLEFBQ3RCO3VCQVZSLEFBVVEsQUFBTyxBQUVsQjs7QTs7K0IsQUFDRCxpRCxBQUFtQixPQUFPLEFBQ3RCO2FBQUssSUFBSSxJQUFJLE1BQUEsQUFBTSxTQUFuQixBQUE0QixHQUFHLEtBQS9CLEFBQW9DLEdBQXBDLEFBQXVDLEtBQUssQUFDeEM7Z0JBQUksT0FBTyxNQUFYLEFBQVcsQUFBTSxBQUNqQjtnQkFBSSxLQUFBLEFBQUssU0FBVCxBQUFrQixxQkFBcUIsQUFDbkM7cUJBQUEsQUFBSyxrQkFBa0IsQ0FBdkIsQUFBdUIsQUFBQyxBQUMzQjtBQUZELG1CQUVPLElBQUksS0FBQSxBQUFLLFNBQVQsQUFBa0IsWUFBWSxBQUNqQztxQkFBQSxBQUFLLE9BQUwsQUFBWSxXQUFaLEFBQXVCLE1BQU0sS0FBN0IsQUFBa0MsQUFDckM7QUFDSjtBQUNEO2FBQUEsQUFBSyxPQUFMLEFBQVksZ0JBQVosQUFBNEIsTUFBTSxNQUFsQyxBQUF3QyxBQUMzQztBOzsrQkFDRCxBLHVEQUE0QjtZQUFULEFBQVMsZ0JBQ3hCOzthQUFBLEFBQUssbUJBQUwsQUFBd0IsQUFDM0I7QTs7K0JBQ0QsQSxxQixBQUFLLE1BQU0sQUFDUDtZQUFJLE1BQU0sS0FBVixBQUFlLEFBQ2Y7WUFBSSxDQUFKLEFBQUssS0FBSyxBQUNOO21CQUFBLEFBQU8sQUFDVjtBQUpNO1lBQUEsQUFLRCxTQUxDLEFBS3NCLElBTHRCLEFBS0Q7WUFMQyxBQUtPLFFBTFAsQUFLc0IsSUFMdEIsQUFLTztZQUxQLEFBS2MsTUFMZCxBQUtzQixJQUx0QixBQUtjLEFBQ3JCOztlQUFPLENBQUEsQUFBQyxPQUFPLENBQUMsVUFBRCxBQUFXLE1BQU0sQ0FBQyxNQUFELEFBQU8sTUFBTSxNQUE5QixBQUFpQixBQUFtQixTQUFTLENBQUMsSUFBRCxBQUFLLE1BQU0sSUFBdkUsQUFBTyxBQUFRLEFBQTZDLEFBQWUsQUFDOUU7QTs7Ozt5QkF2UmEsQUFDVjttQkFBYyxLQUFBLEFBQUssWUFBbkIsQUFBK0IsQUFDbEM7Ozs7Ozs7a0JBbEJnQixBOzs7QUF5U3JCLFNBQUEsQUFBUyxtQkFBVCxBQUE0QixVQUFVLEFBQ2xDO1dBQU8sU0FBQSxBQUFTLFVBQVUsU0FBQSxBQUFTLE9BQVQsQUFBZ0IsU0FBbkMsQUFBNEMsS0FBSyxTQUFBLEFBQVMsUUFBUSxTQUFBLEFBQVMsS0FBVCxBQUFjLE1BQWQsQUFBb0IsU0FBN0YsQUFBc0csQUFDekc7O0FBQ0QsU0FBQSxBQUFTLHFCQUF3QjtRQUFULEFBQVMsZUFBVCxBQUFTLEFBQzdCOztXQUFPLE1BQUEsQUFBTSxXQUFiLEFBQXdCLEFBQzNCOztBQUNELFNBQUEsQUFBUyxnQkFBVCxBQUE0QixTQUFTO1FBQWxCLEFBQWtCLGVBQWxCLEFBQWtCLEFBQ2pDOztXQUFPLFdBQVcsUUFBQSxBQUFRLElBQUksTUFBOUIsQUFBa0IsQUFBWSxBQUFNLEFBQ3ZDOztBQUNELFNBQUEsQUFBUyxRQUFULEFBQWlCLE1BQU0sQUFDbkI7V0FBTyxLQUFBLEFBQUssYUFBWixBQUF5QixBQUM1Qjs7QUFDRCxTQUFBLEFBQVMsVUFBVCxBQUFtQixNQUFNLEFBQ3JCO1dBQU8sS0FBQSxBQUFLLGFBQVosQUFBeUIsQUFDNUI7O0FBQ0QsU0FBQSxBQUFTLFdBQVQsQUFBb0IsTUFBTSxBQUN0QjtXQUFPLEtBQUEsQUFBSyxhQUFaLEFBQXlCLEFBQzVCOztBQUNELFNBQUEsQUFBUyxXQUFULEFBQW9CLE1BQU0sQUFDdEI7V0FBTyxLQUFBLEFBQUssYUFBWixBQUF5QixBQUM1Qjs7QUFDRCxTQUFBLEFBQVMsaUJBQVQsQUFBMEIsTUFBTSxBQUM1QjtXQUFPLEtBQUEsQUFBSyxhQUFaLEFBQXlCLEFBQzVCOztBQUNELFNBQUEsQUFBUyxnQkFBVCxBQUF5QixNQUFNLEFBQzNCO1dBQU8sV0FBQSxBQUFXLFNBQVMsaUJBQTNCLEFBQTJCLEFBQWlCLEFBQy9DOztBQUNELFNBQUEsQUFBUyxNQUFULEFBQWUsTUFBTSxBQUNqQjtXQUFPLENBQUMsQ0FBQyxLQUFULEFBQVMsQUFBSyxBQUNqQjs7QUFDRCxTQUFBLEFBQVMsbUJBQVQsQUFBNEIsTUFBNUIsQUFBa0MsS0FBbEMsQUFBdUMsU0FBUyxBQUM1QztRQUFJLENBQUMsYUFBTCxBQUFLLEFBQWEsT0FBTyxBQUNyQjtjQUFNLEFBQUksOEJBQWlCLEtBQXJCLEFBQTBCLDRDQUExQixBQUFrRSx3QkFBbUIsSUFBQSxBQUFJLE1BQXpGLEFBQStGLFlBQVMsS0FBOUcsQUFBTSxBQUE2RyxBQUN0SDtBQUNKOztBQUNELFNBQUEsQUFBUyxpQkFBVCxBQUEwQixXQUFXO1FBQUEsQUFDM0IsUUFBVSxVQURpQixBQUNQLEtBRE8sQUFDM0IsQUFDTjs7UUFBSSxNQUFBLEFBQU0sV0FBTixBQUFpQixLQUFLLE1BQUEsQUFBTSxHQUFOLEFBQVMsUUFBL0IsQUFBdUMsUUFBUSxNQUFBLEFBQU0sU0FBekQsQUFBa0UsR0FBRyxBQUNqRTtjQUFNLEFBQUksMEVBQThELFVBQXhFLEFBQU0sQUFBNEUsQUFDckY7QUFGRCxlQUVXLE1BQUEsQUFBTSxXQUFOLEFBQWlCLEtBQUssTUFBQSxBQUFNLEdBQU4sQUFBUyxNQUFULEFBQWUsU0FBekMsQUFBa0QsaUJBQWlCLEFBQ3RFO2NBQU0sQUFBSSxpRUFBcUQsVUFBL0QsQUFBTSxBQUFtRSxBQUM1RTtBQUZNLEtBQUEsVUFFSSxNQUFBLEFBQU0sV0FBVixBQUFxQixHQUFHLEFBQzNCO2VBQUEsQUFBTyxBQUNWO0FBRk0sS0FBQSxNQUVBLEFBQ0g7ZUFBTyxNQUFBLEFBQU0sR0FBTixBQUFTLE1BQWhCLEFBQXNCLEFBQ3pCO0FBQ0o7O0FBQ0QsU0FBQSxBQUFTLG1CQUFULEFBQTRCLFdBQVc7UUFBQSxBQUM3QixTQUQ2QixBQUNFLFVBREYsQUFDN0I7UUFENkIsQUFDckIsT0FEcUIsQUFDRSxVQURGLEFBQ3JCO1FBRHFCLEFBQ2YsVUFEZSxBQUNFLFVBREYsQUFDZjtRQURlLEFBQ04sTUFETSxBQUNFLFVBREYsQUFDTixBQUM3Qjs7UUFBSSxVQUFVLE9BQUEsQUFBTyxXQUFyQixBQUFnQyxHQUFHLEFBQy9CO2NBQU0sQUFBSSx5R0FBMkYsSUFBQSxBQUFJLE1BQW5HLEFBQXlHLFlBQVMsVUFBeEgsQUFBTSxBQUE0SCxBQUNySTtBQUZELGVBRVcsUUFBUSxLQUFBLEFBQUssTUFBTCxBQUFXLFNBQXZCLEFBQWdDLEdBQUcsQUFDdEM7Y0FBTSxBQUFJLGdGQUFrRSxJQUFBLEFBQUksTUFBMUUsQUFBZ0YsWUFBUyxVQUEvRixBQUFNLEFBQW1HLEFBQzVHO0FBRk0sS0FBQSxNQUVBLElBQUksQ0FBSixBQUFLLFNBQVMsQUFDakI7Y0FBTSxBQUFJLDZHQUErRixJQUFBLEFBQUksTUFBdkcsQUFBNkcsWUFBUyxVQUE1SCxBQUFNLEFBQWdJLEFBQ3pJO0FBQ0Q7V0FBQSxBQUFPLEFBQ1Y7O0FBQ0QsU0FBQSxBQUFTLHlCQUFULEFBQWtDLE1BQWxDLEFBQXdDLE1BQU07UUFBQSxBQUNwQyxTQURvQyxBQUNkLEtBRGMsQUFDcEM7UUFEb0MsQUFDNUIsT0FENEIsQUFDZCxLQURjLEFBQzVCO1FBRDRCLEFBQ3RCLE1BRHNCLEFBQ2QsS0FEYyxBQUN0QixBQUNwQjs7UUFBSSxRQUFRLEtBQUEsQUFBSyxNQUFMLEFBQVcsU0FBdkIsQUFBZ0MsR0FBRyxBQUMvQjtjQUFNLEFBQUksd0JBQUosQUFBbUIsNkNBQTBDLEtBQW5FLEFBQU0sQUFBa0UsQUFDM0U7QUFDRDtRQUFJLE9BQUEsQUFBTyxXQUFYLEFBQXNCLEdBQUcsQUFDckI7ZUFBQSxBQUFPLEFBQ1Y7QUFGRCxlQUVXLE9BQUEsQUFBTyxXQUFYLEFBQXNCLEdBQUcsQUFDNUI7WUFBSSxRQUFRLE9BQVosQUFBWSxBQUFPLEFBQ25CO1lBQUksTUFBQSxBQUFNLFNBQVYsQUFBbUIsaUJBQWlCLEFBQ2hDO21CQUFPLE1BQVAsQUFBYSxBQUNoQjtBQUZELGVBRU8sQUFDSDtrQkFBTSxBQUFJLDRFQUE4RCxJQUFBLEFBQUksTUFBdEUsQUFBNEUsWUFBUyxLQUEzRixBQUFNLEFBQTBGLEFBQ25HO0FBQ0o7QUFQTSxLQUFBLE1BT0EsQUFDSDtjQUFNLEFBQUksd0JBQUosQUFBbUIsOERBQXlELElBQUEsQUFBSSxNQUFoRixBQUFzRixZQUFTLEtBQXJHLEFBQU0sQUFBb0csQUFDN0c7QUFDSjs7QUFDRCxTQUFBLEFBQVMseUJBQVQsQUFBa0MsV0FBVztRQUFBLEFBQ25DLFNBRG1DLEFBQ2xCLFVBRGtCLEFBQ25DO1FBRG1DLEFBQzNCLE9BRDJCLEFBQ2xCLFVBRGtCLEFBQzNCLEFBQ2Q7O1FBQUksUUFBUSxLQUFBLEFBQUssTUFBTCxBQUFXLFNBQXZCLEFBQWdDLEdBQUcsQUFDL0I7Y0FBTSxBQUFJLHNFQUEwRCxVQUFwRSxBQUFNLEFBQXdFLEFBQ2pGO0FBQ0Q7UUFBSSxPQUFBLEFBQU8sV0FBWCxBQUFzQixHQUFHLEFBQ3JCO2VBQUEsQUFBTyxBQUNWO0FBRkQsV0FFTyxBQUNIO2NBQU0sQUFBSSwyRUFBK0QsVUFBekUsQUFBTSxBQUE2RSxBQUN0RjtBQUNKIiwiZmlsZSI6ImxpYi90ZW1wbGF0ZS1jb21waWxlci5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBUZW1wbGF0ZVZpc2l0b3IgZnJvbSBcIi4vdGVtcGxhdGUtdmlzaXRvclwiO1xuaW1wb3J0IEphdmFTY3JpcHRDb21waWxlciBmcm9tIFwiLi9qYXZhc2NyaXB0LWNvbXBpbGVyXCI7XG5pbXBvcnQgeyBTdGFjaywgZ2V0QXR0ck5hbWVzcGFjZSB9IGZyb20gXCJAZ2xpbW1lci91dGlsXCI7XG5pbXBvcnQgeyBhc3NlcnQsIGV4cGVjdCB9IGZyb20gXCJAZ2xpbW1lci91dGlsXCI7XG5pbXBvcnQgeyBpc0xpdGVyYWwsIFN5bnRheEVycm9yIH0gZnJvbSAnQGdsaW1tZXIvc3ludGF4JztcbmZ1bmN0aW9uIGlzVHJ1c3RlZFZhbHVlKHZhbHVlKSB7XG4gICAgcmV0dXJuIHZhbHVlLmVzY2FwZWQgIT09IHVuZGVmaW5lZCAmJiAhdmFsdWUuZXNjYXBlZDtcbn1cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFRlbXBsYXRlQ29tcGlsZXIge1xuICAgIGNvbnN0cnVjdG9yKG9wdGlvbnMpIHtcbiAgICAgICAgdGhpcy50ZW1wbGF0ZUlkID0gMDtcbiAgICAgICAgdGhpcy50ZW1wbGF0ZUlkcyA9IFtdO1xuICAgICAgICB0aGlzLnN5bWJvbFN0YWNrID0gbmV3IFN0YWNrKCk7XG4gICAgICAgIHRoaXMub3Bjb2RlcyA9IFtdO1xuICAgICAgICB0aGlzLmluY2x1ZGVNZXRhID0gZmFsc2U7XG4gICAgICAgIHRoaXMub3B0aW9ucyA9IG9wdGlvbnMgfHwge307XG4gICAgfVxuICAgIHN0YXRpYyBjb21waWxlKG9wdGlvbnMsIGFzdCkge1xuICAgICAgICBsZXQgdGVtcGxhdGVWaXNpdG9yID0gbmV3IFRlbXBsYXRlVmlzaXRvcigpO1xuICAgICAgICB0ZW1wbGF0ZVZpc2l0b3IudmlzaXQoYXN0KTtcbiAgICAgICAgbGV0IGNvbXBpbGVyID0gbmV3IFRlbXBsYXRlQ29tcGlsZXIob3B0aW9ucyk7XG4gICAgICAgIGxldCBvcGNvZGVzID0gY29tcGlsZXIucHJvY2Vzcyh0ZW1wbGF0ZVZpc2l0b3IuYWN0aW9ucyk7XG4gICAgICAgIHJldHVybiBKYXZhU2NyaXB0Q29tcGlsZXIucHJvY2VzcyhvcGNvZGVzLCBhc3RbJ3N5bWJvbHMnXSwgb3B0aW9ucy5tZXRhKTtcbiAgICB9XG4gICAgZ2V0IHN5bWJvbHMoKSB7XG4gICAgICAgIHJldHVybiBleHBlY3QodGhpcy5zeW1ib2xTdGFjay5jdXJyZW50LCAnRXhwZWN0ZWQgYSBzeW1ib2wgdGFibGUgb24gdGhlIHN0YWNrJyk7XG4gICAgfVxuICAgIHByb2Nlc3MoYWN0aW9ucykge1xuICAgICAgICBhY3Rpb25zLmZvckVhY2goKFtuYW1lLCAuLi5hcmdzXSkgPT4ge1xuICAgICAgICAgICAgaWYgKCF0aGlzW25hbWVdKSB7XG4gICAgICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBVbmltcGxlbWVudGVkICR7bmFtZX0gb24gVGVtcGxhdGVDb21waWxlcmApO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgdGhpc1tuYW1lXSguLi5hcmdzKTtcbiAgICAgICAgfSk7XG4gICAgICAgIHJldHVybiB0aGlzLm9wY29kZXM7XG4gICAgfVxuICAgIHN0YXJ0UHJvZ3JhbShwcm9ncmFtKSB7XG4gICAgICAgIHRoaXMuc3ltYm9sU3RhY2sucHVzaChwcm9ncmFtWzBdWydzeW1ib2xzJ10pO1xuICAgICAgICB0aGlzLm9wY29kZSgnc3RhcnRQcm9ncmFtJywgcHJvZ3JhbSwgcHJvZ3JhbSk7XG4gICAgfVxuICAgIGVuZFByb2dyYW0oKSB7XG4gICAgICAgIHRoaXMuc3ltYm9sU3RhY2sucG9wKCk7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdlbmRQcm9ncmFtJywgbnVsbCk7XG4gICAgfVxuICAgIHN0YXJ0QmxvY2socHJvZ3JhbSkge1xuICAgICAgICB0aGlzLnN5bWJvbFN0YWNrLnB1c2gocHJvZ3JhbVswXVsnc3ltYm9scyddKTtcbiAgICAgICAgdGhpcy50ZW1wbGF0ZUlkKys7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdzdGFydEJsb2NrJywgcHJvZ3JhbSwgcHJvZ3JhbSk7XG4gICAgfVxuICAgIGVuZEJsb2NrKCkge1xuICAgICAgICB0aGlzLnN5bWJvbFN0YWNrLnBvcCgpO1xuICAgICAgICB0aGlzLnRlbXBsYXRlSWRzLnB1c2godGhpcy50ZW1wbGF0ZUlkIC0gMSk7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdlbmRCbG9jaycsIG51bGwpO1xuICAgIH1cbiAgICB0ZXh0KFthY3Rpb25dKSB7XG4gICAgICAgIHRoaXMub3Bjb2RlKCd0ZXh0JywgYWN0aW9uLCBhY3Rpb24uY2hhcnMpO1xuICAgIH1cbiAgICBjb21tZW50KFthY3Rpb25dKSB7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdjb21tZW50JywgYWN0aW9uLCBhY3Rpb24udmFsdWUpO1xuICAgIH1cbiAgICBvcGVuRWxlbWVudChbYWN0aW9uXSkge1xuICAgICAgICB0aGlzLm9wY29kZSgnb3BlbkVsZW1lbnQnLCBhY3Rpb24sIGFjdGlvbik7XG4gICAgICAgIGZvciAobGV0IGkgPSAwOyBpIDwgYWN0aW9uLmF0dHJpYnV0ZXMubGVuZ3RoOyBpKyspIHtcbiAgICAgICAgICAgIHRoaXMuYXR0cmlidXRlKFthY3Rpb24uYXR0cmlidXRlc1tpXV0pO1xuICAgICAgICB9XG4gICAgICAgIGZvciAobGV0IGkgPSAwOyBpIDwgYWN0aW9uLm1vZGlmaWVycy5sZW5ndGg7IGkrKykge1xuICAgICAgICAgICAgdGhpcy5tb2RpZmllcihbYWN0aW9uLm1vZGlmaWVyc1tpXV0pO1xuICAgICAgICB9XG4gICAgICAgIHRoaXMub3Bjb2RlKCdmbHVzaEVsZW1lbnQnLCBudWxsKTtcbiAgICAgICAgdGhpcy5zeW1ib2xTdGFjay5wdXNoKGFjdGlvblsnc3ltYm9scyddKTtcbiAgICB9XG4gICAgY2xvc2VFbGVtZW50KFthY3Rpb25dKSB7XG4gICAgICAgIHRoaXMuc3ltYm9sU3RhY2sucG9wKCk7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdjbG9zZUVsZW1lbnQnLCBudWxsLCBhY3Rpb24pO1xuICAgIH1cbiAgICBhdHRyaWJ1dGUoW2FjdGlvbl0pIHtcbiAgICAgICAgbGV0IHsgbmFtZSwgdmFsdWUgfSA9IGFjdGlvbjtcbiAgICAgICAgbGV0IG5hbWVzcGFjZSA9IGdldEF0dHJOYW1lc3BhY2UobmFtZSk7XG4gICAgICAgIGxldCBpc1N0YXRpYyA9IHRoaXMucHJlcGFyZUF0dHJpYnV0ZVZhbHVlKHZhbHVlKTtcbiAgICAgICAgaWYgKG5hbWUuY2hhckF0KDApID09PSAnQCcpIHtcbiAgICAgICAgICAgIC8vIEFyZ3VtZW50c1xuICAgICAgICAgICAgaWYgKGlzU3RhdGljKSB7XG4gICAgICAgICAgICAgICAgdGhpcy5vcGNvZGUoJ3N0YXRpY0FyZycsIGFjdGlvbiwgbmFtZSk7XG4gICAgICAgICAgICB9IGVsc2UgaWYgKGFjdGlvbi52YWx1ZS50eXBlID09PSAnTXVzdGFjaGVTdGF0ZW1lbnQnKSB7XG4gICAgICAgICAgICAgICAgdGhpcy5vcGNvZGUoJ2R5bmFtaWNBcmcnLCBhY3Rpb24sIG5hbWUpO1xuICAgICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgICAgICB0aGlzLm9wY29kZSgnZHluYW1pY0FyZycsIGFjdGlvbiwgbmFtZSk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICBsZXQgaXNUcnVzdGluZyA9IGlzVHJ1c3RlZFZhbHVlKHZhbHVlKTtcbiAgICAgICAgICAgIGlmIChpc1N0YXRpYykge1xuICAgICAgICAgICAgICAgIHRoaXMub3Bjb2RlKCdzdGF0aWNBdHRyJywgYWN0aW9uLCBuYW1lLCBuYW1lc3BhY2UpO1xuICAgICAgICAgICAgfSBlbHNlIGlmIChpc1RydXN0aW5nKSB7XG4gICAgICAgICAgICAgICAgdGhpcy5vcGNvZGUoJ3RydXN0aW5nQXR0cicsIGFjdGlvbiwgbmFtZSwgbmFtZXNwYWNlKTtcbiAgICAgICAgICAgIH0gZWxzZSBpZiAoYWN0aW9uLnZhbHVlLnR5cGUgPT09ICdNdXN0YWNoZVN0YXRlbWVudCcpIHtcbiAgICAgICAgICAgICAgICB0aGlzLm9wY29kZSgnZHluYW1pY0F0dHInLCBhY3Rpb24sIG5hbWUpO1xuICAgICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgICAgICB0aGlzLm9wY29kZSgnZHluYW1pY0F0dHInLCBhY3Rpb24sIG5hbWUsIG5hbWVzcGFjZSk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICB9XG4gICAgbW9kaWZpZXIoW2FjdGlvbl0pIHtcbiAgICAgICAgYXNzZXJ0SXNTaW1wbGVQYXRoKGFjdGlvbi5wYXRoLCBhY3Rpb24ubG9jLCAnbW9kaWZpZXInKTtcbiAgICAgICAgbGV0IHsgcGF0aDogeyBwYXJ0cyB9IH0gPSBhY3Rpb247XG4gICAgICAgIHRoaXMucHJlcGFyZUhlbHBlcihhY3Rpb24pO1xuICAgICAgICB0aGlzLm9wY29kZSgnbW9kaWZpZXInLCBhY3Rpb24sIHBhcnRzWzBdKTtcbiAgICB9XG4gICAgbXVzdGFjaGUoW2FjdGlvbl0pIHtcbiAgICAgICAgbGV0IHsgcGF0aCB9ID0gYWN0aW9uO1xuICAgICAgICBpZiAoaXNMaXRlcmFsKHBhdGgpKSB7XG4gICAgICAgICAgICB0aGlzLm11c3RhY2hlRXhwcmVzc2lvbihhY3Rpb24pO1xuICAgICAgICAgICAgdGhpcy5vcGNvZGUoJ2FwcGVuZCcsIGFjdGlvbiwgIWFjdGlvbi5lc2NhcGVkKTtcbiAgICAgICAgfSBlbHNlIGlmIChpc1lpZWxkKHBhdGgpKSB7XG4gICAgICAgICAgICBsZXQgdG8gPSBhc3NlcnRWYWxpZFlpZWxkKGFjdGlvbik7XG4gICAgICAgICAgICB0aGlzLnlpZWxkKHRvLCBhY3Rpb24pO1xuICAgICAgICB9IGVsc2UgaWYgKGlzUGFydGlhbChwYXRoKSkge1xuICAgICAgICAgICAgbGV0IHBhcmFtcyA9IGFzc2VydFZhbGlkUGFydGlhbChhY3Rpb24pO1xuICAgICAgICAgICAgdGhpcy5wYXJ0aWFsKHBhcmFtcywgYWN0aW9uKTtcbiAgICAgICAgfSBlbHNlIGlmIChpc0RlYnVnZ2VyKHBhdGgpKSB7XG4gICAgICAgICAgICBhc3NlcnRWYWxpZERlYnVnZ2VyVXNhZ2UoYWN0aW9uKTtcbiAgICAgICAgICAgIHRoaXMuZGVidWdnZXIoJ2RlYnVnZ2VyJywgYWN0aW9uKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMubXVzdGFjaGVFeHByZXNzaW9uKGFjdGlvbik7XG4gICAgICAgICAgICB0aGlzLm9wY29kZSgnYXBwZW5kJywgYWN0aW9uLCAhYWN0aW9uLmVzY2FwZWQpO1xuICAgICAgICB9XG4gICAgfVxuICAgIGJsb2NrKFthY3Rpb24gLyosIGluZGV4LCBjb3VudCovXSkge1xuICAgICAgICB0aGlzLnByZXBhcmVIZWxwZXIoYWN0aW9uKTtcbiAgICAgICAgbGV0IHRlbXBsYXRlSWQgPSB0aGlzLnRlbXBsYXRlSWRzLnBvcCgpO1xuICAgICAgICBsZXQgaW52ZXJzZUlkID0gYWN0aW9uLmludmVyc2UgPT09IG51bGwgPyBudWxsIDogdGhpcy50ZW1wbGF0ZUlkcy5wb3AoKTtcbiAgICAgICAgdGhpcy5vcGNvZGUoJ2Jsb2NrJywgYWN0aW9uLCBhY3Rpb24ucGF0aC5wYXJ0c1swXSwgdGVtcGxhdGVJZCwgaW52ZXJzZUlkKTtcbiAgICB9XG4gICAgLy8vIEludGVybmFsIGFjdGlvbnMsIG5vdCBmb3VuZCBpbiB0aGUgb3JpZ2luYWwgcHJvY2Vzc2VkIGFjdGlvbnNcbiAgICBhcmcoW3BhdGhdKSB7XG4gICAgICAgIGxldCB7IHBhcnRzOiBbaGVhZCwgLi4ucmVzdF0gfSA9IHBhdGg7XG4gICAgICAgIGxldCBzeW1ib2wgPSB0aGlzLnN5bWJvbHMuYWxsb2NhdGVOYW1lZChoZWFkKTtcbiAgICAgICAgdGhpcy5vcGNvZGUoJ2dldCcsIHBhdGgsIHN5bWJvbCwgcmVzdCk7XG4gICAgfVxuICAgIG11c3RhY2hlRXhwcmVzc2lvbihleHByKSB7XG4gICAgICAgIGxldCB7IHBhdGggfSA9IGV4cHI7XG4gICAgICAgIGlmIChpc0xpdGVyYWwocGF0aCkpIHtcbiAgICAgICAgICAgIHRoaXMub3Bjb2RlKCdsaXRlcmFsJywgZXhwciwgcGF0aC52YWx1ZSk7XG4gICAgICAgIH0gZWxzZSBpZiAoaXNCdWlsdEluSGVscGVyKHBhdGgpKSB7XG4gICAgICAgICAgICB0aGlzLmJ1aWx0SW5IZWxwZXIoZXhwcik7XG4gICAgICAgIH0gZWxzZSBpZiAoaXNBcmcocGF0aCkpIHtcbiAgICAgICAgICAgIHRoaXMuYXJnKFtwYXRoXSk7XG4gICAgICAgIH0gZWxzZSBpZiAoaXNIZWxwZXJJbnZvY2F0aW9uKGV4cHIpKSB7XG4gICAgICAgICAgICB0aGlzLnByZXBhcmVIZWxwZXIoZXhwcik7XG4gICAgICAgICAgICB0aGlzLm9wY29kZSgnaGVscGVyJywgZXhwciwgcGF0aC5wYXJ0c1swXSk7XG4gICAgICAgIH0gZWxzZSBpZiAocGF0aC50aGlzKSB7XG4gICAgICAgICAgICB0aGlzLm9wY29kZSgnZ2V0JywgZXhwciwgMCwgcGF0aC5wYXJ0cyk7XG4gICAgICAgIH0gZWxzZSBpZiAoaXNMb2NhbChwYXRoLCB0aGlzLnN5bWJvbHMpKSB7XG4gICAgICAgICAgICBsZXQgW2hlYWQsIC4uLnBhcnRzXSA9IHBhdGgucGFydHM7XG4gICAgICAgICAgICB0aGlzLm9wY29kZSgnZ2V0JywgZXhwciwgdGhpcy5zeW1ib2xzLmdldChoZWFkKSwgcGFydHMpO1xuICAgICAgICB9IGVsc2UgaWYgKGlzU2ltcGxlUGF0aChwYXRoKSkge1xuICAgICAgICAgICAgdGhpcy5vcGNvZGUoJ3Vua25vd24nLCBleHByLCBwYXRoLnBhcnRzWzBdKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMub3Bjb2RlKCdtYXliZUxvY2FsJywgZXhwciwgcGF0aC5wYXJ0cyk7XG4gICAgICAgIH1cbiAgICB9XG4gICAgLy8vIEludGVybmFsIFN5bnRheFxuICAgIHlpZWxkKHRvLCBhY3Rpb24pIHtcbiAgICAgICAgdGhpcy5wcmVwYXJlUGFyYW1zKGFjdGlvbi5wYXJhbXMpO1xuICAgICAgICB0aGlzLm9wY29kZSgneWllbGQnLCBhY3Rpb24sIHRoaXMuc3ltYm9scy5hbGxvY2F0ZUJsb2NrKHRvKSk7XG4gICAgfVxuICAgIGRlYnVnZ2VyKF9uYW1lLCBhY3Rpb24pIHtcbiAgICAgICAgdGhpcy5vcGNvZGUoJ2RlYnVnZ2VyJywgYWN0aW9uLCB0aGlzLnN5bWJvbHMuZ2V0RXZhbEluZm8oKSk7XG4gICAgfVxuICAgIGhhc0Jsb2NrKG5hbWUsIGFjdGlvbikge1xuICAgICAgICB0aGlzLm9wY29kZSgnaGFzQmxvY2snLCBhY3Rpb24sIHRoaXMuc3ltYm9scy5hbGxvY2F0ZUJsb2NrKG5hbWUpKTtcbiAgICB9XG4gICAgaGFzQmxvY2tQYXJhbXMobmFtZSwgYWN0aW9uKSB7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdoYXNCbG9ja1BhcmFtcycsIGFjdGlvbiwgdGhpcy5zeW1ib2xzLmFsbG9jYXRlQmxvY2sobmFtZSkpO1xuICAgIH1cbiAgICBwYXJ0aWFsKF9wYXJhbXMsIGFjdGlvbikge1xuICAgICAgICB0aGlzLnByZXBhcmVQYXJhbXMoYWN0aW9uLnBhcmFtcyk7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdwYXJ0aWFsJywgYWN0aW9uLCB0aGlzLnN5bWJvbHMuZ2V0RXZhbEluZm8oKSk7XG4gICAgfVxuICAgIGJ1aWx0SW5IZWxwZXIoZXhwcikge1xuICAgICAgICBsZXQgeyBwYXRoIH0gPSBleHByO1xuICAgICAgICBpZiAoaXNIYXNCbG9jayhwYXRoKSkge1xuICAgICAgICAgICAgbGV0IG5hbWUgPSBhc3NlcnRWYWxpZEhhc0Jsb2NrVXNhZ2UoZXhwci5wYXRoLm9yaWdpbmFsLCBleHByKTtcbiAgICAgICAgICAgIHRoaXMuaGFzQmxvY2sobmFtZSwgZXhwcik7XG4gICAgICAgIH0gZWxzZSBpZiAoaXNIYXNCbG9ja1BhcmFtcyhwYXRoKSkge1xuICAgICAgICAgICAgbGV0IG5hbWUgPSBhc3NlcnRWYWxpZEhhc0Jsb2NrVXNhZ2UoZXhwci5wYXRoLm9yaWdpbmFsLCBleHByKTtcbiAgICAgICAgICAgIHRoaXMuaGFzQmxvY2tQYXJhbXMobmFtZSwgZXhwcik7XG4gICAgICAgIH1cbiAgICB9XG4gICAgLy8vIEV4cHJlc3Npb25zLCBpbnZva2VkIHJlY3Vyc2l2ZWx5IGZyb20gcHJlcGFyZVBhcmFtcyBhbmQgcHJlcGFyZUhhc2hcbiAgICBTdWJFeHByZXNzaW9uKGV4cHIpIHtcbiAgICAgICAgaWYgKGlzQnVpbHRJbkhlbHBlcihleHByLnBhdGgpKSB7XG4gICAgICAgICAgICB0aGlzLmJ1aWx0SW5IZWxwZXIoZXhwcik7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICB0aGlzLnByZXBhcmVIZWxwZXIoZXhwcik7XG4gICAgICAgICAgICB0aGlzLm9wY29kZSgnaGVscGVyJywgZXhwciwgZXhwci5wYXRoLnBhcnRzWzBdKTtcbiAgICAgICAgfVxuICAgIH1cbiAgICBQYXRoRXhwcmVzc2lvbihleHByKSB7XG4gICAgICAgIGlmIChleHByLmRhdGEpIHtcbiAgICAgICAgICAgIHRoaXMuYXJnKFtleHByXSk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICBsZXQgeyBzeW1ib2xzIH0gPSB0aGlzO1xuICAgICAgICAgICAgbGV0IFtoZWFkXSA9IGV4cHIucGFydHM7XG4gICAgICAgICAgICBpZiAoZXhwci50aGlzKSB7XG4gICAgICAgICAgICAgICAgdGhpcy5vcGNvZGUoJ2dldCcsIGV4cHIsIDAsIGV4cHIucGFydHMpO1xuICAgICAgICAgICAgfSBlbHNlIGlmIChzeW1ib2xzLmhhcyhoZWFkKSkge1xuICAgICAgICAgICAgICAgIHRoaXMub3Bjb2RlKCdnZXQnLCBleHByLCBzeW1ib2xzLmdldChoZWFkKSwgZXhwci5wYXJ0cy5zbGljZSgxKSk7XG4gICAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgICAgIHRoaXMub3Bjb2RlKCdnZXQnLCBleHByLCAwLCBleHByLnBhcnRzKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgIH1cbiAgICBTdHJpbmdMaXRlcmFsKGFjdGlvbikge1xuICAgICAgICB0aGlzLm9wY29kZSgnbGl0ZXJhbCcsIG51bGwsIGFjdGlvbi52YWx1ZSk7XG4gICAgfVxuICAgIEJvb2xlYW5MaXRlcmFsKGFjdGlvbikge1xuICAgICAgICB0aGlzLm9wY29kZSgnbGl0ZXJhbCcsIG51bGwsIGFjdGlvbi52YWx1ZSk7XG4gICAgfVxuICAgIE51bWJlckxpdGVyYWwoYWN0aW9uKSB7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdsaXRlcmFsJywgbnVsbCwgYWN0aW9uLnZhbHVlKTtcbiAgICB9XG4gICAgTnVsbExpdGVyYWwoYWN0aW9uKSB7XG4gICAgICAgIHRoaXMub3Bjb2RlKCdsaXRlcmFsJywgbnVsbCwgYWN0aW9uLnZhbHVlKTtcbiAgICB9XG4gICAgVW5kZWZpbmVkTGl0ZXJhbChhY3Rpb24pIHtcbiAgICAgICAgdGhpcy5vcGNvZGUoJ2xpdGVyYWwnLCBudWxsLCBhY3Rpb24udmFsdWUpO1xuICAgIH1cbiAgICAvLy8gVXRpbGl0aWVzXG4gICAgb3Bjb2RlKG5hbWUsIGFjdGlvbiwgLi4uYXJncykge1xuICAgICAgICBsZXQgb3Bjb2RlID0gW25hbWUsIC4uLmFyZ3NdO1xuICAgICAgICBpZiAodGhpcy5pbmNsdWRlTWV0YSAmJiBhY3Rpb24pIHtcbiAgICAgICAgICAgIG9wY29kZS5wdXNoKHR