Make WordPress Core

Changeset 42548 for branches/4.9


Ignore:
Timestamp:
01/23/2018 03:37:13 AM (9 years ago)
Author:
jorbin
Message:

Remove JSHint due to license compatibility

Backports [42547] without adding new files due to how minor updates work.

JSHint inherits a license from JSLint that includes the clause "The Software shall be used for Good, not Evil." WordPress's license specifically allows grants the freedom to run the program, for any purpose. Please note, this is not an encouragement of evil. Rather than doing something evil, how about learning to love those around you. Instead of tweeting lies and saying people are "Not Good!", help your neighbor. In the words of Lin Manual Miranda, "Love is love is love is love is love is love is love is love, cannot be killed or swept aside."

This replaces JSHint with esprima, a part of the larger jQuery project, and a custom wrapper for some basic error checking within codemirror.

The existing JSHint configuration is kept in place in case someone wants to use that, but they can only do so for Good.

Fixes #42850
Props netweb for a spelling fix on a comment.

Location:
branches/4.9/src/wp-includes
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/4.9/src/wp-includes/js/codemirror/jshint.js

    r41376 r42548  
    1 /*! 2.9.5 */
    2 var JSHINT;
    3 if (typeof window === 'undefined') window = {};
    4 (function () {
    5 var require;
    6 require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
    7 var identifierStartTable = [];
     1(function webpackUniversalModuleDefinition(root, factory) {
     2/* istanbul ignore next */
     3        if(typeof exports === 'object' && typeof module === 'object')
     4                module.exports = factory();
     5        else if(typeof define === 'function' && define.amd)
     6                define([], factory);
     7/* istanbul ignore next */
     8        else if(typeof exports === 'object')
     9                exports["esprima"] = factory();
     10        else
     11                root["esprima"] = factory();
     12})(this, function() {
     13return /******/ (function(modules) { // webpackBootstrap
     14/******/        // The module cache
     15/******/        var installedModules = {};
    816
    9 for (var i = 0; i < 128; i++) {
    10   identifierStartTable[i] =
    11     i === 36 ||           // $
    12     i >= 65 && i <= 90 || // A-Z
    13     i === 95 ||           // _
    14     i >= 97 && i <= 122;  // a-z
    15 }
     17/******/        // The require function
     18/******/        function __webpack_require__(moduleId) {
    1619
    17 var identifierPartTable = [];
     20/******/                // Check if module is in cache
     21/* istanbul ignore if */
     22/******/                if(installedModules[moduleId])
     23/******/                        return installedModules[moduleId].exports;
    1824
    19 for (var i = 0; i < 128; i++) {
    20   identifierPartTable[i] =
    21     identifierStartTable[i] || // $, _, A-Z, a-z
    22     i >= 48 && i <= 57;        // 0-9
    23 }
     25/******/                // Create a new module (and put it into the cache)
     26/******/                var module = installedModules[moduleId] = {
     27/******/                        exports: {},
     28/******/                        id: moduleId,
     29/******/                        loaded: false
     30/******/                };
    2431
    25 module.exports = {
    26   asciiIdentifierStartTable: identifierStartTable,
    27   asciiIdentifierPartTable: identifierPartTable
     32/******/                // Execute the module function
     33/******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
     34
     35/******/                // Flag the module as loaded
     36/******/                module.loaded = true;
     37
     38/******/                // Return the exports of the module
     39/******/                return module.exports;
     40/******/        }
     41
     42
     43/******/        // expose the modules object (__webpack_modules__)
     44/******/        __webpack_require__.m = modules;
     45
     46/******/        // expose the module cache
     47/******/        __webpack_require__.c = installedModules;
     48
     49/******/        // __webpack_public_path__
     50/******/        __webpack_require__.p = "";
     51
     52/******/        // Load entry module and return exports
     53/******/        return __webpack_require__(0);
     54/******/ })
     55/************************************************************************/
     56/******/ ([
     57/* 0 */
     58/***/ function(module, exports, __webpack_require__) {
     59
     60        "use strict";
     61        /*
     62          Copyright JS Foundation and other contributors, https://js.foundation/
     63
     64          Redistribution and use in source and binary forms, with or without
     65          modification, are permitted provided that the following conditions are met:
     66
     67            * Redistributions of source code must retain the above copyright
     68              notice, this list of conditions and the following disclaimer.
     69            * Redistributions in binary form must reproduce the above copyright
     70              notice, this list of conditions and the following disclaimer in the
     71              documentation and/or other materials provided with the distribution.
     72
     73          THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     74          AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     75          IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     76          ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
     77          DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     78          (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     79          LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     80          ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     81          (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     82          THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     83        */
     84        Object.defineProperty(exports, "__esModule", { value: true });
     85        var comment_handler_1 = __webpack_require__(1);
     86        var jsx_parser_1 = __webpack_require__(3);
     87        var parser_1 = __webpack_require__(8);
     88        var tokenizer_1 = __webpack_require__(15);
     89        function parse(code, options, delegate) {
     90            var commentHandler = null;
     91            var proxyDelegate = function (node, metadata) {
     92                if (delegate) {
     93                    delegate(node, metadata);
     94                }
     95                if (commentHandler) {
     96                    commentHandler.visit(node, metadata);
     97                }
     98            };
     99            var parserDelegate = (typeof delegate === 'function') ? proxyDelegate : null;
     100            var collectComment = false;
     101            if (options) {
     102                collectComment = (typeof options.comment === 'boolean' && options.comment);
     103                var attachComment = (typeof options.attachComment === 'boolean' && options.attachComment);
     104                if (collectComment || attachComment) {
     105                    commentHandler = new comment_handler_1.CommentHandler();
     106                    commentHandler.attach = attachComment;
     107                    options.comment = true;
     108                    parserDelegate = proxyDelegate;
     109                }
     110            }
     111            var isModule = false;
     112            if (options && typeof options.sourceType === 'string') {
     113                isModule = (options.sourceType === 'module');
     114            }
     115            var parser;
     116            if (options && typeof options.jsx === 'boolean' && options.jsx) {
     117                parser = new jsx_parser_1.JSXParser(code, options, parserDelegate);
     118            }
     119            else {
     120                parser = new parser_1.Parser(code, options, parserDelegate);
     121            }
     122            var program = isModule ? parser.parseModule() : parser.parseScript();
     123            var ast = program;
     124            if (collectComment && commentHandler) {
     125                ast.comments = commentHandler.comments;
     126            }
     127            if (parser.config.tokens) {
     128                ast.tokens = parser.tokens;
     129            }
     130            if (parser.config.tolerant) {
     131                ast.errors = parser.errorHandler.errors;
     132            }
     133            return ast;
     134        }
     135        exports.parse = parse;
     136        function parseModule(code, options, delegate) {
     137            var parsingOptions = options || {};
     138            parsingOptions.sourceType = 'module';
     139            return parse(code, parsingOptions, delegate);
     140        }
     141        exports.parseModule = parseModule;
     142        function parseScript(code, options, delegate) {
     143            var parsingOptions = options || {};
     144            parsingOptions.sourceType = 'script';
     145            return parse(code, parsingOptions, delegate);
     146        }
     147        exports.parseScript = parseScript;
     148        function tokenize(code, options, delegate) {
     149            var tokenizer = new tokenizer_1.Tokenizer(code, options);
     150            var tokens;
     151            tokens = [];
     152            try {
     153                while (true) {
     154                    var token = tokenizer.getNextToken();
     155                    if (!token) {
     156                        break;
     157                    }
     158                    if (delegate) {
     159                        token = delegate(token);
     160                    }
     161                    tokens.push(token);
     162                }
     163            }
     164            catch (e) {
     165                tokenizer.errorHandler.tolerate(e);
     166            }
     167            if (tokenizer.errorHandler.tolerant) {
     168                tokens.errors = tokenizer.errors();
     169            }
     170            return tokens;
     171        }
     172        exports.tokenize = tokenize;
     173        var syntax_1 = __webpack_require__(2);
     174        exports.Syntax = syntax_1.Syntax;
     175        // Sync with *.json manifests.
     176        exports.version = '4.0.0';
     177
     178
     179/***/ },
     180/* 1 */
     181/***/ function(module, exports, __webpack_require__) {
     182
     183        "use strict";
     184        Object.defineProperty(exports, "__esModule", { value: true });
     185        var syntax_1 = __webpack_require__(2);
     186        var CommentHandler = (function () {
     187            function CommentHandler() {
     188                this.attach = false;
     189                this.comments = [];
     190                this.stack = [];
     191                this.leading = [];
     192                this.trailing = [];
     193            }
     194            CommentHandler.prototype.insertInnerComments = function (node, metadata) {
     195                //  innnerComments for properties empty block
     196                //  `function a() {/** comments **\/}`
     197                if (node.type === syntax_1.Syntax.BlockStatement && node.body.length === 0) {
     198                    var innerComments = [];
     199                    for (var i = this.leading.length - 1; i >= 0; --i) {
     200                        var entry = this.leading[i];
     201                        if (metadata.end.offset >= entry.start) {
     202                            innerComments.unshift(entry.comment);
     203                            this.leading.splice(i, 1);
     204                            this.trailing.splice(i, 1);
     205                        }
     206                    }
     207                    if (innerComments.length) {
     208                        node.innerComments = innerComments;
     209                    }
     210                }
     211            };
     212            CommentHandler.prototype.findTrailingComments = function (metadata) {
     213                var trailingComments = [];
     214                if (this.trailing.length > 0) {
     215                    for (var i = this.trailing.length - 1; i >= 0; --i) {
     216                        var entry_1 = this.trailing[i];
     217                        if (entry_1.start >= metadata.end.offset) {
     218                            trailingComments.unshift(entry_1.comment);
     219                        }
     220                    }
     221                    this.trailing.length = 0;
     222                    return trailingComments;
     223                }
     224                var entry = this.stack[this.stack.length - 1];
     225                if (entry && entry.node.trailingComments) {
     226                    var firstComment = entry.node.trailingComments[0];
     227                    if (firstComment && firstComment.range[0] >= metadata.end.offset) {
     228                        trailingComments = entry.node.trailingComments;
     229                        delete entry.node.trailingComments;
     230                    }
     231                }
     232                return trailingComments;
     233            };
     234            CommentHandler.prototype.findLeadingComments = function (metadata) {
     235                var leadingComments = [];
     236                var target;
     237                while (this.stack.length > 0) {
     238                    var entry = this.stack[this.stack.length - 1];
     239                    if (entry && entry.start >= metadata.start.offset) {
     240                        target = entry.node;
     241                        this.stack.pop();
     242                    }
     243                    else {
     244                        break;
     245                    }
     246                }
     247                if (target) {
     248                    var count = target.leadingComments ? target.leadingComments.length : 0;
     249                    for (var i = count - 1; i >= 0; --i) {
     250                        var comment = target.leadingComments[i];
     251                        if (comment.range[1] <= metadata.start.offset) {
     252                            leadingComments.unshift(comment);
     253                            target.leadingComments.splice(i, 1);
     254                        }
     255                    }
     256                    if (target.leadingComments && target.leadingComments.length === 0) {
     257                        delete target.leadingComments;
     258                    }
     259                    return leadingComments;
     260                }
     261                for (var i = this.leading.length - 1; i >= 0; --i) {
     262                    var entry = this.leading[i];
     263                    if (entry.start <= metadata.start.offset) {
     264                        leadingComments.unshift(entry.comment);
     265                        this.leading.splice(i, 1);
     266                    }
     267                }
     268                return leadingComments;
     269            };
     270            CommentHandler.prototype.visitNode = function (node, metadata) {
     271                if (node.type === syntax_1.Syntax.Program && node.body.length > 0) {
     272                    return;
     273                }
     274                this.insertInnerComments(node, metadata);
     275                var trailingComments = this.findTrailingComments(metadata);
     276                var leadingComments = this.findLeadingComments(metadata);
     277                if (leadingComments.length > 0) {
     278                    node.leadingComments = leadingComments;
     279                }
     280                if (trailingComments.length > 0) {
     281                    node.trailingComments = trailingComments;
     282                }
     283                this.stack.push({
     284                    node: node,
     285                    start: metadata.start.offset
     286                });
     287            };
     288            CommentHandler.prototype.visitComment = function (node, metadata) {
     289                var type = (node.type[0] === 'L') ? 'Line' : 'Block';
     290                var comment = {
     291                    type: type,
     292                    value: node.value
     293                };
     294                if (node.range) {
     295                    comment.range = node.range;
     296                }
     297                if (node.loc) {
     298                    comment.loc = node.loc;
     299                }
     300                this.comments.push(comment);
     301                if (this.attach) {
     302                    var entry = {
     303                        comment: {
     304                            type: type,
     305                            value: node.value,
     306                            range: [metadata.start.offset, metadata.end.offset]
     307                        },
     308                        start: metadata.start.offset
     309                    };
     310                    if (node.loc) {
     311                        entry.comment.loc = node.loc;
     312                    }
     313                    node.type = type;
     314                    this.leading.push(entry);
     315                    this.trailing.push(entry);
     316                }
     317            };
     318            CommentHandler.prototype.visit = function (node, metadata) {
     319                if (node.type === 'LineComment') {
     320                    this.visitComment(node, metadata);
     321                }
     322                else if (node.type === 'BlockComment') {
     323                    this.visitComment(node, metadata);
     324                }
     325                else if (this.attach) {
     326                    this.visitNode(node, metadata);
     327                }
     328            };
     329            return CommentHandler;
     330        }());
     331        exports.CommentHandler = CommentHandler;
     332
     333
     334/***/ },
     335/* 2 */
     336/***/ function(module, exports) {
     337
     338        "use strict";
     339        Object.defineProperty(exports, "__esModule", { value: true });
     340        exports.Syntax = {
     341            AssignmentExpression: 'AssignmentExpression',
     342            AssignmentPattern: 'AssignmentPattern',
     343            ArrayExpression: 'ArrayExpression',
     344            ArrayPattern: 'ArrayPattern',
     345            ArrowFunctionExpression: 'ArrowFunctionExpression',
     346            AwaitExpression: 'AwaitExpression',
     347            BlockStatement: 'BlockStatement',
     348            BinaryExpression: 'BinaryExpression',
     349            BreakStatement: 'BreakStatement',
     350            CallExpression: 'CallExpression',
     351            CatchClause: 'CatchClause',
     352            ClassBody: 'ClassBody',
     353            ClassDeclaration: 'ClassDeclaration',
     354            ClassExpression: 'ClassExpression',
     355            ConditionalExpression: 'ConditionalExpression',
     356            ContinueStatement: 'ContinueStatement',
     357            DoWhileStatement: 'DoWhileStatement',
     358            DebuggerStatement: 'DebuggerStatement',
     359            EmptyStatement: 'EmptyStatement',
     360            ExportAllDeclaration: 'ExportAllDeclaration',
     361            ExportDefaultDeclaration: 'ExportDefaultDeclaration',
     362            ExportNamedDeclaration: 'ExportNamedDeclaration',
     363            ExportSpecifier: 'ExportSpecifier',
     364            ExpressionStatement: 'ExpressionStatement',
     365            ForStatement: 'ForStatement',
     366            ForOfStatement: 'ForOfStatement',
     367            ForInStatement: 'ForInStatement',
     368            FunctionDeclaration: 'FunctionDeclaration',
     369            FunctionExpression: 'FunctionExpression',
     370            Identifier: 'Identifier',
     371            IfStatement: 'IfStatement',
     372            ImportDeclaration: 'ImportDeclaration',
     373            ImportDefaultSpecifier: 'ImportDefaultSpecifier',
     374            ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
     375            ImportSpecifier: 'ImportSpecifier',
     376            Literal: 'Literal',
     377            LabeledStatement: 'LabeledStatement',
     378            LogicalExpression: 'LogicalExpression',
     379            MemberExpression: 'MemberExpression',
     380            MetaProperty: 'MetaProperty',
     381            MethodDefinition: 'MethodDefinition',
     382            NewExpression: 'NewExpression',
     383            ObjectExpression: 'ObjectExpression',
     384            ObjectPattern: 'ObjectPattern',
     385            Program: 'Program',
     386            Property: 'Property',
     387            RestElement: 'RestElement',
     388            ReturnStatement: 'ReturnStatement',
     389            SequenceExpression: 'SequenceExpression',
     390            SpreadElement: 'SpreadElement',
     391            Super: 'Super',
     392            SwitchCase: 'SwitchCase',
     393            SwitchStatement: 'SwitchStatement',
     394            TaggedTemplateExpression: 'TaggedTemplateExpression',
     395            TemplateElement: 'TemplateElement',
     396            TemplateLiteral: 'TemplateLiteral',
     397            ThisExpression: 'ThisExpression',
     398            ThrowStatement: 'ThrowStatement',
     399            TryStatement: 'TryStatement',
     400            UnaryExpression: 'UnaryExpression',
     401            UpdateExpression: 'UpdateExpression',
     402            VariableDeclaration: 'VariableDeclaration',
     403            VariableDeclarator: 'VariableDeclarator',
     404            WhileStatement: 'WhileStatement',
     405            WithStatement: 'WithStatement',
     406            YieldExpression: 'YieldExpression'
     407        };
     408
     409
     410/***/ },
     411/* 3 */
     412/***/ function(module, exports, __webpack_require__) {
     413
     414        "use strict";
     415/* istanbul ignore next */
     416        var __extends = (this && this.__extends) || (function () {
     417            var extendStatics = Object.setPrototypeOf ||
     418                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
     419                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
     420            return function (d, b) {
     421                extendStatics(d, b);
     422                function __() { this.constructor = d; }
     423                d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     424            };
     425        })();
     426        Object.defineProperty(exports, "__esModule", { value: true });
     427        var character_1 = __webpack_require__(4);
     428        var JSXNode = __webpack_require__(5);
     429        var jsx_syntax_1 = __webpack_require__(6);
     430        var Node = __webpack_require__(7);
     431        var parser_1 = __webpack_require__(8);
     432        var token_1 = __webpack_require__(13);
     433        var xhtml_entities_1 = __webpack_require__(14);
     434        token_1.TokenName[100 /* Identifier */] = 'JSXIdentifier';
     435        token_1.TokenName[101 /* Text */] = 'JSXText';
     436        // Fully qualified element name, e.g. <svg:path> returns "svg:path"
     437        function getQualifiedElementName(elementName) {
     438            var qualifiedName;
     439            switch (elementName.type) {
     440                case jsx_syntax_1.JSXSyntax.JSXIdentifier:
     441                    var id = elementName;
     442                    qualifiedName = id.name;
     443                    break;
     444                case jsx_syntax_1.JSXSyntax.JSXNamespacedName:
     445                    var ns = elementName;
     446                    qualifiedName = getQualifiedElementName(ns.namespace) + ':' +
     447                        getQualifiedElementName(ns.name);
     448                    break;
     449                case jsx_syntax_1.JSXSyntax.JSXMemberExpression:
     450                    var expr = elementName;
     451                    qualifiedName = getQualifiedElementName(expr.object) + '.' +
     452                        getQualifiedElementName(expr.property);
     453                    break;
     454                /* istanbul ignore next */
     455                default:
     456                    break;
     457            }
     458            return qualifiedName;
     459        }
     460        var JSXParser = (function (_super) {
     461            __extends(JSXParser, _super);
     462            function JSXParser(code, options, delegate) {
     463                return _super.call(this, code, options, delegate) || this;
     464            }
     465            JSXParser.prototype.parsePrimaryExpression = function () {
     466                return this.match('<') ? this.parseJSXRoot() : _super.prototype.parsePrimaryExpression.call(this);
     467            };
     468            JSXParser.prototype.startJSX = function () {
     469                // Unwind the scanner before the lookahead token.
     470                this.scanner.index = this.startMarker.index;
     471                this.scanner.lineNumber = this.startMarker.line;
     472                this.scanner.lineStart = this.startMarker.index - this.startMarker.column;
     473            };
     474            JSXParser.prototype.finishJSX = function () {
     475                // Prime the next lookahead.
     476                this.nextToken();
     477            };
     478            JSXParser.prototype.reenterJSX = function () {
     479                this.startJSX();
     480                this.expectJSX('}');
     481                // Pop the closing '}' added from the lookahead.
     482                if (this.config.tokens) {
     483                    this.tokens.pop();
     484                }
     485            };
     486            JSXParser.prototype.createJSXNode = function () {
     487                this.collectComments();
     488                return {
     489                    index: this.scanner.index,
     490                    line: this.scanner.lineNumber,
     491                    column: this.scanner.index - this.scanner.lineStart
     492                };
     493            };
     494            JSXParser.prototype.createJSXChildNode = function () {
     495                return {
     496                    index: this.scanner.index,
     497                    line: this.scanner.lineNumber,
     498                    column: this.scanner.index - this.scanner.lineStart
     499                };
     500            };
     501            JSXParser.prototype.scanXHTMLEntity = function (quote) {
     502                var result = '&';
     503                var valid = true;
     504                var terminated = false;
     505                var numeric = false;
     506                var hex = false;
     507                while (!this.scanner.eof() && valid && !terminated) {
     508                    var ch = this.scanner.source[this.scanner.index];
     509                    if (ch === quote) {
     510                        break;
     511                    }
     512                    terminated = (ch === ';');
     513                    result += ch;
     514                    ++this.scanner.index;
     515                    if (!terminated) {
     516                        switch (result.length) {
     517                            case 2:
     518                                // e.g. '&#123;'
     519                                numeric = (ch === '#');
     520                                break;
     521                            case 3:
     522                                if (numeric) {
     523                                    // e.g. '&#x41;'
     524                                    hex = (ch === 'x');
     525                                    valid = hex || character_1.Character.isDecimalDigit(ch.charCodeAt(0));
     526                                    numeric = numeric && !hex;
     527                                }
     528                                break;
     529                            default:
     530                                valid = valid && !(numeric && !character_1.Character.isDecimalDigit(ch.charCodeAt(0)));
     531                                valid = valid && !(hex && !character_1.Character.isHexDigit(ch.charCodeAt(0)));
     532                                break;
     533                        }
     534                    }
     535                }
     536                if (valid && terminated && result.length > 2) {
     537                    // e.g. '&#x41;' becomes just '#x41'
     538                    var str = result.substr(1, result.length - 2);
     539                    if (numeric && str.length > 1) {
     540                        result = String.fromCharCode(parseInt(str.substr(1), 10));
     541                    }
     542                    else if (hex && str.length > 2) {
     543                        result = String.fromCharCode(parseInt('0' + str.substr(1), 16));
     544                    }
     545                    else if (!numeric && !hex && xhtml_entities_1.XHTMLEntities[str]) {
     546                        result = xhtml_entities_1.XHTMLEntities[str];
     547                    }
     548                }
     549                return result;
     550            };
     551            // Scan the next JSX token. This replaces Scanner#lex when in JSX mode.
     552            JSXParser.prototype.lexJSX = function () {
     553                var cp = this.scanner.source.charCodeAt(this.scanner.index);
     554                // < > / : = { }
     555                if (cp === 60 || cp === 62 || cp === 47 || cp === 58 || cp === 61 || cp === 123 || cp === 125) {
     556                    var value = this.scanner.source[this.scanner.index++];
     557                    return {
     558                        type: 7 /* Punctuator */,
     559                        value: value,
     560                        lineNumber: this.scanner.lineNumber,
     561                        lineStart: this.scanner.lineStart,
     562                        start: this.scanner.index - 1,
     563                        end: this.scanner.index
     564                    };
     565                }
     566                // " '
     567                if (cp === 34 || cp === 39) {
     568                    var start = this.scanner.index;
     569                    var quote = this.scanner.source[this.scanner.index++];
     570                    var str = '';
     571                    while (!this.scanner.eof()) {
     572                        var ch = this.scanner.source[this.scanner.index++];
     573                        if (ch === quote) {
     574                            break;
     575                        }
     576                        else if (ch === '&') {
     577                            str += this.scanXHTMLEntity(quote);
     578                        }
     579                        else {
     580                            str += ch;
     581                        }
     582                    }
     583                    return {
     584                        type: 8 /* StringLiteral */,
     585                        value: str,
     586                        lineNumber: this.scanner.lineNumber,
     587                        lineStart: this.scanner.lineStart,
     588                        start: start,
     589                        end: this.scanner.index
     590                    };
     591                }
     592                // ... or .
     593                if (cp === 46) {
     594                    var n1 = this.scanner.source.charCodeAt(this.scanner.index + 1);
     595                    var n2 = this.scanner.source.charCodeAt(this.scanner.index + 2);
     596                    var value = (n1 === 46 && n2 === 46) ? '...' : '.';
     597                    var start = this.scanner.index;
     598                    this.scanner.index += value.length;
     599                    return {
     600                        type: 7 /* Punctuator */,
     601                        value: value,
     602                        lineNumber: this.scanner.lineNumber,
     603                        lineStart: this.scanner.lineStart,
     604                        start: start,
     605                        end: this.scanner.index
     606                    };
     607                }
     608                // `
     609                if (cp === 96) {
     610                    // Only placeholder, since it will be rescanned as a real assignment expression.
     611                    return {
     612                        type: 10 /* Template */,
     613                        value: '',
     614                        lineNumber: this.scanner.lineNumber,
     615                        lineStart: this.scanner.lineStart,
     616                        start: this.scanner.index,
     617                        end: this.scanner.index
     618                    };
     619                }
     620                // Identifer can not contain backslash (char code 92).
     621                if (character_1.Character.isIdentifierStart(cp) && (cp !== 92)) {
     622                    var start = this.scanner.index;
     623                    ++this.scanner.index;
     624                    while (!this.scanner.eof()) {
     625                        var ch = this.scanner.source.charCodeAt(this.scanner.index);
     626                        if (character_1.Character.isIdentifierPart(ch) && (ch !== 92)) {
     627                            ++this.scanner.index;
     628                        }
     629                        else if (ch === 45) {
     630                            // Hyphen (char code 45) can be part of an identifier.
     631                            ++this.scanner.index;
     632                        }
     633                        else {
     634                            break;
     635                        }
     636                    }
     637                    var id = this.scanner.source.slice(start, this.scanner.index);
     638                    return {
     639                        type: 100 /* Identifier */,
     640                        value: id,
     641                        lineNumber: this.scanner.lineNumber,
     642                        lineStart: this.scanner.lineStart,
     643                        start: start,
     644                        end: this.scanner.index
     645                    };
     646                }
     647                return this.scanner.lex();
     648            };
     649            JSXParser.prototype.nextJSXToken = function () {
     650                this.collectComments();
     651                this.startMarker.index = this.scanner.index;
     652                this.startMarker.line = this.scanner.lineNumber;
     653                this.startMarker.column = this.scanner.index - this.scanner.lineStart;
     654                var token = this.lexJSX();
     655                this.lastMarker.index = this.scanner.index;
     656                this.lastMarker.line = this.scanner.lineNumber;
     657                this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
     658                if (this.config.tokens) {
     659                    this.tokens.push(this.convertToken(token));
     660                }
     661                return token;
     662            };
     663            JSXParser.prototype.nextJSXText = function () {
     664                this.startMarker.index = this.scanner.index;
     665                this.startMarker.line = this.scanner.lineNumber;
     666                this.startMarker.column = this.scanner.index - this.scanner.lineStart;
     667                var start = this.scanner.index;
     668                var text = '';
     669                while (!this.scanner.eof()) {
     670                    var ch = this.scanner.source[this.scanner.index];
     671                    if (ch === '{' || ch === '<') {
     672                        break;
     673                    }
     674                    ++this.scanner.index;
     675                    text += ch;
     676                    if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     677                        ++this.scanner.lineNumber;
     678                        if (ch === '\r' && this.scanner.source[this.scanner.index] === '\n') {
     679                            ++this.scanner.index;
     680                        }
     681                        this.scanner.lineStart = this.scanner.index;
     682                    }
     683                }
     684                this.lastMarker.index = this.scanner.index;
     685                this.lastMarker.line = this.scanner.lineNumber;
     686                this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
     687                var token = {
     688                    type: 101 /* Text */,
     689                    value: text,
     690                    lineNumber: this.scanner.lineNumber,
     691                    lineStart: this.scanner.lineStart,
     692                    start: start,
     693                    end: this.scanner.index
     694                };
     695                if ((text.length > 0) && this.config.tokens) {
     696                    this.tokens.push(this.convertToken(token));
     697                }
     698                return token;
     699            };
     700            JSXParser.prototype.peekJSXToken = function () {
     701                var state = this.scanner.saveState();
     702                this.scanner.scanComments();
     703                var next = this.lexJSX();
     704                this.scanner.restoreState(state);
     705                return next;
     706            };
     707            // Expect the next JSX token to match the specified punctuator.
     708            // If not, an exception will be thrown.
     709            JSXParser.prototype.expectJSX = function (value) {
     710                var token = this.nextJSXToken();
     711                if (token.type !== 7 /* Punctuator */ || token.value !== value) {
     712                    this.throwUnexpectedToken(token);
     713                }
     714            };
     715            // Return true if the next JSX token matches the specified punctuator.
     716            JSXParser.prototype.matchJSX = function (value) {
     717                var next = this.peekJSXToken();
     718                return next.type === 7 /* Punctuator */ && next.value === value;
     719            };
     720            JSXParser.prototype.parseJSXIdentifier = function () {
     721                var node = this.createJSXNode();
     722                var token = this.nextJSXToken();
     723                if (token.type !== 100 /* Identifier */) {
     724                    this.throwUnexpectedToken(token);
     725                }
     726                return this.finalize(node, new JSXNode.JSXIdentifier(token.value));
     727            };
     728            JSXParser.prototype.parseJSXElementName = function () {
     729                var node = this.createJSXNode();
     730                var elementName = this.parseJSXIdentifier();
     731                if (this.matchJSX(':')) {
     732                    var namespace = elementName;
     733                    this.expectJSX(':');
     734                    var name_1 = this.parseJSXIdentifier();
     735                    elementName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_1));
     736                }
     737                else if (this.matchJSX('.')) {
     738                    while (this.matchJSX('.')) {
     739                        var object = elementName;
     740                        this.expectJSX('.');
     741                        var property = this.parseJSXIdentifier();
     742                        elementName = this.finalize(node, new JSXNode.JSXMemberExpression(object, property));
     743                    }
     744                }
     745                return elementName;
     746            };
     747            JSXParser.prototype.parseJSXAttributeName = function () {
     748                var node = this.createJSXNode();
     749                var attributeName;
     750                var identifier = this.parseJSXIdentifier();
     751                if (this.matchJSX(':')) {
     752                    var namespace = identifier;
     753                    this.expectJSX(':');
     754                    var name_2 = this.parseJSXIdentifier();
     755                    attributeName = this.finalize(node, new JSXNode.JSXNamespacedName(namespace, name_2));
     756                }
     757                else {
     758                    attributeName = identifier;
     759                }
     760                return attributeName;
     761            };
     762            JSXParser.prototype.parseJSXStringLiteralAttribute = function () {
     763                var node = this.createJSXNode();
     764                var token = this.nextJSXToken();
     765                if (token.type !== 8 /* StringLiteral */) {
     766                    this.throwUnexpectedToken(token);
     767                }
     768                var raw = this.getTokenRaw(token);
     769                return this.finalize(node, new Node.Literal(token.value, raw));
     770            };
     771            JSXParser.prototype.parseJSXExpressionAttribute = function () {
     772                var node = this.createJSXNode();
     773                this.expectJSX('{');
     774                this.finishJSX();
     775                if (this.match('}')) {
     776                    this.tolerateError('JSX attributes must only be assigned a non-empty expression');
     777                }
     778                var expression = this.parseAssignmentExpression();
     779                this.reenterJSX();
     780                return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
     781            };
     782            JSXParser.prototype.parseJSXAttributeValue = function () {
     783                return this.matchJSX('{') ? this.parseJSXExpressionAttribute() :
     784                    this.matchJSX('<') ? this.parseJSXElement() : this.parseJSXStringLiteralAttribute();
     785            };
     786            JSXParser.prototype.parseJSXNameValueAttribute = function () {
     787                var node = this.createJSXNode();
     788                var name = this.parseJSXAttributeName();
     789                var value = null;
     790                if (this.matchJSX('=')) {
     791                    this.expectJSX('=');
     792                    value = this.parseJSXAttributeValue();
     793                }
     794                return this.finalize(node, new JSXNode.JSXAttribute(name, value));
     795            };
     796            JSXParser.prototype.parseJSXSpreadAttribute = function () {
     797                var node = this.createJSXNode();
     798                this.expectJSX('{');
     799                this.expectJSX('...');
     800                this.finishJSX();
     801                var argument = this.parseAssignmentExpression();
     802                this.reenterJSX();
     803                return this.finalize(node, new JSXNode.JSXSpreadAttribute(argument));
     804            };
     805            JSXParser.prototype.parseJSXAttributes = function () {
     806                var attributes = [];
     807                while (!this.matchJSX('/') && !this.matchJSX('>')) {
     808                    var attribute = this.matchJSX('{') ? this.parseJSXSpreadAttribute() :
     809                        this.parseJSXNameValueAttribute();
     810                    attributes.push(attribute);
     811                }
     812                return attributes;
     813            };
     814            JSXParser.prototype.parseJSXOpeningElement = function () {
     815                var node = this.createJSXNode();
     816                this.expectJSX('<');
     817                var name = this.parseJSXElementName();
     818                var attributes = this.parseJSXAttributes();
     819                var selfClosing = this.matchJSX('/');
     820                if (selfClosing) {
     821                    this.expectJSX('/');
     822                }
     823                this.expectJSX('>');
     824                return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
     825            };
     826            JSXParser.prototype.parseJSXBoundaryElement = function () {
     827                var node = this.createJSXNode();
     828                this.expectJSX('<');
     829                if (this.matchJSX('/')) {
     830                    this.expectJSX('/');
     831                    var name_3 = this.parseJSXElementName();
     832                    this.expectJSX('>');
     833                    return this.finalize(node, new JSXNode.JSXClosingElement(name_3));
     834                }
     835                var name = this.parseJSXElementName();
     836                var attributes = this.parseJSXAttributes();
     837                var selfClosing = this.matchJSX('/');
     838                if (selfClosing) {
     839                    this.expectJSX('/');
     840                }
     841                this.expectJSX('>');
     842                return this.finalize(node, new JSXNode.JSXOpeningElement(name, selfClosing, attributes));
     843            };
     844            JSXParser.prototype.parseJSXEmptyExpression = function () {
     845                var node = this.createJSXChildNode();
     846                this.collectComments();
     847                this.lastMarker.index = this.scanner.index;
     848                this.lastMarker.line = this.scanner.lineNumber;
     849                this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
     850                return this.finalize(node, new JSXNode.JSXEmptyExpression());
     851            };
     852            JSXParser.prototype.parseJSXExpressionContainer = function () {
     853                var node = this.createJSXNode();
     854                this.expectJSX('{');
     855                var expression;
     856                if (this.matchJSX('}')) {
     857                    expression = this.parseJSXEmptyExpression();
     858                    this.expectJSX('}');
     859                }
     860                else {
     861                    this.finishJSX();
     862                    expression = this.parseAssignmentExpression();
     863                    this.reenterJSX();
     864                }
     865                return this.finalize(node, new JSXNode.JSXExpressionContainer(expression));
     866            };
     867            JSXParser.prototype.parseJSXChildren = function () {
     868                var children = [];
     869                while (!this.scanner.eof()) {
     870                    var node = this.createJSXChildNode();
     871                    var token = this.nextJSXText();
     872                    if (token.start < token.end) {
     873                        var raw = this.getTokenRaw(token);
     874                        var child = this.finalize(node, new JSXNode.JSXText(token.value, raw));
     875                        children.push(child);
     876                    }
     877                    if (this.scanner.source[this.scanner.index] === '{') {
     878                        var container = this.parseJSXExpressionContainer();
     879                        children.push(container);
     880                    }
     881                    else {
     882                        break;
     883                    }
     884                }
     885                return children;
     886            };
     887            JSXParser.prototype.parseComplexJSXElement = function (el) {
     888                var stack = [];
     889                while (!this.scanner.eof()) {
     890                    el.children = el.children.concat(this.parseJSXChildren());
     891                    var node = this.createJSXChildNode();
     892                    var element = this.parseJSXBoundaryElement();
     893                    if (element.type === jsx_syntax_1.JSXSyntax.JSXOpeningElement) {
     894                        var opening = element;
     895                        if (opening.selfClosing) {
     896                            var child = this.finalize(node, new JSXNode.JSXElement(opening, [], null));
     897                            el.children.push(child);
     898                        }
     899                        else {
     900                            stack.push(el);
     901                            el = { node: node, opening: opening, closing: null, children: [] };
     902                        }
     903                    }
     904                    if (element.type === jsx_syntax_1.JSXSyntax.JSXClosingElement) {
     905                        el.closing = element;
     906                        var open_1 = getQualifiedElementName(el.opening.name);
     907                        var close_1 = getQualifiedElementName(el.closing.name);
     908                        if (open_1 !== close_1) {
     909                            this.tolerateError('Expected corresponding JSX closing tag for %0', open_1);
     910                        }
     911                        if (stack.length > 0) {
     912                            var child = this.finalize(el.node, new JSXNode.JSXElement(el.opening, el.children, el.closing));
     913                            el = stack[stack.length - 1];
     914                            el.children.push(child);
     915                            stack.pop();
     916                        }
     917                        else {
     918                            break;
     919                        }
     920                    }
     921                }
     922                return el;
     923            };
     924            JSXParser.prototype.parseJSXElement = function () {
     925                var node = this.createJSXNode();
     926                var opening = this.parseJSXOpeningElement();
     927                var children = [];
     928                var closing = null;
     929                if (!opening.selfClosing) {
     930                    var el = this.parseComplexJSXElement({ node: node, opening: opening, closing: closing, children: children });
     931                    children = el.children;
     932                    closing = el.closing;
     933                }
     934                return this.finalize(node, new JSXNode.JSXElement(opening, children, closing));
     935            };
     936            JSXParser.prototype.parseJSXRoot = function () {
     937                // Pop the opening '<' added from the lookahead.
     938                if (this.config.tokens) {
     939                    this.tokens.pop();
     940                }
     941                this.startJSX();
     942                var element = this.parseJSXElement();
     943                this.finishJSX();
     944                return element;
     945            };
     946            JSXParser.prototype.isStartOfExpression = function () {
     947                return _super.prototype.isStartOfExpression.call(this) || this.match('<');
     948            };
     949            return JSXParser;
     950        }(parser_1.Parser));
     951        exports.JSXParser = JSXParser;
     952
     953
     954/***/ },
     955/* 4 */
     956/***/ function(module, exports) {
     957
     958        "use strict";
     959        Object.defineProperty(exports, "__esModule", { value: true });
     960        // See also tools/generate-unicode-regex.js.
     961        var Regex = {
     962            // Unicode v8.0.0 NonAsciiIdentifierStart:
     963            NonAsciiIdentifierStart: /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]/,
     964            // Unicode v8.0.0 NonAsciiIdentifierPart:
     965            NonAsciiIdentifierPart: /[\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF30-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDEC0-\uDEF8]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F]|\uD82C[\uDC00\uDC01]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
     966        };
     967        exports.Character = {
     968            /* tslint:disable:no-bitwise */
     969            fromCodePoint: function (cp) {
     970                return (cp < 0x10000) ? String.fromCharCode(cp) :
     971                    String.fromCharCode(0xD800 + ((cp - 0x10000) >> 10)) +
     972                        String.fromCharCode(0xDC00 + ((cp - 0x10000) & 1023));
     973            },
     974            // https://tc39.github.io/ecma262/#sec-white-space
     975            isWhiteSpace: function (cp) {
     976                return (cp === 0x20) || (cp === 0x09) || (cp === 0x0B) || (cp === 0x0C) || (cp === 0xA0) ||
     977                    (cp >= 0x1680 && [0x1680, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(cp) >= 0);
     978            },
     979            // https://tc39.github.io/ecma262/#sec-line-terminators
     980            isLineTerminator: function (cp) {
     981                return (cp === 0x0A) || (cp === 0x0D) || (cp === 0x2028) || (cp === 0x2029);
     982            },
     983            // https://tc39.github.io/ecma262/#sec-names-and-keywords
     984            isIdentifierStart: function (cp) {
     985                return (cp === 0x24) || (cp === 0x5F) ||
     986                    (cp >= 0x41 && cp <= 0x5A) ||
     987                    (cp >= 0x61 && cp <= 0x7A) ||
     988                    (cp === 0x5C) ||
     989                    ((cp >= 0x80) && Regex.NonAsciiIdentifierStart.test(exports.Character.fromCodePoint(cp)));
     990            },
     991            isIdentifierPart: function (cp) {
     992                return (cp === 0x24) || (cp === 0x5F) ||
     993                    (cp >= 0x41 && cp <= 0x5A) ||
     994                    (cp >= 0x61 && cp <= 0x7A) ||
     995                    (cp >= 0x30 && cp <= 0x39) ||
     996                    (cp === 0x5C) ||
     997                    ((cp >= 0x80) && Regex.NonAsciiIdentifierPart.test(exports.Character.fromCodePoint(cp)));
     998            },
     999            // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
     1000            isDecimalDigit: function (cp) {
     1001                return (cp >= 0x30 && cp <= 0x39); // 0..9
     1002            },
     1003            isHexDigit: function (cp) {
     1004                return (cp >= 0x30 && cp <= 0x39) ||
     1005                    (cp >= 0x41 && cp <= 0x46) ||
     1006                    (cp >= 0x61 && cp <= 0x66); // a..f
     1007            },
     1008            isOctalDigit: function (cp) {
     1009                return (cp >= 0x30 && cp <= 0x37); // 0..7
     1010            }
     1011        };
     1012
     1013
     1014/***/ },
     1015/* 5 */
     1016/***/ function(module, exports, __webpack_require__) {
     1017
     1018        "use strict";
     1019        Object.defineProperty(exports, "__esModule", { value: true });
     1020        var jsx_syntax_1 = __webpack_require__(6);
     1021        /* tslint:disable:max-classes-per-file */
     1022        var JSXClosingElement = (function () {
     1023            function JSXClosingElement(name) {
     1024                this.type = jsx_syntax_1.JSXSyntax.JSXClosingElement;
     1025                this.name = name;
     1026            }
     1027            return JSXClosingElement;
     1028        }());
     1029        exports.JSXClosingElement = JSXClosingElement;
     1030        var JSXElement = (function () {
     1031            function JSXElement(openingElement, children, closingElement) {
     1032                this.type = jsx_syntax_1.JSXSyntax.JSXElement;
     1033                this.openingElement = openingElement;
     1034                this.children = children;
     1035                this.closingElement = closingElement;
     1036            }
     1037            return JSXElement;
     1038        }());
     1039        exports.JSXElement = JSXElement;
     1040        var JSXEmptyExpression = (function () {
     1041            function JSXEmptyExpression() {
     1042                this.type = jsx_syntax_1.JSXSyntax.JSXEmptyExpression;
     1043            }
     1044            return JSXEmptyExpression;
     1045        }());
     1046        exports.JSXEmptyExpression = JSXEmptyExpression;
     1047        var JSXExpressionContainer = (function () {
     1048            function JSXExpressionContainer(expression) {
     1049                this.type = jsx_syntax_1.JSXSyntax.JSXExpressionContainer;
     1050                this.expression = expression;
     1051            }
     1052            return JSXExpressionContainer;
     1053        }());
     1054        exports.JSXExpressionContainer = JSXExpressionContainer;
     1055        var JSXIdentifier = (function () {
     1056            function JSXIdentifier(name) {
     1057                this.type = jsx_syntax_1.JSXSyntax.JSXIdentifier;
     1058                this.name = name;
     1059            }
     1060            return JSXIdentifier;
     1061        }());
     1062        exports.JSXIdentifier = JSXIdentifier;
     1063        var JSXMemberExpression = (function () {
     1064            function JSXMemberExpression(object, property) {
     1065                this.type = jsx_syntax_1.JSXSyntax.JSXMemberExpression;
     1066                this.object = object;
     1067                this.property = property;
     1068            }
     1069            return JSXMemberExpression;
     1070        }());
     1071        exports.JSXMemberExpression = JSXMemberExpression;
     1072        var JSXAttribute = (function () {
     1073            function JSXAttribute(name, value) {
     1074                this.type = jsx_syntax_1.JSXSyntax.JSXAttribute;
     1075                this.name = name;
     1076                this.value = value;
     1077            }
     1078            return JSXAttribute;
     1079        }());
     1080        exports.JSXAttribute = JSXAttribute;
     1081        var JSXNamespacedName = (function () {
     1082            function JSXNamespacedName(namespace, name) {
     1083                this.type = jsx_syntax_1.JSXSyntax.JSXNamespacedName;
     1084                this.namespace = namespace;
     1085                this.name = name;
     1086            }
     1087            return JSXNamespacedName;
     1088        }());
     1089        exports.JSXNamespacedName = JSXNamespacedName;
     1090        var JSXOpeningElement = (function () {
     1091            function JSXOpeningElement(name, selfClosing, attributes) {
     1092                this.type = jsx_syntax_1.JSXSyntax.JSXOpeningElement;
     1093                this.name = name;
     1094                this.selfClosing = selfClosing;
     1095                this.attributes = attributes;
     1096            }
     1097            return JSXOpeningElement;
     1098        }());
     1099        exports.JSXOpeningElement = JSXOpeningElement;
     1100        var JSXSpreadAttribute = (function () {
     1101            function JSXSpreadAttribute(argument) {
     1102                this.type = jsx_syntax_1.JSXSyntax.JSXSpreadAttribute;
     1103                this.argument = argument;
     1104            }
     1105            return JSXSpreadAttribute;
     1106        }());
     1107        exports.JSXSpreadAttribute = JSXSpreadAttribute;
     1108        var JSXText = (function () {
     1109            function JSXText(value, raw) {
     1110                this.type = jsx_syntax_1.JSXSyntax.JSXText;
     1111                this.value = value;
     1112                this.raw = raw;
     1113            }
     1114            return JSXText;
     1115        }());
     1116        exports.JSXText = JSXText;
     1117
     1118
     1119/***/ },
     1120/* 6 */
     1121/***/ function(module, exports) {
     1122
     1123        "use strict";
     1124        Object.defineProperty(exports, "__esModule", { value: true });
     1125        exports.JSXSyntax = {
     1126            JSXAttribute: 'JSXAttribute',
     1127            JSXClosingElement: 'JSXClosingElement',
     1128            JSXElement: 'JSXElement',
     1129            JSXEmptyExpression: 'JSXEmptyExpression',
     1130            JSXExpressionContainer: 'JSXExpressionContainer',
     1131            JSXIdentifier: 'JSXIdentifier',
     1132            JSXMemberExpression: 'JSXMemberExpression',
     1133            JSXNamespacedName: 'JSXNamespacedName',
     1134            JSXOpeningElement: 'JSXOpeningElement',
     1135            JSXSpreadAttribute: 'JSXSpreadAttribute',
     1136            JSXText: 'JSXText'
     1137        };
     1138
     1139
     1140/***/ },
     1141/* 7 */
     1142/***/ function(module, exports, __webpack_require__) {
     1143
     1144        "use strict";
     1145        Object.defineProperty(exports, "__esModule", { value: true });
     1146        var syntax_1 = __webpack_require__(2);
     1147        /* tslint:disable:max-classes-per-file */
     1148        var ArrayExpression = (function () {
     1149            function ArrayExpression(elements) {
     1150                this.type = syntax_1.Syntax.ArrayExpression;
     1151                this.elements = elements;
     1152            }
     1153            return ArrayExpression;
     1154        }());
     1155        exports.ArrayExpression = ArrayExpression;
     1156        var ArrayPattern = (function () {
     1157            function ArrayPattern(elements) {
     1158                this.type = syntax_1.Syntax.ArrayPattern;
     1159                this.elements = elements;
     1160            }
     1161            return ArrayPattern;
     1162        }());
     1163        exports.ArrayPattern = ArrayPattern;
     1164        var ArrowFunctionExpression = (function () {
     1165            function ArrowFunctionExpression(params, body, expression) {
     1166                this.type = syntax_1.Syntax.ArrowFunctionExpression;
     1167                this.id = null;
     1168                this.params = params;
     1169                this.body = body;
     1170                this.generator = false;
     1171                this.expression = expression;
     1172                this.async = false;
     1173            }
     1174            return ArrowFunctionExpression;
     1175        }());
     1176        exports.ArrowFunctionExpression = ArrowFunctionExpression;
     1177        var AssignmentExpression = (function () {
     1178            function AssignmentExpression(operator, left, right) {
     1179                this.type = syntax_1.Syntax.AssignmentExpression;
     1180                this.operator = operator;
     1181                this.left = left;
     1182                this.right = right;
     1183            }
     1184            return AssignmentExpression;
     1185        }());
     1186        exports.AssignmentExpression = AssignmentExpression;
     1187        var AssignmentPattern = (function () {
     1188            function AssignmentPattern(left, right) {
     1189                this.type = syntax_1.Syntax.AssignmentPattern;
     1190                this.left = left;
     1191                this.right = right;
     1192            }
     1193            return AssignmentPattern;
     1194        }());
     1195        exports.AssignmentPattern = AssignmentPattern;
     1196        var AsyncArrowFunctionExpression = (function () {
     1197            function AsyncArrowFunctionExpression(params, body, expression) {
     1198                this.type = syntax_1.Syntax.ArrowFunctionExpression;
     1199                this.id = null;
     1200                this.params = params;
     1201                this.body = body;
     1202                this.generator = false;
     1203                this.expression = expression;
     1204                this.async = true;
     1205            }
     1206            return AsyncArrowFunctionExpression;
     1207        }());
     1208        exports.AsyncArrowFunctionExpression = AsyncArrowFunctionExpression;
     1209        var AsyncFunctionDeclaration = (function () {
     1210            function AsyncFunctionDeclaration(id, params, body) {
     1211                this.type = syntax_1.Syntax.FunctionDeclaration;
     1212                this.id = id;
     1213                this.params = params;
     1214                this.body = body;
     1215                this.generator = false;
     1216                this.expression = false;
     1217                this.async = true;
     1218            }
     1219            return AsyncFunctionDeclaration;
     1220        }());
     1221        exports.AsyncFunctionDeclaration = AsyncFunctionDeclaration;
     1222        var AsyncFunctionExpression = (function () {
     1223            function AsyncFunctionExpression(id, params, body) {
     1224                this.type = syntax_1.Syntax.FunctionExpression;
     1225                this.id = id;
     1226                this.params = params;
     1227                this.body = body;
     1228                this.generator = false;
     1229                this.expression = false;
     1230                this.async = true;
     1231            }
     1232            return AsyncFunctionExpression;
     1233        }());
     1234        exports.AsyncFunctionExpression = AsyncFunctionExpression;
     1235        var AwaitExpression = (function () {
     1236            function AwaitExpression(argument) {
     1237                this.type = syntax_1.Syntax.AwaitExpression;
     1238                this.argument = argument;
     1239            }
     1240            return AwaitExpression;
     1241        }());
     1242        exports.AwaitExpression = AwaitExpression;
     1243        var BinaryExpression = (function () {
     1244            function BinaryExpression(operator, left, right) {
     1245                var logical = (operator === '||' || operator === '&&');
     1246                this.type = logical ? syntax_1.Syntax.LogicalExpression : syntax_1.Syntax.BinaryExpression;
     1247                this.operator = operator;
     1248                this.left = left;
     1249                this.right = right;
     1250            }
     1251            return BinaryExpression;
     1252        }());
     1253        exports.BinaryExpression = BinaryExpression;
     1254        var BlockStatement = (function () {
     1255            function BlockStatement(body) {
     1256                this.type = syntax_1.Syntax.BlockStatement;
     1257                this.body = body;
     1258            }
     1259            return BlockStatement;
     1260        }());
     1261        exports.BlockStatement = BlockStatement;
     1262        var BreakStatement = (function () {
     1263            function BreakStatement(label) {
     1264                this.type = syntax_1.Syntax.BreakStatement;
     1265                this.label = label;
     1266            }
     1267            return BreakStatement;
     1268        }());
     1269        exports.BreakStatement = BreakStatement;
     1270        var CallExpression = (function () {
     1271            function CallExpression(callee, args) {
     1272                this.type = syntax_1.Syntax.CallExpression;
     1273                this.callee = callee;
     1274                this.arguments = args;
     1275            }
     1276            return CallExpression;
     1277        }());
     1278        exports.CallExpression = CallExpression;
     1279        var CatchClause = (function () {
     1280            function CatchClause(param, body) {
     1281                this.type = syntax_1.Syntax.CatchClause;
     1282                this.param = param;
     1283                this.body = body;
     1284            }
     1285            return CatchClause;
     1286        }());
     1287        exports.CatchClause = CatchClause;
     1288        var ClassBody = (function () {
     1289            function ClassBody(body) {
     1290                this.type = syntax_1.Syntax.ClassBody;
     1291                this.body = body;
     1292            }
     1293            return ClassBody;
     1294        }());
     1295        exports.ClassBody = ClassBody;
     1296        var ClassDeclaration = (function () {
     1297            function ClassDeclaration(id, superClass, body) {
     1298                this.type = syntax_1.Syntax.ClassDeclaration;
     1299                this.id = id;
     1300                this.superClass = superClass;
     1301                this.body = body;
     1302            }
     1303            return ClassDeclaration;
     1304        }());
     1305        exports.ClassDeclaration = ClassDeclaration;
     1306        var ClassExpression = (function () {
     1307            function ClassExpression(id, superClass, body) {
     1308                this.type = syntax_1.Syntax.ClassExpression;
     1309                this.id = id;
     1310                this.superClass = superClass;
     1311                this.body = body;
     1312            }
     1313            return ClassExpression;
     1314        }());
     1315        exports.ClassExpression = ClassExpression;
     1316        var ComputedMemberExpression = (function () {
     1317            function ComputedMemberExpression(object, property) {
     1318                this.type = syntax_1.Syntax.MemberExpression;
     1319                this.computed = true;
     1320                this.object = object;
     1321                this.property = property;
     1322            }
     1323            return ComputedMemberExpression;
     1324        }());
     1325        exports.ComputedMemberExpression = ComputedMemberExpression;
     1326        var ConditionalExpression = (function () {
     1327            function ConditionalExpression(test, consequent, alternate) {
     1328                this.type = syntax_1.Syntax.ConditionalExpression;
     1329                this.test = test;
     1330                this.consequent = consequent;
     1331                this.alternate = alternate;
     1332            }
     1333            return ConditionalExpression;
     1334        }());
     1335        exports.ConditionalExpression = ConditionalExpression;
     1336        var ContinueStatement = (function () {
     1337            function ContinueStatement(label) {
     1338                this.type = syntax_1.Syntax.ContinueStatement;
     1339                this.label = label;
     1340            }
     1341            return ContinueStatement;
     1342        }());
     1343        exports.ContinueStatement = ContinueStatement;
     1344        var DebuggerStatement = (function () {
     1345            function DebuggerStatement() {
     1346                this.type = syntax_1.Syntax.DebuggerStatement;
     1347            }
     1348            return DebuggerStatement;
     1349        }());
     1350        exports.DebuggerStatement = DebuggerStatement;
     1351        var Directive = (function () {
     1352            function Directive(expression, directive) {
     1353                this.type = syntax_1.Syntax.ExpressionStatement;
     1354                this.expression = expression;
     1355                this.directive = directive;
     1356            }
     1357            return Directive;
     1358        }());
     1359        exports.Directive = Directive;
     1360        var DoWhileStatement = (function () {
     1361            function DoWhileStatement(body, test) {
     1362                this.type = syntax_1.Syntax.DoWhileStatement;
     1363                this.body = body;
     1364                this.test = test;
     1365            }
     1366            return DoWhileStatement;
     1367        }());
     1368        exports.DoWhileStatement = DoWhileStatement;
     1369        var EmptyStatement = (function () {
     1370            function EmptyStatement() {
     1371                this.type = syntax_1.Syntax.EmptyStatement;
     1372            }
     1373            return EmptyStatement;
     1374        }());
     1375        exports.EmptyStatement = EmptyStatement;
     1376        var ExportAllDeclaration = (function () {
     1377            function ExportAllDeclaration(source) {
     1378                this.type = syntax_1.Syntax.ExportAllDeclaration;
     1379                this.source = source;
     1380            }
     1381            return ExportAllDeclaration;
     1382        }());
     1383        exports.ExportAllDeclaration = ExportAllDeclaration;
     1384        var ExportDefaultDeclaration = (function () {
     1385            function ExportDefaultDeclaration(declaration) {
     1386                this.type = syntax_1.Syntax.ExportDefaultDeclaration;
     1387                this.declaration = declaration;
     1388            }
     1389            return ExportDefaultDeclaration;
     1390        }());
     1391        exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
     1392        var ExportNamedDeclaration = (function () {
     1393            function ExportNamedDeclaration(declaration, specifiers, source) {
     1394                this.type = syntax_1.Syntax.ExportNamedDeclaration;
     1395                this.declaration = declaration;
     1396                this.specifiers = specifiers;
     1397                this.source = source;
     1398            }
     1399            return ExportNamedDeclaration;
     1400        }());
     1401        exports.ExportNamedDeclaration = ExportNamedDeclaration;
     1402        var ExportSpecifier = (function () {
     1403            function ExportSpecifier(local, exported) {
     1404                this.type = syntax_1.Syntax.ExportSpecifier;
     1405                this.exported = exported;
     1406                this.local = local;
     1407            }
     1408            return ExportSpecifier;
     1409        }());
     1410        exports.ExportSpecifier = ExportSpecifier;
     1411        var ExpressionStatement = (function () {
     1412            function ExpressionStatement(expression) {
     1413                this.type = syntax_1.Syntax.ExpressionStatement;
     1414                this.expression = expression;
     1415            }
     1416            return ExpressionStatement;
     1417        }());
     1418        exports.ExpressionStatement = ExpressionStatement;
     1419        var ForInStatement = (function () {
     1420            function ForInStatement(left, right, body) {
     1421                this.type = syntax_1.Syntax.ForInStatement;
     1422                this.left = left;
     1423                this.right = right;
     1424                this.body = body;
     1425                this.each = false;
     1426            }
     1427            return ForInStatement;
     1428        }());
     1429        exports.ForInStatement = ForInStatement;
     1430        var ForOfStatement = (function () {
     1431            function ForOfStatement(left, right, body) {
     1432                this.type = syntax_1.Syntax.ForOfStatement;
     1433                this.left = left;
     1434                this.right = right;
     1435                this.body = body;
     1436            }
     1437            return ForOfStatement;
     1438        }());
     1439        exports.ForOfStatement = ForOfStatement;
     1440        var ForStatement = (function () {
     1441            function ForStatement(init, test, update, body) {
     1442                this.type = syntax_1.Syntax.ForStatement;
     1443                this.init = init;
     1444                this.test = test;
     1445                this.update = update;
     1446                this.body = body;
     1447            }
     1448            return ForStatement;
     1449        }());
     1450        exports.ForStatement = ForStatement;
     1451        var FunctionDeclaration = (function () {
     1452            function FunctionDeclaration(id, params, body, generator) {
     1453                this.type = syntax_1.Syntax.FunctionDeclaration;
     1454                this.id = id;
     1455                this.params = params;
     1456                this.body = body;
     1457                this.generator = generator;
     1458                this.expression = false;
     1459                this.async = false;
     1460            }
     1461            return FunctionDeclaration;
     1462        }());
     1463        exports.FunctionDeclaration = FunctionDeclaration;
     1464        var FunctionExpression = (function () {
     1465            function FunctionExpression(id, params, body, generator) {
     1466                this.type = syntax_1.Syntax.FunctionExpression;
     1467                this.id = id;
     1468                this.params = params;
     1469                this.body = body;
     1470                this.generator = generator;
     1471                this.expression = false;
     1472                this.async = false;
     1473            }
     1474            return FunctionExpression;
     1475        }());
     1476        exports.FunctionExpression = FunctionExpression;
     1477        var Identifier = (function () {
     1478            function Identifier(name) {
     1479                this.type = syntax_1.Syntax.Identifier;
     1480                this.name = name;
     1481            }
     1482            return Identifier;
     1483        }());
     1484        exports.Identifier = Identifier;
     1485        var IfStatement = (function () {
     1486            function IfStatement(test, consequent, alternate) {
     1487                this.type = syntax_1.Syntax.IfStatement;
     1488                this.test = test;
     1489                this.consequent = consequent;
     1490                this.alternate = alternate;
     1491            }
     1492            return IfStatement;
     1493        }());
     1494        exports.IfStatement = IfStatement;
     1495        var ImportDeclaration = (function () {
     1496            function ImportDeclaration(specifiers, source) {
     1497                this.type = syntax_1.Syntax.ImportDeclaration;
     1498                this.specifiers = specifiers;
     1499                this.source = source;
     1500            }
     1501            return ImportDeclaration;
     1502        }());
     1503        exports.ImportDeclaration = ImportDeclaration;
     1504        var ImportDefaultSpecifier = (function () {
     1505            function ImportDefaultSpecifier(local) {
     1506                this.type = syntax_1.Syntax.ImportDefaultSpecifier;
     1507                this.local = local;
     1508            }
     1509            return ImportDefaultSpecifier;
     1510        }());
     1511        exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
     1512        var ImportNamespaceSpecifier = (function () {
     1513            function ImportNamespaceSpecifier(local) {
     1514                this.type = syntax_1.Syntax.ImportNamespaceSpecifier;
     1515                this.local = local;
     1516            }
     1517            return ImportNamespaceSpecifier;
     1518        }());
     1519        exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
     1520        var ImportSpecifier = (function () {
     1521            function ImportSpecifier(local, imported) {
     1522                this.type = syntax_1.Syntax.ImportSpecifier;
     1523                this.local = local;
     1524                this.imported = imported;
     1525            }
     1526            return ImportSpecifier;
     1527        }());
     1528        exports.ImportSpecifier = ImportSpecifier;
     1529        var LabeledStatement = (function () {
     1530            function LabeledStatement(label, body) {
     1531                this.type = syntax_1.Syntax.LabeledStatement;
     1532                this.label = label;
     1533                this.body = body;
     1534            }
     1535            return LabeledStatement;
     1536        }());
     1537        exports.LabeledStatement = LabeledStatement;
     1538        var Literal = (function () {
     1539            function Literal(value, raw) {
     1540                this.type = syntax_1.Syntax.Literal;
     1541                this.value = value;
     1542                this.raw = raw;
     1543            }
     1544            return Literal;
     1545        }());
     1546        exports.Literal = Literal;
     1547        var MetaProperty = (function () {
     1548            function MetaProperty(meta, property) {
     1549                this.type = syntax_1.Syntax.MetaProperty;
     1550                this.meta = meta;
     1551                this.property = property;
     1552            }
     1553            return MetaProperty;
     1554        }());
     1555        exports.MetaProperty = MetaProperty;
     1556        var MethodDefinition = (function () {
     1557            function MethodDefinition(key, computed, value, kind, isStatic) {
     1558                this.type = syntax_1.Syntax.MethodDefinition;
     1559                this.key = key;
     1560                this.computed = computed;
     1561                this.value = value;
     1562                this.kind = kind;
     1563                this.static = isStatic;
     1564            }
     1565            return MethodDefinition;
     1566        }());
     1567        exports.MethodDefinition = MethodDefinition;
     1568        var Module = (function () {
     1569            function Module(body) {
     1570                this.type = syntax_1.Syntax.Program;
     1571                this.body = body;
     1572                this.sourceType = 'module';
     1573            }
     1574            return Module;
     1575        }());
     1576        exports.Module = Module;
     1577        var NewExpression = (function () {
     1578            function NewExpression(callee, args) {
     1579                this.type = syntax_1.Syntax.NewExpression;
     1580                this.callee = callee;
     1581                this.arguments = args;
     1582            }
     1583            return NewExpression;
     1584        }());
     1585        exports.NewExpression = NewExpression;
     1586        var ObjectExpression = (function () {
     1587            function ObjectExpression(properties) {
     1588                this.type = syntax_1.Syntax.ObjectExpression;
     1589                this.properties = properties;
     1590            }
     1591            return ObjectExpression;
     1592        }());
     1593        exports.ObjectExpression = ObjectExpression;
     1594        var ObjectPattern = (function () {
     1595            function ObjectPattern(properties) {
     1596                this.type = syntax_1.Syntax.ObjectPattern;
     1597                this.properties = properties;
     1598            }
     1599            return ObjectPattern;
     1600        }());
     1601        exports.ObjectPattern = ObjectPattern;
     1602        var Property = (function () {
     1603            function Property(kind, key, computed, value, method, shorthand) {
     1604                this.type = syntax_1.Syntax.Property;
     1605                this.key = key;
     1606                this.computed = computed;
     1607                this.value = value;
     1608                this.kind = kind;
     1609                this.method = method;
     1610                this.shorthand = shorthand;
     1611            }
     1612            return Property;
     1613        }());
     1614        exports.Property = Property;
     1615        var RegexLiteral = (function () {
     1616            function RegexLiteral(value, raw, pattern, flags) {
     1617                this.type = syntax_1.Syntax.Literal;
     1618                this.value = value;
     1619                this.raw = raw;
     1620                this.regex = { pattern: pattern, flags: flags };
     1621            }
     1622            return RegexLiteral;
     1623        }());
     1624        exports.RegexLiteral = RegexLiteral;
     1625        var RestElement = (function () {
     1626            function RestElement(argument) {
     1627                this.type = syntax_1.Syntax.RestElement;
     1628                this.argument = argument;
     1629            }
     1630            return RestElement;
     1631        }());
     1632        exports.RestElement = RestElement;
     1633        var ReturnStatement = (function () {
     1634            function ReturnStatement(argument) {
     1635                this.type = syntax_1.Syntax.ReturnStatement;
     1636                this.argument = argument;
     1637            }
     1638            return ReturnStatement;
     1639        }());
     1640        exports.ReturnStatement = ReturnStatement;
     1641        var Script = (function () {
     1642            function Script(body) {
     1643                this.type = syntax_1.Syntax.Program;
     1644                this.body = body;
     1645                this.sourceType = 'script';
     1646            }
     1647            return Script;
     1648        }());
     1649        exports.Script = Script;
     1650        var SequenceExpression = (function () {
     1651            function SequenceExpression(expressions) {
     1652                this.type = syntax_1.Syntax.SequenceExpression;
     1653                this.expressions = expressions;
     1654            }
     1655            return SequenceExpression;
     1656        }());
     1657        exports.SequenceExpression = SequenceExpression;
     1658        var SpreadElement = (function () {
     1659            function SpreadElement(argument) {
     1660                this.type = syntax_1.Syntax.SpreadElement;
     1661                this.argument = argument;
     1662            }
     1663            return SpreadElement;
     1664        }());
     1665        exports.SpreadElement = SpreadElement;
     1666        var StaticMemberExpression = (function () {
     1667            function StaticMemberExpression(object, property) {
     1668                this.type = syntax_1.Syntax.MemberExpression;
     1669                this.computed = false;
     1670                this.object = object;
     1671                this.property = property;
     1672            }
     1673            return StaticMemberExpression;
     1674        }());
     1675        exports.StaticMemberExpression = StaticMemberExpression;
     1676        var Super = (function () {
     1677            function Super() {
     1678                this.type = syntax_1.Syntax.Super;
     1679            }
     1680            return Super;
     1681        }());
     1682        exports.Super = Super;
     1683        var SwitchCase = (function () {
     1684            function SwitchCase(test, consequent) {
     1685                this.type = syntax_1.Syntax.SwitchCase;
     1686                this.test = test;
     1687                this.consequent = consequent;
     1688            }
     1689            return SwitchCase;
     1690        }());
     1691        exports.SwitchCase = SwitchCase;
     1692        var SwitchStatement = (function () {
     1693            function SwitchStatement(discriminant, cases) {
     1694                this.type = syntax_1.Syntax.SwitchStatement;
     1695                this.discriminant = discriminant;
     1696                this.cases = cases;
     1697            }
     1698            return SwitchStatement;
     1699        }());
     1700        exports.SwitchStatement = SwitchStatement;
     1701        var TaggedTemplateExpression = (function () {
     1702            function TaggedTemplateExpression(tag, quasi) {
     1703                this.type = syntax_1.Syntax.TaggedTemplateExpression;
     1704                this.tag = tag;
     1705                this.quasi = quasi;
     1706            }
     1707            return TaggedTemplateExpression;
     1708        }());
     1709        exports.TaggedTemplateExpression = TaggedTemplateExpression;
     1710        var TemplateElement = (function () {
     1711            function TemplateElement(value, tail) {
     1712                this.type = syntax_1.Syntax.TemplateElement;
     1713                this.value = value;
     1714                this.tail = tail;
     1715            }
     1716            return TemplateElement;
     1717        }());
     1718        exports.TemplateElement = TemplateElement;
     1719        var TemplateLiteral = (function () {
     1720            function TemplateLiteral(quasis, expressions) {
     1721                this.type = syntax_1.Syntax.TemplateLiteral;
     1722                this.quasis = quasis;
     1723                this.expressions = expressions;
     1724            }
     1725            return TemplateLiteral;
     1726        }());
     1727        exports.TemplateLiteral = TemplateLiteral;
     1728        var ThisExpression = (function () {
     1729            function ThisExpression() {
     1730                this.type = syntax_1.Syntax.ThisExpression;
     1731            }
     1732            return ThisExpression;
     1733        }());
     1734        exports.ThisExpression = ThisExpression;
     1735        var ThrowStatement = (function () {
     1736            function ThrowStatement(argument) {
     1737                this.type = syntax_1.Syntax.ThrowStatement;
     1738                this.argument = argument;
     1739            }
     1740            return ThrowStatement;
     1741        }());
     1742        exports.ThrowStatement = ThrowStatement;
     1743        var TryStatement = (function () {
     1744            function TryStatement(block, handler, finalizer) {
     1745                this.type = syntax_1.Syntax.TryStatement;
     1746                this.block = block;
     1747                this.handler = handler;
     1748                this.finalizer = finalizer;
     1749            }
     1750            return TryStatement;
     1751        }());
     1752        exports.TryStatement = TryStatement;
     1753        var UnaryExpression = (function () {
     1754            function UnaryExpression(operator, argument) {
     1755                this.type = syntax_1.Syntax.UnaryExpression;
     1756                this.operator = operator;
     1757                this.argument = argument;
     1758                this.prefix = true;
     1759            }
     1760            return UnaryExpression;
     1761        }());
     1762        exports.UnaryExpression = UnaryExpression;
     1763        var UpdateExpression = (function () {
     1764            function UpdateExpression(operator, argument, prefix) {
     1765                this.type = syntax_1.Syntax.UpdateExpression;
     1766                this.operator = operator;
     1767                this.argument = argument;
     1768                this.prefix = prefix;
     1769            }
     1770            return UpdateExpression;
     1771        }());
     1772        exports.UpdateExpression = UpdateExpression;
     1773        var VariableDeclaration = (function () {
     1774            function VariableDeclaration(declarations, kind) {
     1775                this.type = syntax_1.Syntax.VariableDeclaration;
     1776                this.declarations = declarations;
     1777                this.kind = kind;
     1778            }
     1779            return VariableDeclaration;
     1780        }());
     1781        exports.VariableDeclaration = VariableDeclaration;
     1782        var VariableDeclarator = (function () {
     1783            function VariableDeclarator(id, init) {
     1784                this.type = syntax_1.Syntax.VariableDeclarator;
     1785                this.id = id;
     1786                this.init = init;
     1787            }
     1788            return VariableDeclarator;
     1789        }());
     1790        exports.VariableDeclarator = VariableDeclarator;
     1791        var WhileStatement = (function () {
     1792            function WhileStatement(test, body) {
     1793                this.type = syntax_1.Syntax.WhileStatement;
     1794                this.test = test;
     1795                this.body = body;
     1796            }
     1797            return WhileStatement;
     1798        }());
     1799        exports.WhileStatement = WhileStatement;
     1800        var WithStatement = (function () {
     1801            function WithStatement(object, body) {
     1802                this.type = syntax_1.Syntax.WithStatement;
     1803                this.object = object;
     1804                this.body = body;
     1805            }
     1806            return WithStatement;
     1807        }());
     1808        exports.WithStatement = WithStatement;
     1809        var YieldExpression = (function () {
     1810            function YieldExpression(argument, delegate) {
     1811                this.type = syntax_1.Syntax.YieldExpression;
     1812                this.argument = argument;
     1813                this.delegate = delegate;
     1814            }
     1815            return YieldExpression;
     1816        }());
     1817        exports.YieldExpression = YieldExpression;
     1818
     1819
     1820/***/ },
     1821/* 8 */
     1822/***/ function(module, exports, __webpack_require__) {
     1823
     1824        "use strict";
     1825        Object.defineProperty(exports, "__esModule", { value: true });
     1826        var assert_1 = __webpack_require__(9);
     1827        var error_handler_1 = __webpack_require__(10);
     1828        var messages_1 = __webpack_require__(11);
     1829        var Node = __webpack_require__(7);
     1830        var scanner_1 = __webpack_require__(12);
     1831        var syntax_1 = __webpack_require__(2);
     1832        var token_1 = __webpack_require__(13);
     1833        var ArrowParameterPlaceHolder = 'ArrowParameterPlaceHolder';
     1834        var Parser = (function () {
     1835            function Parser(code, options, delegate) {
     1836                if (options === void 0) { options = {}; }
     1837                this.config = {
     1838                    range: (typeof options.range === 'boolean') && options.range,
     1839                    loc: (typeof options.loc === 'boolean') && options.loc,
     1840                    source: null,
     1841                    tokens: (typeof options.tokens === 'boolean') && options.tokens,
     1842                    comment: (typeof options.comment === 'boolean') && options.comment,
     1843                    tolerant: (typeof options.tolerant === 'boolean') && options.tolerant
     1844                };
     1845                if (this.config.loc && options.source && options.source !== null) {
     1846                    this.config.source = String(options.source);
     1847                }
     1848                this.delegate = delegate;
     1849                this.errorHandler = new error_handler_1.ErrorHandler();
     1850                this.errorHandler.tolerant = this.config.tolerant;
     1851                this.scanner = new scanner_1.Scanner(code, this.errorHandler);
     1852                this.scanner.trackComment = this.config.comment;
     1853                this.operatorPrecedence = {
     1854                    ')': 0,
     1855                    ';': 0,
     1856                    ',': 0,
     1857                    '=': 0,
     1858                    ']': 0,
     1859                    '||': 1,
     1860                    '&&': 2,
     1861                    '|': 3,
     1862                    '^': 4,
     1863                    '&': 5,
     1864                    '==': 6,
     1865                    '!=': 6,
     1866                    '===': 6,
     1867                    '!==': 6,
     1868                    '<': 7,
     1869                    '>': 7,
     1870                    '<=': 7,
     1871                    '>=': 7,
     1872                    '<<': 8,
     1873                    '>>': 8,
     1874                    '>>>': 8,
     1875                    '+': 9,
     1876                    '-': 9,
     1877                    '*': 11,
     1878                    '/': 11,
     1879                    '%': 11
     1880                };
     1881                this.lookahead = {
     1882                    type: 2 /* EOF */,
     1883                    value: '',
     1884                    lineNumber: this.scanner.lineNumber,
     1885                    lineStart: 0,
     1886                    start: 0,
     1887                    end: 0
     1888                };
     1889                this.hasLineTerminator = false;
     1890                this.context = {
     1891                    isModule: false,
     1892                    await: false,
     1893                    allowIn: true,
     1894                    allowStrictDirective: true,
     1895                    allowYield: true,
     1896                    firstCoverInitializedNameError: null,
     1897                    isAssignmentTarget: false,
     1898                    isBindingElement: false,
     1899                    inFunctionBody: false,
     1900                    inIteration: false,
     1901                    inSwitch: false,
     1902                    labelSet: {},
     1903                    strict: false
     1904                };
     1905                this.tokens = [];
     1906                this.startMarker = {
     1907                    index: 0,
     1908                    line: this.scanner.lineNumber,
     1909                    column: 0
     1910                };
     1911                this.lastMarker = {
     1912                    index: 0,
     1913                    line: this.scanner.lineNumber,
     1914                    column: 0
     1915                };
     1916                this.nextToken();
     1917                this.lastMarker = {
     1918                    index: this.scanner.index,
     1919                    line: this.scanner.lineNumber,
     1920                    column: this.scanner.index - this.scanner.lineStart
     1921                };
     1922            }
     1923            Parser.prototype.throwError = function (messageFormat) {
     1924                var values = [];
     1925                for (var _i = 1; _i < arguments.length; _i++) {
     1926                    values[_i - 1] = arguments[_i];
     1927                }
     1928                var args = Array.prototype.slice.call(arguments, 1);
     1929                var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
     1930                    assert_1.assert(idx < args.length, 'Message reference must be in range');
     1931                    return args[idx];
     1932                });
     1933                var index = this.lastMarker.index;
     1934                var line = this.lastMarker.line;
     1935                var column = this.lastMarker.column + 1;
     1936                throw this.errorHandler.createError(index, line, column, msg);
     1937            };
     1938            Parser.prototype.tolerateError = function (messageFormat) {
     1939                var values = [];
     1940                for (var _i = 1; _i < arguments.length; _i++) {
     1941                    values[_i - 1] = arguments[_i];
     1942                }
     1943                var args = Array.prototype.slice.call(arguments, 1);
     1944                var msg = messageFormat.replace(/%(\d)/g, function (whole, idx) {
     1945                    assert_1.assert(idx < args.length, 'Message reference must be in range');
     1946                    return args[idx];
     1947                });
     1948                var index = this.lastMarker.index;
     1949                var line = this.scanner.lineNumber;
     1950                var column = this.lastMarker.column + 1;
     1951                this.errorHandler.tolerateError(index, line, column, msg);
     1952            };
     1953            // Throw an exception because of the token.
     1954            Parser.prototype.unexpectedTokenError = function (token, message) {
     1955                var msg = message || messages_1.Messages.UnexpectedToken;
     1956                var value;
     1957                if (token) {
     1958                    if (!message) {
     1959                        msg = (token.type === 2 /* EOF */) ? messages_1.Messages.UnexpectedEOS :
     1960                            (token.type === 3 /* Identifier */) ? messages_1.Messages.UnexpectedIdentifier :
     1961                                (token.type === 6 /* NumericLiteral */) ? messages_1.Messages.UnexpectedNumber :
     1962                                    (token.type === 8 /* StringLiteral */) ? messages_1.Messages.UnexpectedString :
     1963                                        (token.type === 10 /* Template */) ? messages_1.Messages.UnexpectedTemplate :
     1964                                            messages_1.Messages.UnexpectedToken;
     1965                        if (token.type === 4 /* Keyword */) {
     1966                            if (this.scanner.isFutureReservedWord(token.value)) {
     1967                                msg = messages_1.Messages.UnexpectedReserved;
     1968                            }
     1969                            else if (this.context.strict && this.scanner.isStrictModeReservedWord(token.value)) {
     1970                                msg = messages_1.Messages.StrictReservedWord;
     1971                            }
     1972                        }
     1973                    }
     1974                    value = token.value;
     1975                }
     1976                else {
     1977                    value = 'ILLEGAL';
     1978                }
     1979                msg = msg.replace('%0', value);
     1980                if (token && typeof token.lineNumber === 'number') {
     1981                    var index = token.start;
     1982                    var line = token.lineNumber;
     1983                    var lastMarkerLineStart = this.lastMarker.index - this.lastMarker.column;
     1984                    var column = token.start - lastMarkerLineStart + 1;
     1985                    return this.errorHandler.createError(index, line, column, msg);
     1986                }
     1987                else {
     1988                    var index = this.lastMarker.index;
     1989                    var line = this.lastMarker.line;
     1990                    var column = this.lastMarker.column + 1;
     1991                    return this.errorHandler.createError(index, line, column, msg);
     1992                }
     1993            };
     1994            Parser.prototype.throwUnexpectedToken = function (token, message) {
     1995                throw this.unexpectedTokenError(token, message);
     1996            };
     1997            Parser.prototype.tolerateUnexpectedToken = function (token, message) {
     1998                this.errorHandler.tolerate(this.unexpectedTokenError(token, message));
     1999            };
     2000            Parser.prototype.collectComments = function () {
     2001                if (!this.config.comment) {
     2002                    this.scanner.scanComments();
     2003                }
     2004                else {
     2005                    var comments = this.scanner.scanComments();
     2006                    if (comments.length > 0 && this.delegate) {
     2007                        for (var i = 0; i < comments.length; ++i) {
     2008                            var e = comments[i];
     2009                            var node = void 0;
     2010                            node = {
     2011                                type: e.multiLine ? 'BlockComment' : 'LineComment',
     2012                                value: this.scanner.source.slice(e.slice[0], e.slice[1])
     2013                            };
     2014                            if (this.config.range) {
     2015                                node.range = e.range;
     2016                            }
     2017                            if (this.config.loc) {
     2018                                node.loc = e.loc;
     2019                            }
     2020                            var metadata = {
     2021                                start: {
     2022                                    line: e.loc.start.line,
     2023                                    column: e.loc.start.column,
     2024                                    offset: e.range[0]
     2025                                },
     2026                                end: {
     2027                                    line: e.loc.end.line,
     2028                                    column: e.loc.end.column,
     2029                                    offset: e.range[1]
     2030                                }
     2031                            };
     2032                            this.delegate(node, metadata);
     2033                        }
     2034                    }
     2035                }
     2036            };
     2037            // From internal representation to an external structure
     2038            Parser.prototype.getTokenRaw = function (token) {
     2039                return this.scanner.source.slice(token.start, token.end);
     2040            };
     2041            Parser.prototype.convertToken = function (token) {
     2042                var t = {
     2043                    type: token_1.TokenName[token.type],
     2044                    value: this.getTokenRaw(token)
     2045                };
     2046                if (this.config.range) {
     2047                    t.range = [token.start, token.end];
     2048                }
     2049                if (this.config.loc) {
     2050                    t.loc = {
     2051                        start: {
     2052                            line: this.startMarker.line,
     2053                            column: this.startMarker.column
     2054                        },
     2055                        end: {
     2056                            line: this.scanner.lineNumber,
     2057                            column: this.scanner.index - this.scanner.lineStart
     2058                        }
     2059                    };
     2060                }
     2061                if (token.type === 9 /* RegularExpression */) {
     2062                    var pattern = token.pattern;
     2063                    var flags = token.flags;
     2064                    t.regex = { pattern: pattern, flags: flags };
     2065                }
     2066                return t;
     2067            };
     2068            Parser.prototype.nextToken = function () {
     2069                var token = this.lookahead;
     2070                this.lastMarker.index = this.scanner.index;
     2071                this.lastMarker.line = this.scanner.lineNumber;
     2072                this.lastMarker.column = this.scanner.index - this.scanner.lineStart;
     2073                this.collectComments();
     2074                if (this.scanner.index !== this.startMarker.index) {
     2075                    this.startMarker.index = this.scanner.index;
     2076                    this.startMarker.line = this.scanner.lineNumber;
     2077                    this.startMarker.column = this.scanner.index - this.scanner.lineStart;
     2078                }
     2079                var next = this.scanner.lex();
     2080                this.hasLineTerminator = (token.lineNumber !== next.lineNumber);
     2081                if (next && this.context.strict && next.type === 3 /* Identifier */) {
     2082                    if (this.scanner.isStrictModeReservedWord(next.value)) {
     2083                        next.type = 4 /* Keyword */;
     2084                    }
     2085                }
     2086                this.lookahead = next;
     2087                if (this.config.tokens && next.type !== 2 /* EOF */) {
     2088                    this.tokens.push(this.convertToken(next));
     2089                }
     2090                return token;
     2091            };
     2092            Parser.prototype.nextRegexToken = function () {
     2093                this.collectComments();
     2094                var token = this.scanner.scanRegExp();
     2095                if (this.config.tokens) {
     2096                    // Pop the previous token, '/' or '/='
     2097                    // This is added from the lookahead token.
     2098                    this.tokens.pop();
     2099                    this.tokens.push(this.convertToken(token));
     2100                }
     2101                // Prime the next lookahead.
     2102                this.lookahead = token;
     2103                this.nextToken();
     2104                return token;
     2105            };
     2106            Parser.prototype.createNode = function () {
     2107                return {
     2108                    index: this.startMarker.index,
     2109                    line: this.startMarker.line,
     2110                    column: this.startMarker.column
     2111                };
     2112            };
     2113            Parser.prototype.startNode = function (token) {
     2114                return {
     2115                    index: token.start,
     2116                    line: token.lineNumber,
     2117                    column: token.start - token.lineStart
     2118                };
     2119            };
     2120            Parser.prototype.finalize = function (marker, node) {
     2121                if (this.config.range) {
     2122                    node.range = [marker.index, this.lastMarker.index];
     2123                }
     2124                if (this.config.loc) {
     2125                    node.loc = {
     2126                        start: {
     2127                            line: marker.line,
     2128                            column: marker.column,
     2129                        },
     2130                        end: {
     2131                            line: this.lastMarker.line,
     2132                            column: this.lastMarker.column
     2133                        }
     2134                    };
     2135                    if (this.config.source) {
     2136                        node.loc.source = this.config.source;
     2137                    }
     2138                }
     2139                if (this.delegate) {
     2140                    var metadata = {
     2141                        start: {
     2142                            line: marker.line,
     2143                            column: marker.column,
     2144                            offset: marker.index
     2145                        },
     2146                        end: {
     2147                            line: this.lastMarker.line,
     2148                            column: this.lastMarker.column,
     2149                            offset: this.lastMarker.index
     2150                        }
     2151                    };
     2152                    this.delegate(node, metadata);
     2153                }
     2154                return node;
     2155            };
     2156            // Expect the next token to match the specified punctuator.
     2157            // If not, an exception will be thrown.
     2158            Parser.prototype.expect = function (value) {
     2159                var token = this.nextToken();
     2160                if (token.type !== 7 /* Punctuator */ || token.value !== value) {
     2161                    this.throwUnexpectedToken(token);
     2162                }
     2163            };
     2164            // Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
     2165            Parser.prototype.expectCommaSeparator = function () {
     2166                if (this.config.tolerant) {
     2167                    var token = this.lookahead;
     2168                    if (token.type === 7 /* Punctuator */ && token.value === ',') {
     2169                        this.nextToken();
     2170                    }
     2171                    else if (token.type === 7 /* Punctuator */ && token.value === ';') {
     2172                        this.nextToken();
     2173                        this.tolerateUnexpectedToken(token);
     2174                    }
     2175                    else {
     2176                        this.tolerateUnexpectedToken(token, messages_1.Messages.UnexpectedToken);
     2177                    }
     2178                }
     2179                else {
     2180                    this.expect(',');
     2181                }
     2182            };
     2183            // Expect the next token to match the specified keyword.
     2184            // If not, an exception will be thrown.
     2185            Parser.prototype.expectKeyword = function (keyword) {
     2186                var token = this.nextToken();
     2187                if (token.type !== 4 /* Keyword */ || token.value !== keyword) {
     2188                    this.throwUnexpectedToken(token);
     2189                }
     2190            };
     2191            // Return true if the next token matches the specified punctuator.
     2192            Parser.prototype.match = function (value) {
     2193                return this.lookahead.type === 7 /* Punctuator */ && this.lookahead.value === value;
     2194            };
     2195            // Return true if the next token matches the specified keyword
     2196            Parser.prototype.matchKeyword = function (keyword) {
     2197                return this.lookahead.type === 4 /* Keyword */ && this.lookahead.value === keyword;
     2198            };
     2199            // Return true if the next token matches the specified contextual keyword
     2200            // (where an identifier is sometimes a keyword depending on the context)
     2201            Parser.prototype.matchContextualKeyword = function (keyword) {
     2202                return this.lookahead.type === 3 /* Identifier */ && this.lookahead.value === keyword;
     2203            };
     2204            // Return true if the next token is an assignment operator
     2205            Parser.prototype.matchAssign = function () {
     2206                if (this.lookahead.type !== 7 /* Punctuator */) {
     2207                    return false;
     2208                }
     2209                var op = this.lookahead.value;
     2210                return op === '=' ||
     2211                    op === '*=' ||
     2212                    op === '**=' ||
     2213                    op === '/=' ||
     2214                    op === '%=' ||
     2215                    op === '+=' ||
     2216                    op === '-=' ||
     2217                    op === '<<=' ||
     2218                    op === '>>=' ||
     2219                    op === '>>>=' ||
     2220                    op === '&=' ||
     2221                    op === '^=' ||
     2222                    op === '|=';
     2223            };
     2224            // Cover grammar support.
     2225            //
     2226            // When an assignment expression position starts with an left parenthesis, the determination of the type
     2227            // of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
     2228            // or the first comma. This situation also defers the determination of all the expressions nested in the pair.
     2229            //
     2230            // There are three productions that can be parsed in a parentheses pair that needs to be determined
     2231            // after the outermost pair is closed. They are:
     2232            //
     2233            //   1. AssignmentExpression
     2234            //   2. BindingElements
     2235            //   3. AssignmentTargets
     2236            //
     2237            // In order to avoid exponential backtracking, we use two flags to denote if the production can be
     2238            // binding element or assignment target.
     2239            //
     2240            // The three productions have the relationship:
     2241            //
     2242            //   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
     2243            //
     2244            // with a single exception that CoverInitializedName when used directly in an Expression, generates
     2245            // an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
     2246            // first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
     2247            //
     2248            // isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
     2249            // effect the current flags. This means the production the parser parses is only used as an expression. Therefore
     2250            // the CoverInitializedName check is conducted.
     2251            //
     2252            // inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
     2253            // the flags outside of the parser. This means the production the parser parses is used as a part of a potential
     2254            // pattern. The CoverInitializedName check is deferred.
     2255            Parser.prototype.isolateCoverGrammar = function (parseFunction) {
     2256                var previousIsBindingElement = this.context.isBindingElement;
     2257                var previousIsAssignmentTarget = this.context.isAssignmentTarget;
     2258                var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
     2259                this.context.isBindingElement = true;
     2260                this.context.isAssignmentTarget = true;
     2261                this.context.firstCoverInitializedNameError = null;
     2262                var result = parseFunction.call(this);
     2263                if (this.context.firstCoverInitializedNameError !== null) {
     2264                    this.throwUnexpectedToken(this.context.firstCoverInitializedNameError);
     2265                }
     2266                this.context.isBindingElement = previousIsBindingElement;
     2267                this.context.isAssignmentTarget = previousIsAssignmentTarget;
     2268                this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError;
     2269                return result;
     2270            };
     2271            Parser.prototype.inheritCoverGrammar = function (parseFunction) {
     2272                var previousIsBindingElement = this.context.isBindingElement;
     2273                var previousIsAssignmentTarget = this.context.isAssignmentTarget;
     2274                var previousFirstCoverInitializedNameError = this.context.firstCoverInitializedNameError;
     2275                this.context.isBindingElement = true;
     2276                this.context.isAssignmentTarget = true;
     2277                this.context.firstCoverInitializedNameError = null;
     2278                var result = parseFunction.call(this);
     2279                this.context.isBindingElement = this.context.isBindingElement && previousIsBindingElement;
     2280                this.context.isAssignmentTarget = this.context.isAssignmentTarget && previousIsAssignmentTarget;
     2281                this.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError || this.context.firstCoverInitializedNameError;
     2282                return result;
     2283            };
     2284            Parser.prototype.consumeSemicolon = function () {
     2285                if (this.match(';')) {
     2286                    this.nextToken();
     2287                }
     2288                else if (!this.hasLineTerminator) {
     2289                    if (this.lookahead.type !== 2 /* EOF */ && !this.match('}')) {
     2290                        this.throwUnexpectedToken(this.lookahead);
     2291                    }
     2292                    this.lastMarker.index = this.startMarker.index;
     2293                    this.lastMarker.line = this.startMarker.line;
     2294                    this.lastMarker.column = this.startMarker.column;
     2295                }
     2296            };
     2297            // https://tc39.github.io/ecma262/#sec-primary-expression
     2298            Parser.prototype.parsePrimaryExpression = function () {
     2299                var node = this.createNode();
     2300                var expr;
     2301                var token, raw;
     2302                switch (this.lookahead.type) {
     2303                    case 3 /* Identifier */:
     2304                        if ((this.context.isModule || this.context.await) && this.lookahead.value === 'await') {
     2305                            this.tolerateUnexpectedToken(this.lookahead);
     2306                        }
     2307                        expr = this.matchAsyncFunction() ? this.parseFunctionExpression() : this.finalize(node, new Node.Identifier(this.nextToken().value));
     2308                        break;
     2309                    case 6 /* NumericLiteral */:
     2310                    case 8 /* StringLiteral */:
     2311                        if (this.context.strict && this.lookahead.octal) {
     2312                            this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.StrictOctalLiteral);
     2313                        }
     2314                        this.context.isAssignmentTarget = false;
     2315                        this.context.isBindingElement = false;
     2316                        token = this.nextToken();
     2317                        raw = this.getTokenRaw(token);
     2318                        expr = this.finalize(node, new Node.Literal(token.value, raw));
     2319                        break;
     2320                    case 1 /* BooleanLiteral */:
     2321                        this.context.isAssignmentTarget = false;
     2322                        this.context.isBindingElement = false;
     2323                        token = this.nextToken();
     2324                        raw = this.getTokenRaw(token);
     2325                        expr = this.finalize(node, new Node.Literal(token.value === 'true', raw));
     2326                        break;
     2327                    case 5 /* NullLiteral */:
     2328                        this.context.isAssignmentTarget = false;
     2329                        this.context.isBindingElement = false;
     2330                        token = this.nextToken();
     2331                        raw = this.getTokenRaw(token);
     2332                        expr = this.finalize(node, new Node.Literal(null, raw));
     2333                        break;
     2334                    case 10 /* Template */:
     2335                        expr = this.parseTemplateLiteral();
     2336                        break;
     2337                    case 7 /* Punctuator */:
     2338                        switch (this.lookahead.value) {
     2339                            case '(':
     2340                                this.context.isBindingElement = false;
     2341                                expr = this.inheritCoverGrammar(this.parseGroupExpression);
     2342                                break;
     2343                            case '[':
     2344                                expr = this.inheritCoverGrammar(this.parseArrayInitializer);
     2345                                break;
     2346                            case '{':
     2347                                expr = this.inheritCoverGrammar(this.parseObjectInitializer);
     2348                                break;
     2349                            case '/':
     2350                            case '/=':
     2351                                this.context.isAssignmentTarget = false;
     2352                                this.context.isBindingElement = false;
     2353                                this.scanner.index = this.startMarker.index;
     2354                                token = this.nextRegexToken();
     2355                                raw = this.getTokenRaw(token);
     2356                                expr = this.finalize(node, new Node.RegexLiteral(token.regex, raw, token.pattern, token.flags));
     2357                                break;
     2358                            default:
     2359                                expr = this.throwUnexpectedToken(this.nextToken());
     2360                        }
     2361                        break;
     2362                    case 4 /* Keyword */:
     2363                        if (!this.context.strict && this.context.allowYield && this.matchKeyword('yield')) {
     2364                            expr = this.parseIdentifierName();
     2365                        }
     2366                        else if (!this.context.strict && this.matchKeyword('let')) {
     2367                            expr = this.finalize(node, new Node.Identifier(this.nextToken().value));
     2368                        }
     2369                        else {
     2370                            this.context.isAssignmentTarget = false;
     2371                            this.context.isBindingElement = false;
     2372                            if (this.matchKeyword('function')) {
     2373                                expr = this.parseFunctionExpression();
     2374                            }
     2375                            else if (this.matchKeyword('this')) {
     2376                                this.nextToken();
     2377                                expr = this.finalize(node, new Node.ThisExpression());
     2378                            }
     2379                            else if (this.matchKeyword('class')) {
     2380                                expr = this.parseClassExpression();
     2381                            }
     2382                            else {
     2383                                expr = this.throwUnexpectedToken(this.nextToken());
     2384                            }
     2385                        }
     2386                        break;
     2387                    default:
     2388                        expr = this.throwUnexpectedToken(this.nextToken());
     2389                }
     2390                return expr;
     2391            };
     2392            // https://tc39.github.io/ecma262/#sec-array-initializer
     2393            Parser.prototype.parseSpreadElement = function () {
     2394                var node = this.createNode();
     2395                this.expect('...');
     2396                var arg = this.inheritCoverGrammar(this.parseAssignmentExpression);
     2397                return this.finalize(node, new Node.SpreadElement(arg));
     2398            };
     2399            Parser.prototype.parseArrayInitializer = function () {
     2400                var node = this.createNode();
     2401                var elements = [];
     2402                this.expect('[');
     2403                while (!this.match(']')) {
     2404                    if (this.match(',')) {
     2405                        this.nextToken();
     2406                        elements.push(null);
     2407                    }
     2408                    else if (this.match('...')) {
     2409                        var element = this.parseSpreadElement();
     2410                        if (!this.match(']')) {
     2411                            this.context.isAssignmentTarget = false;
     2412                            this.context.isBindingElement = false;
     2413                            this.expect(',');
     2414                        }
     2415                        elements.push(element);
     2416                    }
     2417                    else {
     2418                        elements.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
     2419                        if (!this.match(']')) {
     2420                            this.expect(',');
     2421                        }
     2422                    }
     2423                }
     2424                this.expect(']');
     2425                return this.finalize(node, new Node.ArrayExpression(elements));
     2426            };
     2427            // https://tc39.github.io/ecma262/#sec-object-initializer
     2428            Parser.prototype.parsePropertyMethod = function (params) {
     2429                this.context.isAssignmentTarget = false;
     2430                this.context.isBindingElement = false;
     2431                var previousStrict = this.context.strict;
     2432                var previousAllowStrictDirective = this.context.allowStrictDirective;
     2433                this.context.allowStrictDirective = params.simple;
     2434                var body = this.isolateCoverGrammar(this.parseFunctionSourceElements);
     2435                if (this.context.strict && params.firstRestricted) {
     2436                    this.tolerateUnexpectedToken(params.firstRestricted, params.message);
     2437                }
     2438                if (this.context.strict && params.stricted) {
     2439                    this.tolerateUnexpectedToken(params.stricted, params.message);
     2440                }
     2441                this.context.strict = previousStrict;
     2442                this.context.allowStrictDirective = previousAllowStrictDirective;
     2443                return body;
     2444            };
     2445            Parser.prototype.parsePropertyMethodFunction = function () {
     2446                var isGenerator = false;
     2447                var node = this.createNode();
     2448                var previousAllowYield = this.context.allowYield;
     2449                this.context.allowYield = false;
     2450                var params = this.parseFormalParameters();
     2451                var method = this.parsePropertyMethod(params);
     2452                this.context.allowYield = previousAllowYield;
     2453                return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
     2454            };
     2455            Parser.prototype.parsePropertyMethodAsyncFunction = function () {
     2456                var node = this.createNode();
     2457                var previousAllowYield = this.context.allowYield;
     2458                var previousAwait = this.context.await;
     2459                this.context.allowYield = false;
     2460                this.context.await = true;
     2461                var params = this.parseFormalParameters();
     2462                var method = this.parsePropertyMethod(params);
     2463                this.context.allowYield = previousAllowYield;
     2464                this.context.await = previousAwait;
     2465                return this.finalize(node, new Node.AsyncFunctionExpression(null, params.params, method));
     2466            };
     2467            Parser.prototype.parseObjectPropertyKey = function () {
     2468                var node = this.createNode();
     2469                var token = this.nextToken();
     2470                var key;
     2471                switch (token.type) {
     2472                    case 8 /* StringLiteral */:
     2473                    case 6 /* NumericLiteral */:
     2474                        if (this.context.strict && token.octal) {
     2475                            this.tolerateUnexpectedToken(token, messages_1.Messages.StrictOctalLiteral);
     2476                        }
     2477                        var raw = this.getTokenRaw(token);
     2478                        key = this.finalize(node, new Node.Literal(token.value, raw));
     2479                        break;
     2480                    case 3 /* Identifier */:
     2481                    case 1 /* BooleanLiteral */:
     2482                    case 5 /* NullLiteral */:
     2483                    case 4 /* Keyword */:
     2484                        key = this.finalize(node, new Node.Identifier(token.value));
     2485                        break;
     2486                    case 7 /* Punctuator */:
     2487                        if (token.value === '[') {
     2488                            key = this.isolateCoverGrammar(this.parseAssignmentExpression);
     2489                            this.expect(']');
     2490                        }
     2491                        else {
     2492                            key = this.throwUnexpectedToken(token);
     2493                        }
     2494                        break;
     2495                    default:
     2496                        key = this.throwUnexpectedToken(token);
     2497                }
     2498                return key;
     2499            };
     2500            Parser.prototype.isPropertyKey = function (key, value) {
     2501                return (key.type === syntax_1.Syntax.Identifier && key.name === value) ||
     2502                    (key.type === syntax_1.Syntax.Literal && key.value === value);
     2503            };
     2504            Parser.prototype.parseObjectProperty = function (hasProto) {
     2505                var node = this.createNode();
     2506                var token = this.lookahead;
     2507                var kind;
     2508                var key = null;
     2509                var value = null;
     2510                var computed = false;
     2511                var method = false;
     2512                var shorthand = false;
     2513                var isAsync = false;
     2514                if (token.type === 3 /* Identifier */) {
     2515                    var id = token.value;
     2516                    this.nextToken();
     2517                    computed = this.match('[');
     2518                    isAsync = !this.hasLineTerminator && (id === 'async') &&
     2519                        !this.match(':') && !this.match('(') && !this.match('*');
     2520                    key = isAsync ? this.parseObjectPropertyKey() : this.finalize(node, new Node.Identifier(id));
     2521                }
     2522                else if (this.match('*')) {
     2523                    this.nextToken();
     2524                }
     2525                else {
     2526                    computed = this.match('[');
     2527                    key = this.parseObjectPropertyKey();
     2528                }
     2529                var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
     2530                if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'get' && lookaheadPropertyKey) {
     2531                    kind = 'get';
     2532                    computed = this.match('[');
     2533                    key = this.parseObjectPropertyKey();
     2534                    this.context.allowYield = false;
     2535                    value = this.parseGetterMethod();
     2536                }
     2537                else if (token.type === 3 /* Identifier */ && !isAsync && token.value === 'set' && lookaheadPropertyKey) {
     2538                    kind = 'set';
     2539                    computed = this.match('[');
     2540                    key = this.parseObjectPropertyKey();
     2541                    value = this.parseSetterMethod();
     2542                }
     2543                else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
     2544                    kind = 'init';
     2545                    computed = this.match('[');
     2546                    key = this.parseObjectPropertyKey();
     2547                    value = this.parseGeneratorMethod();
     2548                    method = true;
     2549                }
     2550                else {
     2551                    if (!key) {
     2552                        this.throwUnexpectedToken(this.lookahead);
     2553                    }
     2554                    kind = 'init';
     2555                    if (this.match(':') && !isAsync) {
     2556                        if (!computed && this.isPropertyKey(key, '__proto__')) {
     2557                            if (hasProto.value) {
     2558                                this.tolerateError(messages_1.Messages.DuplicateProtoProperty);
     2559                            }
     2560                            hasProto.value = true;
     2561                        }
     2562                        this.nextToken();
     2563                        value = this.inheritCoverGrammar(this.parseAssignmentExpression);
     2564                    }
     2565                    else if (this.match('(')) {
     2566                        value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
     2567                        method = true;
     2568                    }
     2569                    else if (token.type === 3 /* Identifier */) {
     2570                        var id = this.finalize(node, new Node.Identifier(token.value));
     2571                        if (this.match('=')) {
     2572                            this.context.firstCoverInitializedNameError = this.lookahead;
     2573                            this.nextToken();
     2574                            shorthand = true;
     2575                            var init = this.isolateCoverGrammar(this.parseAssignmentExpression);
     2576                            value = this.finalize(node, new Node.AssignmentPattern(id, init));
     2577                        }
     2578                        else {
     2579                            shorthand = true;
     2580                            value = id;
     2581                        }
     2582                    }
     2583                    else {
     2584                        this.throwUnexpectedToken(this.nextToken());
     2585                    }
     2586                }
     2587                return this.finalize(node, new Node.Property(kind, key, computed, value, method, shorthand));
     2588            };
     2589            Parser.prototype.parseObjectInitializer = function () {
     2590                var node = this.createNode();
     2591                this.expect('{');
     2592                var properties = [];
     2593                var hasProto = { value: false };
     2594                while (!this.match('}')) {
     2595                    properties.push(this.parseObjectProperty(hasProto));
     2596                    if (!this.match('}')) {
     2597                        this.expectCommaSeparator();
     2598                    }
     2599                }
     2600                this.expect('}');
     2601                return this.finalize(node, new Node.ObjectExpression(properties));
     2602            };
     2603            // https://tc39.github.io/ecma262/#sec-template-literals
     2604            Parser.prototype.parseTemplateHead = function () {
     2605                assert_1.assert(this.lookahead.head, 'Template literal must start with a template head');
     2606                var node = this.createNode();
     2607                var token = this.nextToken();
     2608                var raw = token.value;
     2609                var cooked = token.cooked;
     2610                return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
     2611            };
     2612            Parser.prototype.parseTemplateElement = function () {
     2613                if (this.lookahead.type !== 10 /* Template */) {
     2614                    this.throwUnexpectedToken();
     2615                }
     2616                var node = this.createNode();
     2617                var token = this.nextToken();
     2618                var raw = token.value;
     2619                var cooked = token.cooked;
     2620                return this.finalize(node, new Node.TemplateElement({ raw: raw, cooked: cooked }, token.tail));
     2621            };
     2622            Parser.prototype.parseTemplateLiteral = function () {
     2623                var node = this.createNode();
     2624                var expressions = [];
     2625                var quasis = [];
     2626                var quasi = this.parseTemplateHead();
     2627                quasis.push(quasi);
     2628                while (!quasi.tail) {
     2629                    expressions.push(this.parseExpression());
     2630                    quasi = this.parseTemplateElement();
     2631                    quasis.push(quasi);
     2632                }
     2633                return this.finalize(node, new Node.TemplateLiteral(quasis, expressions));
     2634            };
     2635            // https://tc39.github.io/ecma262/#sec-grouping-operator
     2636            Parser.prototype.reinterpretExpressionAsPattern = function (expr) {
     2637                switch (expr.type) {
     2638                    case syntax_1.Syntax.Identifier:
     2639                    case syntax_1.Syntax.MemberExpression:
     2640                    case syntax_1.Syntax.RestElement:
     2641                    case syntax_1.Syntax.AssignmentPattern:
     2642                        break;
     2643                    case syntax_1.Syntax.SpreadElement:
     2644                        expr.type = syntax_1.Syntax.RestElement;
     2645                        this.reinterpretExpressionAsPattern(expr.argument);
     2646                        break;
     2647                    case syntax_1.Syntax.ArrayExpression:
     2648                        expr.type = syntax_1.Syntax.ArrayPattern;
     2649                        for (var i = 0; i < expr.elements.length; i++) {
     2650                            if (expr.elements[i] !== null) {
     2651                                this.reinterpretExpressionAsPattern(expr.elements[i]);
     2652                            }
     2653                        }
     2654                        break;
     2655                    case syntax_1.Syntax.ObjectExpression:
     2656                        expr.type = syntax_1.Syntax.ObjectPattern;
     2657                        for (var i = 0; i < expr.properties.length; i++) {
     2658                            this.reinterpretExpressionAsPattern(expr.properties[i].value);
     2659                        }
     2660                        break;
     2661                    case syntax_1.Syntax.AssignmentExpression:
     2662                        expr.type = syntax_1.Syntax.AssignmentPattern;
     2663                        delete expr.operator;
     2664                        this.reinterpretExpressionAsPattern(expr.left);
     2665                        break;
     2666                    default:
     2667                        // Allow other node type for tolerant parsing.
     2668                        break;
     2669                }
     2670            };
     2671            Parser.prototype.parseGroupExpression = function () {
     2672                var expr;
     2673                this.expect('(');
     2674                if (this.match(')')) {
     2675                    this.nextToken();
     2676                    if (!this.match('=>')) {
     2677                        this.expect('=>');
     2678                    }
     2679                    expr = {
     2680                        type: ArrowParameterPlaceHolder,
     2681                        params: [],
     2682                        async: false
     2683                    };
     2684                }
     2685                else {
     2686                    var startToken = this.lookahead;
     2687                    var params = [];
     2688                    if (this.match('...')) {
     2689                        expr = this.parseRestElement(params);
     2690                        this.expect(')');
     2691                        if (!this.match('=>')) {
     2692                            this.expect('=>');
     2693                        }
     2694                        expr = {
     2695                            type: ArrowParameterPlaceHolder,
     2696                            params: [expr],
     2697                            async: false
     2698                        };
     2699                    }
     2700                    else {
     2701                        var arrow = false;
     2702                        this.context.isBindingElement = true;
     2703                        expr = this.inheritCoverGrammar(this.parseAssignmentExpression);
     2704                        if (this.match(',')) {
     2705                            var expressions = [];
     2706                            this.context.isAssignmentTarget = false;
     2707                            expressions.push(expr);
     2708                            while (this.lookahead.type !== 2 /* EOF */) {
     2709                                if (!this.match(',')) {
     2710                                    break;
     2711                                }
     2712                                this.nextToken();
     2713                                if (this.match(')')) {
     2714                                    this.nextToken();
     2715                                    for (var i = 0; i < expressions.length; i++) {
     2716                                        this.reinterpretExpressionAsPattern(expressions[i]);
     2717                                    }
     2718                                    arrow = true;
     2719                                    expr = {
     2720                                        type: ArrowParameterPlaceHolder,
     2721                                        params: expressions,
     2722                                        async: false
     2723                                    };
     2724                                }
     2725                                else if (this.match('...')) {
     2726                                    if (!this.context.isBindingElement) {
     2727                                        this.throwUnexpectedToken(this.lookahead);
     2728                                    }
     2729                                    expressions.push(this.parseRestElement(params));
     2730                                    this.expect(')');
     2731                                    if (!this.match('=>')) {
     2732                                        this.expect('=>');
     2733                                    }
     2734                                    this.context.isBindingElement = false;
     2735                                    for (var i = 0; i < expressions.length; i++) {
     2736                                        this.reinterpretExpressionAsPattern(expressions[i]);
     2737                                    }
     2738                                    arrow = true;
     2739                                    expr = {
     2740                                        type: ArrowParameterPlaceHolder,
     2741                                        params: expressions,
     2742                                        async: false
     2743                                    };
     2744                                }
     2745                                else {
     2746                                    expressions.push(this.inheritCoverGrammar(this.parseAssignmentExpression));
     2747                                }
     2748                                if (arrow) {
     2749                                    break;
     2750                                }
     2751                            }
     2752                            if (!arrow) {
     2753                                expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
     2754                            }
     2755                        }
     2756                        if (!arrow) {
     2757                            this.expect(')');
     2758                            if (this.match('=>')) {
     2759                                if (expr.type === syntax_1.Syntax.Identifier && expr.name === 'yield') {
     2760                                    arrow = true;
     2761                                    expr = {
     2762                                        type: ArrowParameterPlaceHolder,
     2763                                        params: [expr],
     2764                                        async: false
     2765                                    };
     2766                                }
     2767                                if (!arrow) {
     2768                                    if (!this.context.isBindingElement) {
     2769                                        this.throwUnexpectedToken(this.lookahead);
     2770                                    }
     2771                                    if (expr.type === syntax_1.Syntax.SequenceExpression) {
     2772                                        for (var i = 0; i < expr.expressions.length; i++) {
     2773                                            this.reinterpretExpressionAsPattern(expr.expressions[i]);
     2774                                        }
     2775                                    }
     2776                                    else {
     2777                                        this.reinterpretExpressionAsPattern(expr);
     2778                                    }
     2779                                    var parameters = (expr.type === syntax_1.Syntax.SequenceExpression ? expr.expressions : [expr]);
     2780                                    expr = {
     2781                                        type: ArrowParameterPlaceHolder,
     2782                                        params: parameters,
     2783                                        async: false
     2784                                    };
     2785                                }
     2786                            }
     2787                            this.context.isBindingElement = false;
     2788                        }
     2789                    }
     2790                }
     2791                return expr;
     2792            };
     2793            // https://tc39.github.io/ecma262/#sec-left-hand-side-expressions
     2794            Parser.prototype.parseArguments = function () {
     2795                this.expect('(');
     2796                var args = [];
     2797                if (!this.match(')')) {
     2798                    while (true) {
     2799                        var expr = this.match('...') ? this.parseSpreadElement() :
     2800                            this.isolateCoverGrammar(this.parseAssignmentExpression);
     2801                        args.push(expr);
     2802                        if (this.match(')')) {
     2803                            break;
     2804                        }
     2805                        this.expectCommaSeparator();
     2806                        if (this.match(')')) {
     2807                            break;
     2808                        }
     2809                    }
     2810                }
     2811                this.expect(')');
     2812                return args;
     2813            };
     2814            Parser.prototype.isIdentifierName = function (token) {
     2815                return token.type === 3 /* Identifier */ ||
     2816                    token.type === 4 /* Keyword */ ||
     2817                    token.type === 1 /* BooleanLiteral */ ||
     2818                    token.type === 5 /* NullLiteral */;
     2819            };
     2820            Parser.prototype.parseIdentifierName = function () {
     2821                var node = this.createNode();
     2822                var token = this.nextToken();
     2823                if (!this.isIdentifierName(token)) {
     2824                    this.throwUnexpectedToken(token);
     2825                }
     2826                return this.finalize(node, new Node.Identifier(token.value));
     2827            };
     2828            Parser.prototype.parseNewExpression = function () {
     2829                var node = this.createNode();
     2830                var id = this.parseIdentifierName();
     2831                assert_1.assert(id.name === 'new', 'New expression must start with `new`');
     2832                var expr;
     2833                if (this.match('.')) {
     2834                    this.nextToken();
     2835                    if (this.lookahead.type === 3 /* Identifier */ && this.context.inFunctionBody && this.lookahead.value === 'target') {
     2836                        var property = this.parseIdentifierName();
     2837                        expr = new Node.MetaProperty(id, property);
     2838                    }
     2839                    else {
     2840                        this.throwUnexpectedToken(this.lookahead);
     2841                    }
     2842                }
     2843                else {
     2844                    var callee = this.isolateCoverGrammar(this.parseLeftHandSideExpression);
     2845                    var args = this.match('(') ? this.parseArguments() : [];
     2846                    expr = new Node.NewExpression(callee, args);
     2847                    this.context.isAssignmentTarget = false;
     2848                    this.context.isBindingElement = false;
     2849                }
     2850                return this.finalize(node, expr);
     2851            };
     2852            Parser.prototype.parseAsyncArgument = function () {
     2853                var arg = this.parseAssignmentExpression();
     2854                this.context.firstCoverInitializedNameError = null;
     2855                return arg;
     2856            };
     2857            Parser.prototype.parseAsyncArguments = function () {
     2858                this.expect('(');
     2859                var args = [];
     2860                if (!this.match(')')) {
     2861                    while (true) {
     2862                        var expr = this.match('...') ? this.parseSpreadElement() :
     2863                            this.isolateCoverGrammar(this.parseAsyncArgument);
     2864                        args.push(expr);
     2865                        if (this.match(')')) {
     2866                            break;
     2867                        }
     2868                        this.expectCommaSeparator();
     2869                        if (this.match(')')) {
     2870                            break;
     2871                        }
     2872                    }
     2873                }
     2874                this.expect(')');
     2875                return args;
     2876            };
     2877            Parser.prototype.parseLeftHandSideExpressionAllowCall = function () {
     2878                var startToken = this.lookahead;
     2879                var maybeAsync = this.matchContextualKeyword('async');
     2880                var previousAllowIn = this.context.allowIn;
     2881                this.context.allowIn = true;
     2882                var expr;
     2883                if (this.matchKeyword('super') && this.context.inFunctionBody) {
     2884                    expr = this.createNode();
     2885                    this.nextToken();
     2886                    expr = this.finalize(expr, new Node.Super());
     2887                    if (!this.match('(') && !this.match('.') && !this.match('[')) {
     2888                        this.throwUnexpectedToken(this.lookahead);
     2889                    }
     2890                }
     2891                else {
     2892                    expr = this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
     2893                }
     2894                while (true) {
     2895                    if (this.match('.')) {
     2896                        this.context.isBindingElement = false;
     2897                        this.context.isAssignmentTarget = true;
     2898                        this.expect('.');
     2899                        var property = this.parseIdentifierName();
     2900                        expr = this.finalize(this.startNode(startToken), new Node.StaticMemberExpression(expr, property));
     2901                    }
     2902                    else if (this.match('(')) {
     2903                        var asyncArrow = maybeAsync && (startToken.lineNumber === this.lookahead.lineNumber);
     2904                        this.context.isBindingElement = false;
     2905                        this.context.isAssignmentTarget = false;
     2906                        var args = asyncArrow ? this.parseAsyncArguments() : this.parseArguments();
     2907                        expr = this.finalize(this.startNode(startToken), new Node.CallExpression(expr, args));
     2908                        if (asyncArrow && this.match('=>')) {
     2909                            for (var i = 0; i < args.length; ++i) {
     2910                                this.reinterpretExpressionAsPattern(args[i]);
     2911                            }
     2912                            expr = {
     2913                                type: ArrowParameterPlaceHolder,
     2914                                params: args,
     2915                                async: true
     2916                            };
     2917                        }
     2918                    }
     2919                    else if (this.match('[')) {
     2920                        this.context.isBindingElement = false;
     2921                        this.context.isAssignmentTarget = true;
     2922                        this.expect('[');
     2923                        var property = this.isolateCoverGrammar(this.parseExpression);
     2924                        this.expect(']');
     2925                        expr = this.finalize(this.startNode(startToken), new Node.ComputedMemberExpression(expr, property));
     2926                    }
     2927                    else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
     2928                        var quasi = this.parseTemplateLiteral();
     2929                        expr = this.finalize(this.startNode(startToken), new Node.TaggedTemplateExpression(expr, quasi));
     2930                    }
     2931                    else {
     2932                        break;
     2933                    }
     2934                }
     2935                this.context.allowIn = previousAllowIn;
     2936                return expr;
     2937            };
     2938            Parser.prototype.parseSuper = function () {
     2939                var node = this.createNode();
     2940                this.expectKeyword('super');
     2941                if (!this.match('[') && !this.match('.')) {
     2942                    this.throwUnexpectedToken(this.lookahead);
     2943                }
     2944                return this.finalize(node, new Node.Super());
     2945            };
     2946            Parser.prototype.parseLeftHandSideExpression = function () {
     2947                assert_1.assert(this.context.allowIn, 'callee of new expression always allow in keyword.');
     2948                var node = this.startNode(this.lookahead);
     2949                var expr = (this.matchKeyword('super') && this.context.inFunctionBody) ? this.parseSuper() :
     2950                    this.inheritCoverGrammar(this.matchKeyword('new') ? this.parseNewExpression : this.parsePrimaryExpression);
     2951                while (true) {
     2952                    if (this.match('[')) {
     2953                        this.context.isBindingElement = false;
     2954                        this.context.isAssignmentTarget = true;
     2955                        this.expect('[');
     2956                        var property = this.isolateCoverGrammar(this.parseExpression);
     2957                        this.expect(']');
     2958                        expr = this.finalize(node, new Node.ComputedMemberExpression(expr, property));
     2959                    }
     2960                    else if (this.match('.')) {
     2961                        this.context.isBindingElement = false;
     2962                        this.context.isAssignmentTarget = true;
     2963                        this.expect('.');
     2964                        var property = this.parseIdentifierName();
     2965                        expr = this.finalize(node, new Node.StaticMemberExpression(expr, property));
     2966                    }
     2967                    else if (this.lookahead.type === 10 /* Template */ && this.lookahead.head) {
     2968                        var quasi = this.parseTemplateLiteral();
     2969                        expr = this.finalize(node, new Node.TaggedTemplateExpression(expr, quasi));
     2970                    }
     2971                    else {
     2972                        break;
     2973                    }
     2974                }
     2975                return expr;
     2976            };
     2977            // https://tc39.github.io/ecma262/#sec-update-expressions
     2978            Parser.prototype.parseUpdateExpression = function () {
     2979                var expr;
     2980                var startToken = this.lookahead;
     2981                if (this.match('++') || this.match('--')) {
     2982                    var node = this.startNode(startToken);
     2983                    var token = this.nextToken();
     2984                    expr = this.inheritCoverGrammar(this.parseUnaryExpression);
     2985                    if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
     2986                        this.tolerateError(messages_1.Messages.StrictLHSPrefix);
     2987                    }
     2988                    if (!this.context.isAssignmentTarget) {
     2989                        this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
     2990                    }
     2991                    var prefix = true;
     2992                    expr = this.finalize(node, new Node.UpdateExpression(token.value, expr, prefix));
     2993                    this.context.isAssignmentTarget = false;
     2994                    this.context.isBindingElement = false;
     2995                }
     2996                else {
     2997                    expr = this.inheritCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
     2998                    if (!this.hasLineTerminator && this.lookahead.type === 7 /* Punctuator */) {
     2999                        if (this.match('++') || this.match('--')) {
     3000                            if (this.context.strict && expr.type === syntax_1.Syntax.Identifier && this.scanner.isRestrictedWord(expr.name)) {
     3001                                this.tolerateError(messages_1.Messages.StrictLHSPostfix);
     3002                            }
     3003                            if (!this.context.isAssignmentTarget) {
     3004                                this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
     3005                            }
     3006                            this.context.isAssignmentTarget = false;
     3007                            this.context.isBindingElement = false;
     3008                            var operator = this.nextToken().value;
     3009                            var prefix = false;
     3010                            expr = this.finalize(this.startNode(startToken), new Node.UpdateExpression(operator, expr, prefix));
     3011                        }
     3012                    }
     3013                }
     3014                return expr;
     3015            };
     3016            // https://tc39.github.io/ecma262/#sec-unary-operators
     3017            Parser.prototype.parseAwaitExpression = function () {
     3018                var node = this.createNode();
     3019                this.nextToken();
     3020                var argument = this.parseUnaryExpression();
     3021                return this.finalize(node, new Node.AwaitExpression(argument));
     3022            };
     3023            Parser.prototype.parseUnaryExpression = function () {
     3024                var expr;
     3025                if (this.match('+') || this.match('-') || this.match('~') || this.match('!') ||
     3026                    this.matchKeyword('delete') || this.matchKeyword('void') || this.matchKeyword('typeof')) {
     3027                    var node = this.startNode(this.lookahead);
     3028                    var token = this.nextToken();
     3029                    expr = this.inheritCoverGrammar(this.parseUnaryExpression);
     3030                    expr = this.finalize(node, new Node.UnaryExpression(token.value, expr));
     3031                    if (this.context.strict && expr.operator === 'delete' && expr.argument.type === syntax_1.Syntax.Identifier) {
     3032                        this.tolerateError(messages_1.Messages.StrictDelete);
     3033                    }
     3034                    this.context.isAssignmentTarget = false;
     3035                    this.context.isBindingElement = false;
     3036                }
     3037                else if (this.context.await && this.matchContextualKeyword('await')) {
     3038                    expr = this.parseAwaitExpression();
     3039                }
     3040                else {
     3041                    expr = this.parseUpdateExpression();
     3042                }
     3043                return expr;
     3044            };
     3045            Parser.prototype.parseExponentiationExpression = function () {
     3046                var startToken = this.lookahead;
     3047                var expr = this.inheritCoverGrammar(this.parseUnaryExpression);
     3048                if (expr.type !== syntax_1.Syntax.UnaryExpression && this.match('**')) {
     3049                    this.nextToken();
     3050                    this.context.isAssignmentTarget = false;
     3051                    this.context.isBindingElement = false;
     3052                    var left = expr;
     3053                    var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
     3054                    expr = this.finalize(this.startNode(startToken), new Node.BinaryExpression('**', left, right));
     3055                }
     3056                return expr;
     3057            };
     3058            // https://tc39.github.io/ecma262/#sec-exp-operator
     3059            // https://tc39.github.io/ecma262/#sec-multiplicative-operators
     3060            // https://tc39.github.io/ecma262/#sec-additive-operators
     3061            // https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
     3062            // https://tc39.github.io/ecma262/#sec-relational-operators
     3063            // https://tc39.github.io/ecma262/#sec-equality-operators
     3064            // https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
     3065            // https://tc39.github.io/ecma262/#sec-binary-logical-operators
     3066            Parser.prototype.binaryPrecedence = function (token) {
     3067                var op = token.value;
     3068                var precedence;
     3069                if (token.type === 7 /* Punctuator */) {
     3070                    precedence = this.operatorPrecedence[op] || 0;
     3071                }
     3072                else if (token.type === 4 /* Keyword */) {
     3073                    precedence = (op === 'instanceof' || (this.context.allowIn && op === 'in')) ? 7 : 0;
     3074                }
     3075                else {
     3076                    precedence = 0;
     3077                }
     3078                return precedence;
     3079            };
     3080            Parser.prototype.parseBinaryExpression = function () {
     3081                var startToken = this.lookahead;
     3082                var expr = this.inheritCoverGrammar(this.parseExponentiationExpression);
     3083                var token = this.lookahead;
     3084                var prec = this.binaryPrecedence(token);
     3085                if (prec > 0) {
     3086                    this.nextToken();
     3087                    this.context.isAssignmentTarget = false;
     3088                    this.context.isBindingElement = false;
     3089                    var markers = [startToken, this.lookahead];
     3090                    var left = expr;
     3091                    var right = this.isolateCoverGrammar(this.parseExponentiationExpression);
     3092                    var stack = [left, token.value, right];
     3093                    var precedences = [prec];
     3094                    while (true) {
     3095                        prec = this.binaryPrecedence(this.lookahead);
     3096                        if (prec <= 0) {
     3097                            break;
     3098                        }
     3099                        // Reduce: make a binary expression from the three topmost entries.
     3100                        while ((stack.length > 2) && (prec <= precedences[precedences.length - 1])) {
     3101                            right = stack.pop();
     3102                            var operator = stack.pop();
     3103                            precedences.pop();
     3104                            left = stack.pop();
     3105                            markers.pop();
     3106                            var node = this.startNode(markers[markers.length - 1]);
     3107                            stack.push(this.finalize(node, new Node.BinaryExpression(operator, left, right)));
     3108                        }
     3109                        // Shift.
     3110                        stack.push(this.nextToken().value);
     3111                        precedences.push(prec);
     3112                        markers.push(this.lookahead);
     3113                        stack.push(this.isolateCoverGrammar(this.parseExponentiationExpression));
     3114                    }
     3115                    // Final reduce to clean-up the stack.
     3116                    var i = stack.length - 1;
     3117                    expr = stack[i];
     3118                    markers.pop();
     3119                    while (i > 1) {
     3120                        var node = this.startNode(markers.pop());
     3121                        var operator = stack[i - 1];
     3122                        expr = this.finalize(node, new Node.BinaryExpression(operator, stack[i - 2], expr));
     3123                        i -= 2;
     3124                    }
     3125                }
     3126                return expr;
     3127            };
     3128            // https://tc39.github.io/ecma262/#sec-conditional-operator
     3129            Parser.prototype.parseConditionalExpression = function () {
     3130                var startToken = this.lookahead;
     3131                var expr = this.inheritCoverGrammar(this.parseBinaryExpression);
     3132                if (this.match('?')) {
     3133                    this.nextToken();
     3134                    var previousAllowIn = this.context.allowIn;
     3135                    this.context.allowIn = true;
     3136                    var consequent = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3137                    this.context.allowIn = previousAllowIn;
     3138                    this.expect(':');
     3139                    var alternate = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3140                    expr = this.finalize(this.startNode(startToken), new Node.ConditionalExpression(expr, consequent, alternate));
     3141                    this.context.isAssignmentTarget = false;
     3142                    this.context.isBindingElement = false;
     3143                }
     3144                return expr;
     3145            };
     3146            // https://tc39.github.io/ecma262/#sec-assignment-operators
     3147            Parser.prototype.checkPatternParam = function (options, param) {
     3148                switch (param.type) {
     3149                    case syntax_1.Syntax.Identifier:
     3150                        this.validateParam(options, param, param.name);
     3151                        break;
     3152                    case syntax_1.Syntax.RestElement:
     3153                        this.checkPatternParam(options, param.argument);
     3154                        break;
     3155                    case syntax_1.Syntax.AssignmentPattern:
     3156                        this.checkPatternParam(options, param.left);
     3157                        break;
     3158                    case syntax_1.Syntax.ArrayPattern:
     3159                        for (var i = 0; i < param.elements.length; i++) {
     3160                            if (param.elements[i] !== null) {
     3161                                this.checkPatternParam(options, param.elements[i]);
     3162                            }
     3163                        }
     3164                        break;
     3165                    case syntax_1.Syntax.ObjectPattern:
     3166                        for (var i = 0; i < param.properties.length; i++) {
     3167                            this.checkPatternParam(options, param.properties[i].value);
     3168                        }
     3169                        break;
     3170                    default:
     3171                        break;
     3172                }
     3173                options.simple = options.simple && (param instanceof Node.Identifier);
     3174            };
     3175            Parser.prototype.reinterpretAsCoverFormalsList = function (expr) {
     3176                var params = [expr];
     3177                var options;
     3178                var asyncArrow = false;
     3179                switch (expr.type) {
     3180                    case syntax_1.Syntax.Identifier:
     3181                        break;
     3182                    case ArrowParameterPlaceHolder:
     3183                        params = expr.params;
     3184                        asyncArrow = expr.async;
     3185                        break;
     3186                    default:
     3187                        return null;
     3188                }
     3189                options = {
     3190                    simple: true,
     3191                    paramSet: {}
     3192                };
     3193                for (var i = 0; i < params.length; ++i) {
     3194                    var param = params[i];
     3195                    if (param.type === syntax_1.Syntax.AssignmentPattern) {
     3196                        if (param.right.type === syntax_1.Syntax.YieldExpression) {
     3197                            if (param.right.argument) {
     3198                                this.throwUnexpectedToken(this.lookahead);
     3199                            }
     3200                            param.right.type = syntax_1.Syntax.Identifier;
     3201                            param.right.name = 'yield';
     3202                            delete param.right.argument;
     3203                            delete param.right.delegate;
     3204                        }
     3205                    }
     3206                    else if (asyncArrow && param.type === syntax_1.Syntax.Identifier && param.name === 'await') {
     3207                        this.throwUnexpectedToken(this.lookahead);
     3208                    }
     3209                    this.checkPatternParam(options, param);
     3210                    params[i] = param;
     3211                }
     3212                if (this.context.strict || !this.context.allowYield) {
     3213                    for (var i = 0; i < params.length; ++i) {
     3214                        var param = params[i];
     3215                        if (param.type === syntax_1.Syntax.YieldExpression) {
     3216                            this.throwUnexpectedToken(this.lookahead);
     3217                        }
     3218                    }
     3219                }
     3220                if (options.message === messages_1.Messages.StrictParamDupe) {
     3221                    var token = this.context.strict ? options.stricted : options.firstRestricted;
     3222                    this.throwUnexpectedToken(token, options.message);
     3223                }
     3224                return {
     3225                    simple: options.simple,
     3226                    params: params,
     3227                    stricted: options.stricted,
     3228                    firstRestricted: options.firstRestricted,
     3229                    message: options.message
     3230                };
     3231            };
     3232            Parser.prototype.parseAssignmentExpression = function () {
     3233                var expr;
     3234                if (!this.context.allowYield && this.matchKeyword('yield')) {
     3235                    expr = this.parseYieldExpression();
     3236                }
     3237                else {
     3238                    var startToken = this.lookahead;
     3239                    var token = startToken;
     3240                    expr = this.parseConditionalExpression();
     3241                    if (token.type === 3 /* Identifier */ && (token.lineNumber === this.lookahead.lineNumber) && token.value === 'async') {
     3242                        if (this.lookahead.type === 3 /* Identifier */ || this.matchKeyword('yield')) {
     3243                            var arg = this.parsePrimaryExpression();
     3244                            this.reinterpretExpressionAsPattern(arg);
     3245                            expr = {
     3246                                type: ArrowParameterPlaceHolder,
     3247                                params: [arg],
     3248                                async: true
     3249                            };
     3250                        }
     3251                    }
     3252                    if (expr.type === ArrowParameterPlaceHolder || this.match('=>')) {
     3253                        // https://tc39.github.io/ecma262/#sec-arrow-function-definitions
     3254                        this.context.isAssignmentTarget = false;
     3255                        this.context.isBindingElement = false;
     3256                        var isAsync = expr.async;
     3257                        var list = this.reinterpretAsCoverFormalsList(expr);
     3258                        if (list) {
     3259                            if (this.hasLineTerminator) {
     3260                                this.tolerateUnexpectedToken(this.lookahead);
     3261                            }
     3262                            this.context.firstCoverInitializedNameError = null;
     3263                            var previousStrict = this.context.strict;
     3264                            var previousAllowStrictDirective = this.context.allowStrictDirective;
     3265                            this.context.allowStrictDirective = list.simple;
     3266                            var previousAllowYield = this.context.allowYield;
     3267                            var previousAwait = this.context.await;
     3268                            this.context.allowYield = true;
     3269                            this.context.await = isAsync;
     3270                            var node = this.startNode(startToken);
     3271                            this.expect('=>');
     3272                            var body = void 0;
     3273                            if (this.match('{')) {
     3274                                var previousAllowIn = this.context.allowIn;
     3275                                this.context.allowIn = true;
     3276                                body = this.parseFunctionSourceElements();
     3277                                this.context.allowIn = previousAllowIn;
     3278                            }
     3279                            else {
     3280                                body = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3281                            }
     3282                            var expression = body.type !== syntax_1.Syntax.BlockStatement;
     3283                            if (this.context.strict && list.firstRestricted) {
     3284                                this.throwUnexpectedToken(list.firstRestricted, list.message);
     3285                            }
     3286                            if (this.context.strict && list.stricted) {
     3287                                this.tolerateUnexpectedToken(list.stricted, list.message);
     3288                            }
     3289                            expr = isAsync ? this.finalize(node, new Node.AsyncArrowFunctionExpression(list.params, body, expression)) :
     3290                                this.finalize(node, new Node.ArrowFunctionExpression(list.params, body, expression));
     3291                            this.context.strict = previousStrict;
     3292                            this.context.allowStrictDirective = previousAllowStrictDirective;
     3293                            this.context.allowYield = previousAllowYield;
     3294                            this.context.await = previousAwait;
     3295                        }
     3296                    }
     3297                    else {
     3298                        if (this.matchAssign()) {
     3299                            if (!this.context.isAssignmentTarget) {
     3300                                this.tolerateError(messages_1.Messages.InvalidLHSInAssignment);
     3301                            }
     3302                            if (this.context.strict && expr.type === syntax_1.Syntax.Identifier) {
     3303                                var id = expr;
     3304                                if (this.scanner.isRestrictedWord(id.name)) {
     3305                                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictLHSAssignment);
     3306                                }
     3307                                if (this.scanner.isStrictModeReservedWord(id.name)) {
     3308                                    this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
     3309                                }
     3310                            }
     3311                            if (!this.match('=')) {
     3312                                this.context.isAssignmentTarget = false;
     3313                                this.context.isBindingElement = false;
     3314                            }
     3315                            else {
     3316                                this.reinterpretExpressionAsPattern(expr);
     3317                            }
     3318                            token = this.nextToken();
     3319                            var operator = token.value;
     3320                            var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3321                            expr = this.finalize(this.startNode(startToken), new Node.AssignmentExpression(operator, expr, right));
     3322                            this.context.firstCoverInitializedNameError = null;
     3323                        }
     3324                    }
     3325                }
     3326                return expr;
     3327            };
     3328            // https://tc39.github.io/ecma262/#sec-comma-operator
     3329            Parser.prototype.parseExpression = function () {
     3330                var startToken = this.lookahead;
     3331                var expr = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3332                if (this.match(',')) {
     3333                    var expressions = [];
     3334                    expressions.push(expr);
     3335                    while (this.lookahead.type !== 2 /* EOF */) {
     3336                        if (!this.match(',')) {
     3337                            break;
     3338                        }
     3339                        this.nextToken();
     3340                        expressions.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
     3341                    }
     3342                    expr = this.finalize(this.startNode(startToken), new Node.SequenceExpression(expressions));
     3343                }
     3344                return expr;
     3345            };
     3346            // https://tc39.github.io/ecma262/#sec-block
     3347            Parser.prototype.parseStatementListItem = function () {
     3348                var statement;
     3349                this.context.isAssignmentTarget = true;
     3350                this.context.isBindingElement = true;
     3351                if (this.lookahead.type === 4 /* Keyword */) {
     3352                    switch (this.lookahead.value) {
     3353                        case 'export':
     3354                            if (!this.context.isModule) {
     3355                                this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalExportDeclaration);
     3356                            }
     3357                            statement = this.parseExportDeclaration();
     3358                            break;
     3359                        case 'import':
     3360                            if (!this.context.isModule) {
     3361                                this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.IllegalImportDeclaration);
     3362                            }
     3363                            statement = this.parseImportDeclaration();
     3364                            break;
     3365                        case 'const':
     3366                            statement = this.parseLexicalDeclaration({ inFor: false });
     3367                            break;
     3368                        case 'function':
     3369                            statement = this.parseFunctionDeclaration();
     3370                            break;
     3371                        case 'class':
     3372                            statement = this.parseClassDeclaration();
     3373                            break;
     3374                        case 'let':
     3375                            statement = this.isLexicalDeclaration() ? this.parseLexicalDeclaration({ inFor: false }) : this.parseStatement();
     3376                            break;
     3377                        default:
     3378                            statement = this.parseStatement();
     3379                            break;
     3380                    }
     3381                }
     3382                else {
     3383                    statement = this.parseStatement();
     3384                }
     3385                return statement;
     3386            };
     3387            Parser.prototype.parseBlock = function () {
     3388                var node = this.createNode();
     3389                this.expect('{');
     3390                var block = [];
     3391                while (true) {
     3392                    if (this.match('}')) {
     3393                        break;
     3394                    }
     3395                    block.push(this.parseStatementListItem());
     3396                }
     3397                this.expect('}');
     3398                return this.finalize(node, new Node.BlockStatement(block));
     3399            };
     3400            // https://tc39.github.io/ecma262/#sec-let-and-const-declarations
     3401            Parser.prototype.parseLexicalBinding = function (kind, options) {
     3402                var node = this.createNode();
     3403                var params = [];
     3404                var id = this.parsePattern(params, kind);
     3405                if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
     3406                    if (this.scanner.isRestrictedWord(id.name)) {
     3407                        this.tolerateError(messages_1.Messages.StrictVarName);
     3408                    }
     3409                }
     3410                var init = null;
     3411                if (kind === 'const') {
     3412                    if (!this.matchKeyword('in') && !this.matchContextualKeyword('of')) {
     3413                        if (this.match('=')) {
     3414                            this.nextToken();
     3415                            init = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3416                        }
     3417                        else {
     3418                            this.throwError(messages_1.Messages.DeclarationMissingInitializer, 'const');
     3419                        }
     3420                    }
     3421                }
     3422                else if ((!options.inFor && id.type !== syntax_1.Syntax.Identifier) || this.match('=')) {
     3423                    this.expect('=');
     3424                    init = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3425                }
     3426                return this.finalize(node, new Node.VariableDeclarator(id, init));
     3427            };
     3428            Parser.prototype.parseBindingList = function (kind, options) {
     3429                var list = [this.parseLexicalBinding(kind, options)];
     3430                while (this.match(',')) {
     3431                    this.nextToken();
     3432                    list.push(this.parseLexicalBinding(kind, options));
     3433                }
     3434                return list;
     3435            };
     3436            Parser.prototype.isLexicalDeclaration = function () {
     3437                var state = this.scanner.saveState();
     3438                this.scanner.scanComments();
     3439                var next = this.scanner.lex();
     3440                this.scanner.restoreState(state);
     3441                return (next.type === 3 /* Identifier */) ||
     3442                    (next.type === 7 /* Punctuator */ && next.value === '[') ||
     3443                    (next.type === 7 /* Punctuator */ && next.value === '{') ||
     3444                    (next.type === 4 /* Keyword */ && next.value === 'let') ||
     3445                    (next.type === 4 /* Keyword */ && next.value === 'yield');
     3446            };
     3447            Parser.prototype.parseLexicalDeclaration = function (options) {
     3448                var node = this.createNode();
     3449                var kind = this.nextToken().value;
     3450                assert_1.assert(kind === 'let' || kind === 'const', 'Lexical declaration must be either let or const');
     3451                var declarations = this.parseBindingList(kind, options);
     3452                this.consumeSemicolon();
     3453                return this.finalize(node, new Node.VariableDeclaration(declarations, kind));
     3454            };
     3455            // https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns
     3456            Parser.prototype.parseBindingRestElement = function (params, kind) {
     3457                var node = this.createNode();
     3458                this.expect('...');
     3459                var arg = this.parsePattern(params, kind);
     3460                return this.finalize(node, new Node.RestElement(arg));
     3461            };
     3462            Parser.prototype.parseArrayPattern = function (params, kind) {
     3463                var node = this.createNode();
     3464                this.expect('[');
     3465                var elements = [];
     3466                while (!this.match(']')) {
     3467                    if (this.match(',')) {
     3468                        this.nextToken();
     3469                        elements.push(null);
     3470                    }
     3471                    else {
     3472                        if (this.match('...')) {
     3473                            elements.push(this.parseBindingRestElement(params, kind));
     3474                            break;
     3475                        }
     3476                        else {
     3477                            elements.push(this.parsePatternWithDefault(params, kind));
     3478                        }
     3479                        if (!this.match(']')) {
     3480                            this.expect(',');
     3481                        }
     3482                    }
     3483                }
     3484                this.expect(']');
     3485                return this.finalize(node, new Node.ArrayPattern(elements));
     3486            };
     3487            Parser.prototype.parsePropertyPattern = function (params, kind) {
     3488                var node = this.createNode();
     3489                var computed = false;
     3490                var shorthand = false;
     3491                var method = false;
     3492                var key;
     3493                var value;
     3494                if (this.lookahead.type === 3 /* Identifier */) {
     3495                    var keyToken = this.lookahead;
     3496                    key = this.parseVariableIdentifier();
     3497                    var init = this.finalize(node, new Node.Identifier(keyToken.value));
     3498                    if (this.match('=')) {
     3499                        params.push(keyToken);
     3500                        shorthand = true;
     3501                        this.nextToken();
     3502                        var expr = this.parseAssignmentExpression();
     3503                        value = this.finalize(this.startNode(keyToken), new Node.AssignmentPattern(init, expr));
     3504                    }
     3505                    else if (!this.match(':')) {
     3506                        params.push(keyToken);
     3507                        shorthand = true;
     3508                        value = init;
     3509                    }
     3510                    else {
     3511                        this.expect(':');
     3512                        value = this.parsePatternWithDefault(params, kind);
     3513                    }
     3514                }
     3515                else {
     3516                    computed = this.match('[');
     3517                    key = this.parseObjectPropertyKey();
     3518                    this.expect(':');
     3519                    value = this.parsePatternWithDefault(params, kind);
     3520                }
     3521                return this.finalize(node, new Node.Property('init', key, computed, value, method, shorthand));
     3522            };
     3523            Parser.prototype.parseObjectPattern = function (params, kind) {
     3524                var node = this.createNode();
     3525                var properties = [];
     3526                this.expect('{');
     3527                while (!this.match('}')) {
     3528                    properties.push(this.parsePropertyPattern(params, kind));
     3529                    if (!this.match('}')) {
     3530                        this.expect(',');
     3531                    }
     3532                }
     3533                this.expect('}');
     3534                return this.finalize(node, new Node.ObjectPattern(properties));
     3535            };
     3536            Parser.prototype.parsePattern = function (params, kind) {
     3537                var pattern;
     3538                if (this.match('[')) {
     3539                    pattern = this.parseArrayPattern(params, kind);
     3540                }
     3541                else if (this.match('{')) {
     3542                    pattern = this.parseObjectPattern(params, kind);
     3543                }
     3544                else {
     3545                    if (this.matchKeyword('let') && (kind === 'const' || kind === 'let')) {
     3546                        this.tolerateUnexpectedToken(this.lookahead, messages_1.Messages.LetInLexicalBinding);
     3547                    }
     3548                    params.push(this.lookahead);
     3549                    pattern = this.parseVariableIdentifier(kind);
     3550                }
     3551                return pattern;
     3552            };
     3553            Parser.prototype.parsePatternWithDefault = function (params, kind) {
     3554                var startToken = this.lookahead;
     3555                var pattern = this.parsePattern(params, kind);
     3556                if (this.match('=')) {
     3557                    this.nextToken();
     3558                    var previousAllowYield = this.context.allowYield;
     3559                    this.context.allowYield = true;
     3560                    var right = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3561                    this.context.allowYield = previousAllowYield;
     3562                    pattern = this.finalize(this.startNode(startToken), new Node.AssignmentPattern(pattern, right));
     3563                }
     3564                return pattern;
     3565            };
     3566            // https://tc39.github.io/ecma262/#sec-variable-statement
     3567            Parser.prototype.parseVariableIdentifier = function (kind) {
     3568                var node = this.createNode();
     3569                var token = this.nextToken();
     3570                if (token.type === 4 /* Keyword */ && token.value === 'yield') {
     3571                    if (this.context.strict) {
     3572                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
     3573                    }
     3574                    else if (!this.context.allowYield) {
     3575                        this.throwUnexpectedToken(token);
     3576                    }
     3577                }
     3578                else if (token.type !== 3 /* Identifier */) {
     3579                    if (this.context.strict && token.type === 4 /* Keyword */ && this.scanner.isStrictModeReservedWord(token.value)) {
     3580                        this.tolerateUnexpectedToken(token, messages_1.Messages.StrictReservedWord);
     3581                    }
     3582                    else {
     3583                        if (this.context.strict || token.value !== 'let' || kind !== 'var') {
     3584                            this.throwUnexpectedToken(token);
     3585                        }
     3586                    }
     3587                }
     3588                else if ((this.context.isModule || this.context.await) && token.type === 3 /* Identifier */ && token.value === 'await') {
     3589                    this.tolerateUnexpectedToken(token);
     3590                }
     3591                return this.finalize(node, new Node.Identifier(token.value));
     3592            };
     3593            Parser.prototype.parseVariableDeclaration = function (options) {
     3594                var node = this.createNode();
     3595                var params = [];
     3596                var id = this.parsePattern(params, 'var');
     3597                if (this.context.strict && id.type === syntax_1.Syntax.Identifier) {
     3598                    if (this.scanner.isRestrictedWord(id.name)) {
     3599                        this.tolerateError(messages_1.Messages.StrictVarName);
     3600                    }
     3601                }
     3602                var init = null;
     3603                if (this.match('=')) {
     3604                    this.nextToken();
     3605                    init = this.isolateCoverGrammar(this.parseAssignmentExpression);
     3606                }
     3607                else if (id.type !== syntax_1.Syntax.Identifier && !options.inFor) {
     3608                    this.expect('=');
     3609                }
     3610                return this.finalize(node, new Node.VariableDeclarator(id, init));
     3611            };
     3612            Parser.prototype.parseVariableDeclarationList = function (options) {
     3613                var opt = { inFor: options.inFor };
     3614                var list = [];
     3615                list.push(this.parseVariableDeclaration(opt));
     3616                while (this.match(',')) {
     3617                    this.nextToken();
     3618                    list.push(this.parseVariableDeclaration(opt));
     3619                }
     3620                return list;
     3621            };
     3622            Parser.prototype.parseVariableStatement = function () {
     3623                var node = this.createNode();
     3624                this.expectKeyword('var');
     3625                var declarations = this.parseVariableDeclarationList({ inFor: false });
     3626                this.consumeSemicolon();
     3627                return this.finalize(node, new Node.VariableDeclaration(declarations, 'var'));
     3628            };
     3629            // https://tc39.github.io/ecma262/#sec-empty-statement
     3630            Parser.prototype.parseEmptyStatement = function () {
     3631                var node = this.createNode();
     3632                this.expect(';');
     3633                return this.finalize(node, new Node.EmptyStatement());
     3634            };
     3635            // https://tc39.github.io/ecma262/#sec-expression-statement
     3636            Parser.prototype.parseExpressionStatement = function () {
     3637                var node = this.createNode();
     3638                var expr = this.parseExpression();
     3639                this.consumeSemicolon();
     3640                return this.finalize(node, new Node.ExpressionStatement(expr));
     3641            };
     3642            // https://tc39.github.io/ecma262/#sec-if-statement
     3643            Parser.prototype.parseIfClause = function () {
     3644                if (this.context.strict && this.matchKeyword('function')) {
     3645                    this.tolerateError(messages_1.Messages.StrictFunction);
     3646                }
     3647                return this.parseStatement();
     3648            };
     3649            Parser.prototype.parseIfStatement = function () {
     3650                var node = this.createNode();
     3651                var consequent;
     3652                var alternate = null;
     3653                this.expectKeyword('if');
     3654                this.expect('(');
     3655                var test = this.parseExpression();
     3656                if (!this.match(')') && this.config.tolerant) {
     3657                    this.tolerateUnexpectedToken(this.nextToken());
     3658                    consequent = this.finalize(this.createNode(), new Node.EmptyStatement());
     3659                }
     3660                else {
     3661                    this.expect(')');
     3662                    consequent = this.parseIfClause();
     3663                    if (this.matchKeyword('else')) {
     3664                        this.nextToken();
     3665                        alternate = this.parseIfClause();
     3666                    }
     3667                }
     3668                return this.finalize(node, new Node.IfStatement(test, consequent, alternate));
     3669            };
     3670            // https://tc39.github.io/ecma262/#sec-do-while-statement
     3671            Parser.prototype.parseDoWhileStatement = function () {
     3672                var node = this.createNode();
     3673                this.expectKeyword('do');
     3674                var previousInIteration = this.context.inIteration;
     3675                this.context.inIteration = true;
     3676                var body = this.parseStatement();
     3677                this.context.inIteration = previousInIteration;
     3678                this.expectKeyword('while');
     3679                this.expect('(');
     3680                var test = this.parseExpression();
     3681                if (!this.match(')') && this.config.tolerant) {
     3682                    this.tolerateUnexpectedToken(this.nextToken());
     3683                }
     3684                else {
     3685                    this.expect(')');
     3686                    if (this.match(';')) {
     3687                        this.nextToken();
     3688                    }
     3689                }
     3690                return this.finalize(node, new Node.DoWhileStatement(body, test));
     3691            };
     3692            // https://tc39.github.io/ecma262/#sec-while-statement
     3693            Parser.prototype.parseWhileStatement = function () {
     3694                var node = this.createNode();
     3695                var body;
     3696                this.expectKeyword('while');
     3697                this.expect('(');
     3698                var test = this.parseExpression();
     3699                if (!this.match(')') && this.config.tolerant) {
     3700                    this.tolerateUnexpectedToken(this.nextToken());
     3701                    body = this.finalize(this.createNode(), new Node.EmptyStatement());
     3702                }
     3703                else {
     3704                    this.expect(')');
     3705                    var previousInIteration = this.context.inIteration;
     3706                    this.context.inIteration = true;
     3707                    body = this.parseStatement();
     3708                    this.context.inIteration = previousInIteration;
     3709                }
     3710                return this.finalize(node, new Node.WhileStatement(test, body));
     3711            };
     3712            // https://tc39.github.io/ecma262/#sec-for-statement
     3713            // https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements
     3714            Parser.prototype.parseForStatement = function () {
     3715                var init = null;
     3716                var test = null;
     3717                var update = null;
     3718                var forIn = true;
     3719                var left, right;
     3720                var node = this.createNode();
     3721                this.expectKeyword('for');
     3722                this.expect('(');
     3723                if (this.match(';')) {
     3724                    this.nextToken();
     3725                }
     3726                else {
     3727                    if (this.matchKeyword('var')) {
     3728                        init = this.createNode();
     3729                        this.nextToken();
     3730                        var previousAllowIn = this.context.allowIn;
     3731                        this.context.allowIn = false;
     3732                        var declarations = this.parseVariableDeclarationList({ inFor: true });
     3733                        this.context.allowIn = previousAllowIn;
     3734                        if (declarations.length === 1 && this.matchKeyword('in')) {
     3735                            var decl = declarations[0];
     3736                            if (decl.init && (decl.id.type === syntax_1.Syntax.ArrayPattern || decl.id.type === syntax_1.Syntax.ObjectPattern || this.context.strict)) {
     3737                                this.tolerateError(messages_1.Messages.ForInOfLoopInitializer, 'for-in');
     3738                            }
     3739                            init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
     3740                            this.nextToken();
     3741                            left = init;
     3742                            right = this.parseExpression();
     3743                            init = null;
     3744                        }
     3745                        else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
     3746                            init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
     3747                            this.nextToken();
     3748                            left = init;
     3749                            right = this.parseAssignmentExpression();
     3750                            init = null;
     3751                            forIn = false;
     3752                        }
     3753                        else {
     3754                            init = this.finalize(init, new Node.VariableDeclaration(declarations, 'var'));
     3755                            this.expect(';');
     3756                        }
     3757                    }
     3758                    else if (this.matchKeyword('const') || this.matchKeyword('let')) {
     3759                        init = this.createNode();
     3760                        var kind = this.nextToken().value;
     3761                        if (!this.context.strict && this.lookahead.value === 'in') {
     3762                            init = this.finalize(init, new Node.Identifier(kind));
     3763                            this.nextToken();
     3764                            left = init;
     3765                            right = this.parseExpression();
     3766                            init = null;
     3767                        }
     3768                        else {
     3769                            var previousAllowIn = this.context.allowIn;
     3770                            this.context.allowIn = false;
     3771                            var declarations = this.parseBindingList(kind, { inFor: true });
     3772                            this.context.allowIn = previousAllowIn;
     3773                            if (declarations.length === 1 && declarations[0].init === null && this.matchKeyword('in')) {
     3774                                init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
     3775                                this.nextToken();
     3776                                left = init;
     3777                                right = this.parseExpression();
     3778                                init = null;
     3779                            }
     3780                            else if (declarations.length === 1 && declarations[0].init === null && this.matchContextualKeyword('of')) {
     3781                                init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
     3782                                this.nextToken();
     3783                                left = init;
     3784                                right = this.parseAssignmentExpression();
     3785                                init = null;
     3786                                forIn = false;
     3787                            }
     3788                            else {
     3789                                this.consumeSemicolon();
     3790                                init = this.finalize(init, new Node.VariableDeclaration(declarations, kind));
     3791                            }
     3792                        }
     3793                    }
     3794                    else {
     3795                        var initStartToken = this.lookahead;
     3796                        var previousAllowIn = this.context.allowIn;
     3797                        this.context.allowIn = false;
     3798                        init = this.inheritCoverGrammar(this.parseAssignmentExpression);
     3799                        this.context.allowIn = previousAllowIn;
     3800                        if (this.matchKeyword('in')) {
     3801                            if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
     3802                                this.tolerateError(messages_1.Messages.InvalidLHSInForIn);
     3803                            }
     3804                            this.nextToken();
     3805                            this.reinterpretExpressionAsPattern(init);
     3806                            left = init;
     3807                            right = this.parseExpression();
     3808                            init = null;
     3809                        }
     3810                        else if (this.matchContextualKeyword('of')) {
     3811                            if (!this.context.isAssignmentTarget || init.type === syntax_1.Syntax.AssignmentExpression) {
     3812                                this.tolerateError(messages_1.Messages.InvalidLHSInForLoop);
     3813                            }
     3814                            this.nextToken();
     3815                            this.reinterpretExpressionAsPattern(init);
     3816                            left = init;
     3817                            right = this.parseAssignmentExpression();
     3818                            init = null;
     3819                            forIn = false;
     3820                        }
     3821                        else {
     3822                            if (this.match(',')) {
     3823                                var initSeq = [init];
     3824                                while (this.match(',')) {
     3825                                    this.nextToken();
     3826                                    initSeq.push(this.isolateCoverGrammar(this.parseAssignmentExpression));
     3827                                }
     3828                                init = this.finalize(this.startNode(initStartToken), new Node.SequenceExpression(initSeq));
     3829                            }
     3830                            this.expect(';');
     3831                        }
     3832                    }
     3833                }
     3834                if (typeof left === 'undefined') {
     3835                    if (!this.match(';')) {
     3836                        test = this.parseExpression();
     3837                    }
     3838                    this.expect(';');
     3839                    if (!this.match(')')) {
     3840                        update = this.parseExpression();
     3841                    }
     3842                }
     3843                var body;
     3844                if (!this.match(')') && this.config.tolerant) {
     3845                    this.tolerateUnexpectedToken(this.nextToken());
     3846                    body = this.finalize(this.createNode(), new Node.EmptyStatement());
     3847                }
     3848                else {
     3849                    this.expect(')');
     3850                    var previousInIteration = this.context.inIteration;
     3851                    this.context.inIteration = true;
     3852                    body = this.isolateCoverGrammar(this.parseStatement);
     3853                    this.context.inIteration = previousInIteration;
     3854                }
     3855                return (typeof left === 'undefined') ?
     3856                    this.finalize(node, new Node.ForStatement(init, test, update, body)) :
     3857                    forIn ? this.finalize(node, new Node.ForInStatement(left, right, body)) :
     3858                        this.finalize(node, new Node.ForOfStatement(left, right, body));
     3859            };
     3860            // https://tc39.github.io/ecma262/#sec-continue-statement
     3861            Parser.prototype.parseContinueStatement = function () {
     3862                var node = this.createNode();
     3863                this.expectKeyword('continue');
     3864                var label = null;
     3865                if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
     3866                    var id = this.parseVariableIdentifier();
     3867                    label = id;
     3868                    var key = '$' + id.name;
     3869                    if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
     3870                        this.throwError(messages_1.Messages.UnknownLabel, id.name);
     3871                    }
     3872                }
     3873                this.consumeSemicolon();
     3874                if (label === null && !this.context.inIteration) {
     3875                    this.throwError(messages_1.Messages.IllegalContinue);
     3876                }
     3877                return this.finalize(node, new Node.ContinueStatement(label));
     3878            };
     3879            // https://tc39.github.io/ecma262/#sec-break-statement
     3880            Parser.prototype.parseBreakStatement = function () {
     3881                var node = this.createNode();
     3882                this.expectKeyword('break');
     3883                var label = null;
     3884                if (this.lookahead.type === 3 /* Identifier */ && !this.hasLineTerminator) {
     3885                    var id = this.parseVariableIdentifier();
     3886                    var key = '$' + id.name;
     3887                    if (!Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
     3888                        this.throwError(messages_1.Messages.UnknownLabel, id.name);
     3889                    }
     3890                    label = id;
     3891                }
     3892                this.consumeSemicolon();
     3893                if (label === null && !this.context.inIteration && !this.context.inSwitch) {
     3894                    this.throwError(messages_1.Messages.IllegalBreak);
     3895                }
     3896                return this.finalize(node, new Node.BreakStatement(label));
     3897            };
     3898            // https://tc39.github.io/ecma262/#sec-return-statement
     3899            Parser.prototype.parseReturnStatement = function () {
     3900                if (!this.context.inFunctionBody) {
     3901                    this.tolerateError(messages_1.Messages.IllegalReturn);
     3902                }
     3903                var node = this.createNode();
     3904                this.expectKeyword('return');
     3905                var hasArgument = !this.match(';') && !this.match('}') &&
     3906                    !this.hasLineTerminator && this.lookahead.type !== 2 /* EOF */;
     3907                var argument = hasArgument ? this.parseExpression() : null;
     3908                this.consumeSemicolon();
     3909                return this.finalize(node, new Node.ReturnStatement(argument));
     3910            };
     3911            // https://tc39.github.io/ecma262/#sec-with-statement
     3912            Parser.prototype.parseWithStatement = function () {
     3913                if (this.context.strict) {
     3914                    this.tolerateError(messages_1.Messages.StrictModeWith);
     3915                }
     3916                var node = this.createNode();
     3917                var body;
     3918                this.expectKeyword('with');
     3919                this.expect('(');
     3920                var object = this.parseExpression();
     3921                if (!this.match(')') && this.config.tolerant) {
     3922                    this.tolerateUnexpectedToken(this.nextToken());
     3923                    body = this.finalize(this.createNode(), new Node.EmptyStatement());
     3924                }
     3925                else {
     3926                    this.expect(')');
     3927                    body = this.parseStatement();
     3928                }
     3929                return this.finalize(node, new Node.WithStatement(object, body));
     3930            };
     3931            // https://tc39.github.io/ecma262/#sec-switch-statement
     3932            Parser.prototype.parseSwitchCase = function () {
     3933                var node = this.createNode();
     3934                var test;
     3935                if (this.matchKeyword('default')) {
     3936                    this.nextToken();
     3937                    test = null;
     3938                }
     3939                else {
     3940                    this.expectKeyword('case');
     3941                    test = this.parseExpression();
     3942                }
     3943                this.expect(':');
     3944                var consequent = [];
     3945                while (true) {
     3946                    if (this.match('}') || this.matchKeyword('default') || this.matchKeyword('case')) {
     3947                        break;
     3948                    }
     3949                    consequent.push(this.parseStatementListItem());
     3950                }
     3951                return this.finalize(node, new Node.SwitchCase(test, consequent));
     3952            };
     3953            Parser.prototype.parseSwitchStatement = function () {
     3954                var node = this.createNode();
     3955                this.expectKeyword('switch');
     3956                this.expect('(');
     3957                var discriminant = this.parseExpression();
     3958                this.expect(')');
     3959                var previousInSwitch = this.context.inSwitch;
     3960                this.context.inSwitch = true;
     3961                var cases = [];
     3962                var defaultFound = false;
     3963                this.expect('{');
     3964                while (true) {
     3965                    if (this.match('}')) {
     3966                        break;
     3967                    }
     3968                    var clause = this.parseSwitchCase();
     3969                    if (clause.test === null) {
     3970                        if (defaultFound) {
     3971                            this.throwError(messages_1.Messages.MultipleDefaultsInSwitch);
     3972                        }
     3973                        defaultFound = true;
     3974                    }
     3975                    cases.push(clause);
     3976                }
     3977                this.expect('}');
     3978                this.context.inSwitch = previousInSwitch;
     3979                return this.finalize(node, new Node.SwitchStatement(discriminant, cases));
     3980            };
     3981            // https://tc39.github.io/ecma262/#sec-labelled-statements
     3982            Parser.prototype.parseLabelledStatement = function () {
     3983                var node = this.createNode();
     3984                var expr = this.parseExpression();
     3985                var statement;
     3986                if ((expr.type === syntax_1.Syntax.Identifier) && this.match(':')) {
     3987                    this.nextToken();
     3988                    var id = expr;
     3989                    var key = '$' + id.name;
     3990                    if (Object.prototype.hasOwnProperty.call(this.context.labelSet, key)) {
     3991                        this.throwError(messages_1.Messages.Redeclaration, 'Label', id.name);
     3992                    }
     3993                    this.context.labelSet[key] = true;
     3994                    var body = void 0;
     3995                    if (this.matchKeyword('class')) {
     3996                        this.tolerateUnexpectedToken(this.lookahead);
     3997                        body = this.parseClassDeclaration();
     3998                    }
     3999                    else if (this.matchKeyword('function')) {
     4000                        var token = this.lookahead;
     4001                        var declaration = this.parseFunctionDeclaration();
     4002                        if (this.context.strict) {
     4003                            this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunction);
     4004                        }
     4005                        else if (declaration.generator) {
     4006                            this.tolerateUnexpectedToken(token, messages_1.Messages.GeneratorInLegacyContext);
     4007                        }
     4008                        body = declaration;
     4009                    }
     4010                    else {
     4011                        body = this.parseStatement();
     4012                    }
     4013                    delete this.context.labelSet[key];
     4014                    statement = new Node.LabeledStatement(id, body);
     4015                }
     4016                else {
     4017                    this.consumeSemicolon();
     4018                    statement = new Node.ExpressionStatement(expr);
     4019                }
     4020                return this.finalize(node, statement);
     4021            };
     4022            // https://tc39.github.io/ecma262/#sec-throw-statement
     4023            Parser.prototype.parseThrowStatement = function () {
     4024                var node = this.createNode();
     4025                this.expectKeyword('throw');
     4026                if (this.hasLineTerminator) {
     4027                    this.throwError(messages_1.Messages.NewlineAfterThrow);
     4028                }
     4029                var argument = this.parseExpression();
     4030                this.consumeSemicolon();
     4031                return this.finalize(node, new Node.ThrowStatement(argument));
     4032            };
     4033            // https://tc39.github.io/ecma262/#sec-try-statement
     4034            Parser.prototype.parseCatchClause = function () {
     4035                var node = this.createNode();
     4036                this.expectKeyword('catch');
     4037                this.expect('(');
     4038                if (this.match(')')) {
     4039                    this.throwUnexpectedToken(this.lookahead);
     4040                }
     4041                var params = [];
     4042                var param = this.parsePattern(params);
     4043                var paramMap = {};
     4044                for (var i = 0; i < params.length; i++) {
     4045                    var key = '$' + params[i].value;
     4046                    if (Object.prototype.hasOwnProperty.call(paramMap, key)) {
     4047                        this.tolerateError(messages_1.Messages.DuplicateBinding, params[i].value);
     4048                    }
     4049                    paramMap[key] = true;
     4050                }
     4051                if (this.context.strict && param.type === syntax_1.Syntax.Identifier) {
     4052                    if (this.scanner.isRestrictedWord(param.name)) {
     4053                        this.tolerateError(messages_1.Messages.StrictCatchVariable);
     4054                    }
     4055                }
     4056                this.expect(')');
     4057                var body = this.parseBlock();
     4058                return this.finalize(node, new Node.CatchClause(param, body));
     4059            };
     4060            Parser.prototype.parseFinallyClause = function () {
     4061                this.expectKeyword('finally');
     4062                return this.parseBlock();
     4063            };
     4064            Parser.prototype.parseTryStatement = function () {
     4065                var node = this.createNode();
     4066                this.expectKeyword('try');
     4067                var block = this.parseBlock();
     4068                var handler = this.matchKeyword('catch') ? this.parseCatchClause() : null;
     4069                var finalizer = this.matchKeyword('finally') ? this.parseFinallyClause() : null;
     4070                if (!handler && !finalizer) {
     4071                    this.throwError(messages_1.Messages.NoCatchOrFinally);
     4072                }
     4073                return this.finalize(node, new Node.TryStatement(block, handler, finalizer));
     4074            };
     4075            // https://tc39.github.io/ecma262/#sec-debugger-statement
     4076            Parser.prototype.parseDebuggerStatement = function () {
     4077                var node = this.createNode();
     4078                this.expectKeyword('debugger');
     4079                this.consumeSemicolon();
     4080                return this.finalize(node, new Node.DebuggerStatement());
     4081            };
     4082            // https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
     4083            Parser.prototype.parseStatement = function () {
     4084                var statement;
     4085                switch (this.lookahead.type) {
     4086                    case 1 /* BooleanLiteral */:
     4087                    case 5 /* NullLiteral */:
     4088                    case 6 /* NumericLiteral */:
     4089                    case 8 /* StringLiteral */:
     4090                    case 10 /* Template */:
     4091                    case 9 /* RegularExpression */:
     4092                        statement = this.parseExpressionStatement();
     4093                        break;
     4094                    case 7 /* Punctuator */:
     4095                        var value = this.lookahead.value;
     4096                        if (value === '{') {
     4097                            statement = this.parseBlock();
     4098                        }
     4099                        else if (value === '(') {
     4100                            statement = this.parseExpressionStatement();
     4101                        }
     4102                        else if (value === ';') {
     4103                            statement = this.parseEmptyStatement();
     4104                        }
     4105                        else {
     4106                            statement = this.parseExpressionStatement();
     4107                        }
     4108                        break;
     4109                    case 3 /* Identifier */:
     4110                        statement = this.matchAsyncFunction() ? this.parseFunctionDeclaration() : this.parseLabelledStatement();
     4111                        break;
     4112                    case 4 /* Keyword */:
     4113                        switch (this.lookahead.value) {
     4114                            case 'break':
     4115                                statement = this.parseBreakStatement();
     4116                                break;
     4117                            case 'continue':
     4118                                statement = this.parseContinueStatement();
     4119                                break;
     4120                            case 'debugger':
     4121                                statement = this.parseDebuggerStatement();
     4122                                break;
     4123                            case 'do':
     4124                                statement = this.parseDoWhileStatement();
     4125                                break;
     4126                            case 'for':
     4127                                statement = this.parseForStatement();
     4128                                break;
     4129                            case 'function':
     4130                                statement = this.parseFunctionDeclaration();
     4131                                break;
     4132                            case 'if':
     4133                                statement = this.parseIfStatement();
     4134                                break;
     4135                            case 'return':
     4136                                statement = this.parseReturnStatement();
     4137                                break;
     4138                            case 'switch':
     4139                                statement = this.parseSwitchStatement();
     4140                                break;
     4141                            case 'throw':
     4142                                statement = this.parseThrowStatement();
     4143                                break;
     4144                            case 'try':
     4145                                statement = this.parseTryStatement();
     4146                                break;
     4147                            case 'var':
     4148                                statement = this.parseVariableStatement();
     4149                                break;
     4150                            case 'while':
     4151                                statement = this.parseWhileStatement();
     4152                                break;
     4153                            case 'with':
     4154                                statement = this.parseWithStatement();
     4155                                break;
     4156                            default:
     4157                                statement = this.parseExpressionStatement();
     4158                                break;
     4159                        }
     4160                        break;
     4161                    default:
     4162                        statement = this.throwUnexpectedToken(this.lookahead);
     4163                }
     4164                return statement;
     4165            };
     4166            // https://tc39.github.io/ecma262/#sec-function-definitions
     4167            Parser.prototype.parseFunctionSourceElements = function () {
     4168                var node = this.createNode();
     4169                this.expect('{');
     4170                var body = this.parseDirectivePrologues();
     4171                var previousLabelSet = this.context.labelSet;
     4172                var previousInIteration = this.context.inIteration;
     4173                var previousInSwitch = this.context.inSwitch;
     4174                var previousInFunctionBody = this.context.inFunctionBody;
     4175                this.context.labelSet = {};
     4176                this.context.inIteration = false;
     4177                this.context.inSwitch = false;
     4178                this.context.inFunctionBody = true;
     4179                while (this.lookahead.type !== 2 /* EOF */) {
     4180                    if (this.match('}')) {
     4181                        break;
     4182                    }
     4183                    body.push(this.parseStatementListItem());
     4184                }
     4185                this.expect('}');
     4186                this.context.labelSet = previousLabelSet;
     4187                this.context.inIteration = previousInIteration;
     4188                this.context.inSwitch = previousInSwitch;
     4189                this.context.inFunctionBody = previousInFunctionBody;
     4190                return this.finalize(node, new Node.BlockStatement(body));
     4191            };
     4192            Parser.prototype.validateParam = function (options, param, name) {
     4193                var key = '$' + name;
     4194                if (this.context.strict) {
     4195                    if (this.scanner.isRestrictedWord(name)) {
     4196                        options.stricted = param;
     4197                        options.message = messages_1.Messages.StrictParamName;
     4198                    }
     4199                    if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
     4200                        options.stricted = param;
     4201                        options.message = messages_1.Messages.StrictParamDupe;
     4202                    }
     4203                }
     4204                else if (!options.firstRestricted) {
     4205                    if (this.scanner.isRestrictedWord(name)) {
     4206                        options.firstRestricted = param;
     4207                        options.message = messages_1.Messages.StrictParamName;
     4208                    }
     4209                    else if (this.scanner.isStrictModeReservedWord(name)) {
     4210                        options.firstRestricted = param;
     4211                        options.message = messages_1.Messages.StrictReservedWord;
     4212                    }
     4213                    else if (Object.prototype.hasOwnProperty.call(options.paramSet, key)) {
     4214                        options.stricted = param;
     4215                        options.message = messages_1.Messages.StrictParamDupe;
     4216                    }
     4217                }
     4218                /* istanbul ignore next */
     4219                if (typeof Object.defineProperty === 'function') {
     4220                    Object.defineProperty(options.paramSet, key, { value: true, enumerable: true, writable: true, configurable: true });
     4221                }
     4222                else {
     4223                    options.paramSet[key] = true;
     4224                }
     4225            };
     4226            Parser.prototype.parseRestElement = function (params) {
     4227                var node = this.createNode();
     4228                this.expect('...');
     4229                var arg = this.parsePattern(params);
     4230                if (this.match('=')) {
     4231                    this.throwError(messages_1.Messages.DefaultRestParameter);
     4232                }
     4233                if (!this.match(')')) {
     4234                    this.throwError(messages_1.Messages.ParameterAfterRestParameter);
     4235                }
     4236                return this.finalize(node, new Node.RestElement(arg));
     4237            };
     4238            Parser.prototype.parseFormalParameter = function (options) {
     4239                var params = [];
     4240                var param = this.match('...') ? this.parseRestElement(params) : this.parsePatternWithDefault(params);
     4241                for (var i = 0; i < params.length; i++) {
     4242                    this.validateParam(options, params[i], params[i].value);
     4243                }
     4244                options.simple = options.simple && (param instanceof Node.Identifier);
     4245                options.params.push(param);
     4246            };
     4247            Parser.prototype.parseFormalParameters = function (firstRestricted) {
     4248                var options;
     4249                options = {
     4250                    simple: true,
     4251                    params: [],
     4252                    firstRestricted: firstRestricted
     4253                };
     4254                this.expect('(');
     4255                if (!this.match(')')) {
     4256                    options.paramSet = {};
     4257                    while (this.lookahead.type !== 2 /* EOF */) {
     4258                        this.parseFormalParameter(options);
     4259                        if (this.match(')')) {
     4260                            break;
     4261                        }
     4262                        this.expect(',');
     4263                        if (this.match(')')) {
     4264                            break;
     4265                        }
     4266                    }
     4267                }
     4268                this.expect(')');
     4269                return {
     4270                    simple: options.simple,
     4271                    params: options.params,
     4272                    stricted: options.stricted,
     4273                    firstRestricted: options.firstRestricted,
     4274                    message: options.message
     4275                };
     4276            };
     4277            Parser.prototype.matchAsyncFunction = function () {
     4278                var match = this.matchContextualKeyword('async');
     4279                if (match) {
     4280                    var state = this.scanner.saveState();
     4281                    this.scanner.scanComments();
     4282                    var next = this.scanner.lex();
     4283                    this.scanner.restoreState(state);
     4284                    match = (state.lineNumber === next.lineNumber) && (next.type === 4 /* Keyword */) && (next.value === 'function');
     4285                }
     4286                return match;
     4287            };
     4288            Parser.prototype.parseFunctionDeclaration = function (identifierIsOptional) {
     4289                var node = this.createNode();
     4290                var isAsync = this.matchContextualKeyword('async');
     4291                if (isAsync) {
     4292                    this.nextToken();
     4293                }
     4294                this.expectKeyword('function');
     4295                var isGenerator = isAsync ? false : this.match('*');
     4296                if (isGenerator) {
     4297                    this.nextToken();
     4298                }
     4299                var message;
     4300                var id = null;
     4301                var firstRestricted = null;
     4302                if (!identifierIsOptional || !this.match('(')) {
     4303                    var token = this.lookahead;
     4304                    id = this.parseVariableIdentifier();
     4305                    if (this.context.strict) {
     4306                        if (this.scanner.isRestrictedWord(token.value)) {
     4307                            this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
     4308                        }
     4309                    }
     4310                    else {
     4311                        if (this.scanner.isRestrictedWord(token.value)) {
     4312                            firstRestricted = token;
     4313                            message = messages_1.Messages.StrictFunctionName;
     4314                        }
     4315                        else if (this.scanner.isStrictModeReservedWord(token.value)) {
     4316                            firstRestricted = token;
     4317                            message = messages_1.Messages.StrictReservedWord;
     4318                        }
     4319                    }
     4320                }
     4321                var previousAllowAwait = this.context.await;
     4322                var previousAllowYield = this.context.allowYield;
     4323                this.context.await = isAsync;
     4324                this.context.allowYield = !isGenerator;
     4325                var formalParameters = this.parseFormalParameters(firstRestricted);
     4326                var params = formalParameters.params;
     4327                var stricted = formalParameters.stricted;
     4328                firstRestricted = formalParameters.firstRestricted;
     4329                if (formalParameters.message) {
     4330                    message = formalParameters.message;
     4331                }
     4332                var previousStrict = this.context.strict;
     4333                var previousAllowStrictDirective = this.context.allowStrictDirective;
     4334                this.context.allowStrictDirective = formalParameters.simple;
     4335                var body = this.parseFunctionSourceElements();
     4336                if (this.context.strict && firstRestricted) {
     4337                    this.throwUnexpectedToken(firstRestricted, message);
     4338                }
     4339                if (this.context.strict && stricted) {
     4340                    this.tolerateUnexpectedToken(stricted, message);
     4341                }
     4342                this.context.strict = previousStrict;
     4343                this.context.allowStrictDirective = previousAllowStrictDirective;
     4344                this.context.await = previousAllowAwait;
     4345                this.context.allowYield = previousAllowYield;
     4346                return isAsync ? this.finalize(node, new Node.AsyncFunctionDeclaration(id, params, body)) :
     4347                    this.finalize(node, new Node.FunctionDeclaration(id, params, body, isGenerator));
     4348            };
     4349            Parser.prototype.parseFunctionExpression = function () {
     4350                var node = this.createNode();
     4351                var isAsync = this.matchContextualKeyword('async');
     4352                if (isAsync) {
     4353                    this.nextToken();
     4354                }
     4355                this.expectKeyword('function');
     4356                var isGenerator = isAsync ? false : this.match('*');
     4357                if (isGenerator) {
     4358                    this.nextToken();
     4359                }
     4360                var message;
     4361                var id = null;
     4362                var firstRestricted;
     4363                var previousAllowAwait = this.context.await;
     4364                var previousAllowYield = this.context.allowYield;
     4365                this.context.await = isAsync;
     4366                this.context.allowYield = !isGenerator;
     4367                if (!this.match('(')) {
     4368                    var token = this.lookahead;
     4369                    id = (!this.context.strict && !isGenerator && this.matchKeyword('yield')) ? this.parseIdentifierName() : this.parseVariableIdentifier();
     4370                    if (this.context.strict) {
     4371                        if (this.scanner.isRestrictedWord(token.value)) {
     4372                            this.tolerateUnexpectedToken(token, messages_1.Messages.StrictFunctionName);
     4373                        }
     4374                    }
     4375                    else {
     4376                        if (this.scanner.isRestrictedWord(token.value)) {
     4377                            firstRestricted = token;
     4378                            message = messages_1.Messages.StrictFunctionName;
     4379                        }
     4380                        else if (this.scanner.isStrictModeReservedWord(token.value)) {
     4381                            firstRestricted = token;
     4382                            message = messages_1.Messages.StrictReservedWord;
     4383                        }
     4384                    }
     4385                }
     4386                var formalParameters = this.parseFormalParameters(firstRestricted);
     4387                var params = formalParameters.params;
     4388                var stricted = formalParameters.stricted;
     4389                firstRestricted = formalParameters.firstRestricted;
     4390                if (formalParameters.message) {
     4391                    message = formalParameters.message;
     4392                }
     4393                var previousStrict = this.context.strict;
     4394                var previousAllowStrictDirective = this.context.allowStrictDirective;
     4395                this.context.allowStrictDirective = formalParameters.simple;
     4396                var body = this.parseFunctionSourceElements();
     4397                if (this.context.strict && firstRestricted) {
     4398                    this.throwUnexpectedToken(firstRestricted, message);
     4399                }
     4400                if (this.context.strict && stricted) {
     4401                    this.tolerateUnexpectedToken(stricted, message);
     4402                }
     4403                this.context.strict = previousStrict;
     4404                this.context.allowStrictDirective = previousAllowStrictDirective;
     4405                this.context.await = previousAllowAwait;
     4406                this.context.allowYield = previousAllowYield;
     4407                return isAsync ? this.finalize(node, new Node.AsyncFunctionExpression(id, params, body)) :
     4408                    this.finalize(node, new Node.FunctionExpression(id, params, body, isGenerator));
     4409            };
     4410            // https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive
     4411            Parser.prototype.parseDirective = function () {
     4412                var token = this.lookahead;
     4413                var node = this.createNode();
     4414                var expr = this.parseExpression();
     4415                var directive = (expr.type === syntax_1.Syntax.Literal) ? this.getTokenRaw(token).slice(1, -1) : null;
     4416                this.consumeSemicolon();
     4417                return this.finalize(node, directive ? new Node.Directive(expr, directive) : new Node.ExpressionStatement(expr));
     4418            };
     4419            Parser.prototype.parseDirectivePrologues = function () {
     4420                var firstRestricted = null;
     4421                var body = [];
     4422                while (true) {
     4423                    var token = this.lookahead;
     4424                    if (token.type !== 8 /* StringLiteral */) {
     4425                        break;
     4426                    }
     4427                    var statement = this.parseDirective();
     4428                    body.push(statement);
     4429                    var directive = statement.directive;
     4430                    if (typeof directive !== 'string') {
     4431                        break;
     4432                    }
     4433                    if (directive === 'use strict') {
     4434                        this.context.strict = true;
     4435                        if (firstRestricted) {
     4436                            this.tolerateUnexpectedToken(firstRestricted, messages_1.Messages.StrictOctalLiteral);
     4437                        }
     4438                        if (!this.context.allowStrictDirective) {
     4439                            this.tolerateUnexpectedToken(token, messages_1.Messages.IllegalLanguageModeDirective);
     4440                        }
     4441                    }
     4442                    else {
     4443                        if (!firstRestricted && token.octal) {
     4444                            firstRestricted = token;
     4445                        }
     4446                    }
     4447                }
     4448                return body;
     4449            };
     4450            // https://tc39.github.io/ecma262/#sec-method-definitions
     4451            Parser.prototype.qualifiedPropertyName = function (token) {
     4452                switch (token.type) {
     4453                    case 3 /* Identifier */:
     4454                    case 8 /* StringLiteral */:
     4455                    case 1 /* BooleanLiteral */:
     4456                    case 5 /* NullLiteral */:
     4457                    case 6 /* NumericLiteral */:
     4458                    case 4 /* Keyword */:
     4459                        return true;
     4460                    case 7 /* Punctuator */:
     4461                        return token.value === '[';
     4462                    default:
     4463                        break;
     4464                }
     4465                return false;
     4466            };
     4467            Parser.prototype.parseGetterMethod = function () {
     4468                var node = this.createNode();
     4469                var isGenerator = false;
     4470                var previousAllowYield = this.context.allowYield;
     4471                this.context.allowYield = false;
     4472                var formalParameters = this.parseFormalParameters();
     4473                if (formalParameters.params.length > 0) {
     4474                    this.tolerateError(messages_1.Messages.BadGetterArity);
     4475                }
     4476                var method = this.parsePropertyMethod(formalParameters);
     4477                this.context.allowYield = previousAllowYield;
     4478                return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
     4479            };
     4480            Parser.prototype.parseSetterMethod = function () {
     4481                var node = this.createNode();
     4482                var isGenerator = false;
     4483                var previousAllowYield = this.context.allowYield;
     4484                this.context.allowYield = false;
     4485                var formalParameters = this.parseFormalParameters();
     4486                if (formalParameters.params.length !== 1) {
     4487                    this.tolerateError(messages_1.Messages.BadSetterArity);
     4488                }
     4489                else if (formalParameters.params[0] instanceof Node.RestElement) {
     4490                    this.tolerateError(messages_1.Messages.BadSetterRestParameter);
     4491                }
     4492                var method = this.parsePropertyMethod(formalParameters);
     4493                this.context.allowYield = previousAllowYield;
     4494                return this.finalize(node, new Node.FunctionExpression(null, formalParameters.params, method, isGenerator));
     4495            };
     4496            Parser.prototype.parseGeneratorMethod = function () {
     4497                var node = this.createNode();
     4498                var isGenerator = true;
     4499                var previousAllowYield = this.context.allowYield;
     4500                this.context.allowYield = true;
     4501                var params = this.parseFormalParameters();
     4502                this.context.allowYield = false;
     4503                var method = this.parsePropertyMethod(params);
     4504                this.context.allowYield = previousAllowYield;
     4505                return this.finalize(node, new Node.FunctionExpression(null, params.params, method, isGenerator));
     4506            };
     4507            // https://tc39.github.io/ecma262/#sec-generator-function-definitions
     4508            Parser.prototype.isStartOfExpression = function () {
     4509                var start = true;
     4510                var value = this.lookahead.value;
     4511                switch (this.lookahead.type) {
     4512                    case 7 /* Punctuator */:
     4513                        start = (value === '[') || (value === '(') || (value === '{') ||
     4514                            (value === '+') || (value === '-') ||
     4515                            (value === '!') || (value === '~') ||
     4516                            (value === '++') || (value === '--') ||
     4517                            (value === '/') || (value === '/='); // regular expression literal
     4518                        break;
     4519                    case 4 /* Keyword */:
     4520                        start = (value === 'class') || (value === 'delete') ||
     4521                            (value === 'function') || (value === 'let') || (value === 'new') ||
     4522                            (value === 'super') || (value === 'this') || (value === 'typeof') ||
     4523                            (value === 'void') || (value === 'yield');
     4524                        break;
     4525                    default:
     4526                        break;
     4527                }
     4528                return start;
     4529            };
     4530            Parser.prototype.parseYieldExpression = function () {
     4531                var node = this.createNode();
     4532                this.expectKeyword('yield');
     4533                var argument = null;
     4534                var delegate = false;
     4535                if (!this.hasLineTerminator) {
     4536                    var previousAllowYield = this.context.allowYield;
     4537                    this.context.allowYield = false;
     4538                    delegate = this.match('*');
     4539                    if (delegate) {
     4540                        this.nextToken();
     4541                        argument = this.parseAssignmentExpression();
     4542                    }
     4543                    else if (this.isStartOfExpression()) {
     4544                        argument = this.parseAssignmentExpression();
     4545                    }
     4546                    this.context.allowYield = previousAllowYield;
     4547                }
     4548                return this.finalize(node, new Node.YieldExpression(argument, delegate));
     4549            };
     4550            // https://tc39.github.io/ecma262/#sec-class-definitions
     4551            Parser.prototype.parseClassElement = function (hasConstructor) {
     4552                var token = this.lookahead;
     4553                var node = this.createNode();
     4554                var kind = '';
     4555                var key = null;
     4556                var value = null;
     4557                var computed = false;
     4558                var method = false;
     4559                var isStatic = false;
     4560                var isAsync = false;
     4561                if (this.match('*')) {
     4562                    this.nextToken();
     4563                }
     4564                else {
     4565                    computed = this.match('[');
     4566                    key = this.parseObjectPropertyKey();
     4567                    var id = key;
     4568                    if (id.name === 'static' && (this.qualifiedPropertyName(this.lookahead) || this.match('*'))) {
     4569                        token = this.lookahead;
     4570                        isStatic = true;
     4571                        computed = this.match('[');
     4572                        if (this.match('*')) {
     4573                            this.nextToken();
     4574                        }
     4575                        else {
     4576                            key = this.parseObjectPropertyKey();
     4577                        }
     4578                    }
     4579                    if ((token.type === 3 /* Identifier */) && !this.hasLineTerminator && (token.value === 'async')) {
     4580                        var punctuator = this.lookahead.value;
     4581                        if (punctuator !== ':' && punctuator !== '(' && punctuator !== '*') {
     4582                            isAsync = true;
     4583                            token = this.lookahead;
     4584                            key = this.parseObjectPropertyKey();
     4585                            if (token.type === 3 /* Identifier */) {
     4586                                if (token.value === 'get' || token.value === 'set') {
     4587                                    this.tolerateUnexpectedToken(token);
     4588                                }
     4589                                else if (token.value === 'constructor') {
     4590                                    this.tolerateUnexpectedToken(token, messages_1.Messages.ConstructorIsAsync);
     4591                                }
     4592                            }
     4593                        }
     4594                    }
     4595                }
     4596                var lookaheadPropertyKey = this.qualifiedPropertyName(this.lookahead);
     4597                if (token.type === 3 /* Identifier */) {
     4598                    if (token.value === 'get' && lookaheadPropertyKey) {
     4599                        kind = 'get';
     4600                        computed = this.match('[');
     4601                        key = this.parseObjectPropertyKey();
     4602                        this.context.allowYield = false;
     4603                        value = this.parseGetterMethod();
     4604                    }
     4605                    else if (token.value === 'set' && lookaheadPropertyKey) {
     4606                        kind = 'set';
     4607                        computed = this.match('[');
     4608                        key = this.parseObjectPropertyKey();
     4609                        value = this.parseSetterMethod();
     4610                    }
     4611                }
     4612                else if (token.type === 7 /* Punctuator */ && token.value === '*' && lookaheadPropertyKey) {
     4613                    kind = 'init';
     4614                    computed = this.match('[');
     4615                    key = this.parseObjectPropertyKey();
     4616                    value = this.parseGeneratorMethod();
     4617                    method = true;
     4618                }
     4619                if (!kind && key && this.match('(')) {
     4620                    kind = 'init';
     4621                    value = isAsync ? this.parsePropertyMethodAsyncFunction() : this.parsePropertyMethodFunction();
     4622                    method = true;
     4623                }
     4624                if (!kind) {
     4625                    this.throwUnexpectedToken(this.lookahead);
     4626                }
     4627                if (kind === 'init') {
     4628                    kind = 'method';
     4629                }
     4630                if (!computed) {
     4631                    if (isStatic && this.isPropertyKey(key, 'prototype')) {
     4632                        this.throwUnexpectedToken(token, messages_1.Messages.StaticPrototype);
     4633                    }
     4634                    if (!isStatic && this.isPropertyKey(key, 'constructor')) {
     4635                        if (kind !== 'method' || !method || (value && value.generator)) {
     4636                            this.throwUnexpectedToken(token, messages_1.Messages.ConstructorSpecialMethod);
     4637                        }
     4638                        if (hasConstructor.value) {
     4639                            this.throwUnexpectedToken(token, messages_1.Messages.DuplicateConstructor);
     4640                        }
     4641                        else {
     4642                            hasConstructor.value = true;
     4643                        }
     4644                        kind = 'constructor';
     4645                    }
     4646                }
     4647                return this.finalize(node, new Node.MethodDefinition(key, computed, value, kind, isStatic));
     4648            };
     4649            Parser.prototype.parseClassElementList = function () {
     4650                var body = [];
     4651                var hasConstructor = { value: false };
     4652                this.expect('{');
     4653                while (!this.match('}')) {
     4654                    if (this.match(';')) {
     4655                        this.nextToken();
     4656                    }
     4657                    else {
     4658                        body.push(this.parseClassElement(hasConstructor));
     4659                    }
     4660                }
     4661                this.expect('}');
     4662                return body;
     4663            };
     4664            Parser.prototype.parseClassBody = function () {
     4665                var node = this.createNode();
     4666                var elementList = this.parseClassElementList();
     4667                return this.finalize(node, new Node.ClassBody(elementList));
     4668            };
     4669            Parser.prototype.parseClassDeclaration = function (identifierIsOptional) {
     4670                var node = this.createNode();
     4671                var previousStrict = this.context.strict;
     4672                this.context.strict = true;
     4673                this.expectKeyword('class');
     4674                var id = (identifierIsOptional && (this.lookahead.type !== 3 /* Identifier */)) ? null : this.parseVariableIdentifier();
     4675                var superClass = null;
     4676                if (this.matchKeyword('extends')) {
     4677                    this.nextToken();
     4678                    superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
     4679                }
     4680                var classBody = this.parseClassBody();
     4681                this.context.strict = previousStrict;
     4682                return this.finalize(node, new Node.ClassDeclaration(id, superClass, classBody));
     4683            };
     4684            Parser.prototype.parseClassExpression = function () {
     4685                var node = this.createNode();
     4686                var previousStrict = this.context.strict;
     4687                this.context.strict = true;
     4688                this.expectKeyword('class');
     4689                var id = (this.lookahead.type === 3 /* Identifier */) ? this.parseVariableIdentifier() : null;
     4690                var superClass = null;
     4691                if (this.matchKeyword('extends')) {
     4692                    this.nextToken();
     4693                    superClass = this.isolateCoverGrammar(this.parseLeftHandSideExpressionAllowCall);
     4694                }
     4695                var classBody = this.parseClassBody();
     4696                this.context.strict = previousStrict;
     4697                return this.finalize(node, new Node.ClassExpression(id, superClass, classBody));
     4698            };
     4699            // https://tc39.github.io/ecma262/#sec-scripts
     4700            // https://tc39.github.io/ecma262/#sec-modules
     4701            Parser.prototype.parseModule = function () {
     4702                this.context.strict = true;
     4703                this.context.isModule = true;
     4704                var node = this.createNode();
     4705                var body = this.parseDirectivePrologues();
     4706                while (this.lookahead.type !== 2 /* EOF */) {
     4707                    body.push(this.parseStatementListItem());
     4708                }
     4709                return this.finalize(node, new Node.Module(body));
     4710            };
     4711            Parser.prototype.parseScript = function () {
     4712                var node = this.createNode();
     4713                var body = this.parseDirectivePrologues();
     4714                while (this.lookahead.type !== 2 /* EOF */) {
     4715                    body.push(this.parseStatementListItem());
     4716                }
     4717                return this.finalize(node, new Node.Script(body));
     4718            };
     4719            // https://tc39.github.io/ecma262/#sec-imports
     4720            Parser.prototype.parseModuleSpecifier = function () {
     4721                var node = this.createNode();
     4722                if (this.lookahead.type !== 8 /* StringLiteral */) {
     4723                    this.throwError(messages_1.Messages.InvalidModuleSpecifier);
     4724                }
     4725                var token = this.nextToken();
     4726                var raw = this.getTokenRaw(token);
     4727                return this.finalize(node, new Node.Literal(token.value, raw));
     4728            };
     4729            // import {<foo as bar>} ...;
     4730            Parser.prototype.parseImportSpecifier = function () {
     4731                var node = this.createNode();
     4732                var imported;
     4733                var local;
     4734                if (this.lookahead.type === 3 /* Identifier */) {
     4735                    imported = this.parseVariableIdentifier();
     4736                    local = imported;
     4737                    if (this.matchContextualKeyword('as')) {
     4738                        this.nextToken();
     4739                        local = this.parseVariableIdentifier();
     4740                    }
     4741                }
     4742                else {
     4743                    imported = this.parseIdentifierName();
     4744                    local = imported;
     4745                    if (this.matchContextualKeyword('as')) {
     4746                        this.nextToken();
     4747                        local = this.parseVariableIdentifier();
     4748                    }
     4749                    else {
     4750                        this.throwUnexpectedToken(this.nextToken());
     4751                    }
     4752                }
     4753                return this.finalize(node, new Node.ImportSpecifier(local, imported));
     4754            };
     4755            // {foo, bar as bas}
     4756            Parser.prototype.parseNamedImports = function () {
     4757                this.expect('{');
     4758                var specifiers = [];
     4759                while (!this.match('}')) {
     4760                    specifiers.push(this.parseImportSpecifier());
     4761                    if (!this.match('}')) {
     4762                        this.expect(',');
     4763                    }
     4764                }
     4765                this.expect('}');
     4766                return specifiers;
     4767            };
     4768            // import <foo> ...;
     4769            Parser.prototype.parseImportDefaultSpecifier = function () {
     4770                var node = this.createNode();
     4771                var local = this.parseIdentifierName();
     4772                return this.finalize(node, new Node.ImportDefaultSpecifier(local));
     4773            };
     4774            // import <* as foo> ...;
     4775            Parser.prototype.parseImportNamespaceSpecifier = function () {
     4776                var node = this.createNode();
     4777                this.expect('*');
     4778                if (!this.matchContextualKeyword('as')) {
     4779                    this.throwError(messages_1.Messages.NoAsAfterImportNamespace);
     4780                }
     4781                this.nextToken();
     4782                var local = this.parseIdentifierName();
     4783                return this.finalize(node, new Node.ImportNamespaceSpecifier(local));
     4784            };
     4785            Parser.prototype.parseImportDeclaration = function () {
     4786                if (this.context.inFunctionBody) {
     4787                    this.throwError(messages_1.Messages.IllegalImportDeclaration);
     4788                }
     4789                var node = this.createNode();
     4790                this.expectKeyword('import');
     4791                var src;
     4792                var specifiers = [];
     4793                if (this.lookahead.type === 8 /* StringLiteral */) {
     4794                    // import 'foo';
     4795                    src = this.parseModuleSpecifier();
     4796                }
     4797                else {
     4798                    if (this.match('{')) {
     4799                        // import {bar}
     4800                        specifiers = specifiers.concat(this.parseNamedImports());
     4801                    }
     4802                    else if (this.match('*')) {
     4803                        // import * as foo
     4804                        specifiers.push(this.parseImportNamespaceSpecifier());
     4805                    }
     4806                    else if (this.isIdentifierName(this.lookahead) && !this.matchKeyword('default')) {
     4807                        // import foo
     4808                        specifiers.push(this.parseImportDefaultSpecifier());
     4809                        if (this.match(',')) {
     4810                            this.nextToken();
     4811                            if (this.match('*')) {
     4812                                // import foo, * as foo
     4813                                specifiers.push(this.parseImportNamespaceSpecifier());
     4814                            }
     4815                            else if (this.match('{')) {
     4816                                // import foo, {bar}
     4817                                specifiers = specifiers.concat(this.parseNamedImports());
     4818                            }
     4819                            else {
     4820                                this.throwUnexpectedToken(this.lookahead);
     4821                            }
     4822                        }
     4823                    }
     4824                    else {
     4825                        this.throwUnexpectedToken(this.nextToken());
     4826                    }
     4827                    if (!this.matchContextualKeyword('from')) {
     4828                        var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
     4829                        this.throwError(message, this.lookahead.value);
     4830                    }
     4831                    this.nextToken();
     4832                    src = this.parseModuleSpecifier();
     4833                }
     4834                this.consumeSemicolon();
     4835                return this.finalize(node, new Node.ImportDeclaration(specifiers, src));
     4836            };
     4837            // https://tc39.github.io/ecma262/#sec-exports
     4838            Parser.prototype.parseExportSpecifier = function () {
     4839                var node = this.createNode();
     4840                var local = this.parseIdentifierName();
     4841                var exported = local;
     4842                if (this.matchContextualKeyword('as')) {
     4843                    this.nextToken();
     4844                    exported = this.parseIdentifierName();
     4845                }
     4846                return this.finalize(node, new Node.ExportSpecifier(local, exported));
     4847            };
     4848            Parser.prototype.parseExportDeclaration = function () {
     4849                if (this.context.inFunctionBody) {
     4850                    this.throwError(messages_1.Messages.IllegalExportDeclaration);
     4851                }
     4852                var node = this.createNode();
     4853                this.expectKeyword('export');
     4854                var exportDeclaration;
     4855                if (this.matchKeyword('default')) {
     4856                    // export default ...
     4857                    this.nextToken();
     4858                    if (this.matchKeyword('function')) {
     4859                        // export default function foo () {}
     4860                        // export default function () {}
     4861                        var declaration = this.parseFunctionDeclaration(true);
     4862                        exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
     4863                    }
     4864                    else if (this.matchKeyword('class')) {
     4865                        // export default class foo {}
     4866                        var declaration = this.parseClassDeclaration(true);
     4867                        exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
     4868                    }
     4869                    else if (this.matchContextualKeyword('async')) {
     4870                        // export default async function f () {}
     4871                        // export default async function () {}
     4872                        // export default async x => x
     4873                        var declaration = this.matchAsyncFunction() ? this.parseFunctionDeclaration(true) : this.parseAssignmentExpression();
     4874                        exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
     4875                    }
     4876                    else {
     4877                        if (this.matchContextualKeyword('from')) {
     4878                            this.throwError(messages_1.Messages.UnexpectedToken, this.lookahead.value);
     4879                        }
     4880                        // export default {};
     4881                        // export default [];
     4882                        // export default (1 + 2);
     4883                        var declaration = this.match('{') ? this.parseObjectInitializer() :
     4884                            this.match('[') ? this.parseArrayInitializer() : this.parseAssignmentExpression();
     4885                        this.consumeSemicolon();
     4886                        exportDeclaration = this.finalize(node, new Node.ExportDefaultDeclaration(declaration));
     4887                    }
     4888                }
     4889                else if (this.match('*')) {
     4890                    // export * from 'foo';
     4891                    this.nextToken();
     4892                    if (!this.matchContextualKeyword('from')) {
     4893                        var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
     4894                        this.throwError(message, this.lookahead.value);
     4895                    }
     4896                    this.nextToken();
     4897                    var src = this.parseModuleSpecifier();
     4898                    this.consumeSemicolon();
     4899                    exportDeclaration = this.finalize(node, new Node.ExportAllDeclaration(src));
     4900                }
     4901                else if (this.lookahead.type === 4 /* Keyword */) {
     4902                    // export var f = 1;
     4903                    var declaration = void 0;
     4904                    switch (this.lookahead.value) {
     4905                        case 'let':
     4906                        case 'const':
     4907                            declaration = this.parseLexicalDeclaration({ inFor: false });
     4908                            break;
     4909                        case 'var':
     4910                        case 'class':
     4911                        case 'function':
     4912                            declaration = this.parseStatementListItem();
     4913                            break;
     4914                        default:
     4915                            this.throwUnexpectedToken(this.lookahead);
     4916                    }
     4917                    exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
     4918                }
     4919                else if (this.matchAsyncFunction()) {
     4920                    var declaration = this.parseFunctionDeclaration();
     4921                    exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(declaration, [], null));
     4922                }
     4923                else {
     4924                    var specifiers = [];
     4925                    var source = null;
     4926                    var isExportFromIdentifier = false;
     4927                    this.expect('{');
     4928                    while (!this.match('}')) {
     4929                        isExportFromIdentifier = isExportFromIdentifier || this.matchKeyword('default');
     4930                        specifiers.push(this.parseExportSpecifier());
     4931                        if (!this.match('}')) {
     4932                            this.expect(',');
     4933                        }
     4934                    }
     4935                    this.expect('}');
     4936                    if (this.matchContextualKeyword('from')) {
     4937                        // export {default} from 'foo';
     4938                        // export {foo} from 'foo';
     4939                        this.nextToken();
     4940                        source = this.parseModuleSpecifier();
     4941                        this.consumeSemicolon();
     4942                    }
     4943                    else if (isExportFromIdentifier) {
     4944                        // export {default}; // missing fromClause
     4945                        var message = this.lookahead.value ? messages_1.Messages.UnexpectedToken : messages_1.Messages.MissingFromClause;
     4946                        this.throwError(message, this.lookahead.value);
     4947                    }
     4948                    else {
     4949                        // export {foo};
     4950                        this.consumeSemicolon();
     4951                    }
     4952                    exportDeclaration = this.finalize(node, new Node.ExportNamedDeclaration(null, specifiers, source));
     4953                }
     4954                return exportDeclaration;
     4955            };
     4956            return Parser;
     4957        }());
     4958        exports.Parser = Parser;
     4959
     4960
     4961/***/ },
     4962/* 9 */
     4963/***/ function(module, exports) {
     4964
     4965        "use strict";
     4966        // Ensure the condition is true, otherwise throw an error.
     4967        // This is only to have a better contract semantic, i.e. another safety net
     4968        // to catch a logic error. The condition shall be fulfilled in normal case.
     4969        // Do NOT use this to enforce a certain condition on any user input.
     4970        Object.defineProperty(exports, "__esModule", { value: true });
     4971        function assert(condition, message) {
     4972            /* istanbul ignore if */
     4973            if (!condition) {
     4974                throw new Error('ASSERT: ' + message);
     4975            }
     4976        }
     4977        exports.assert = assert;
     4978
     4979
     4980/***/ },
     4981/* 10 */
     4982/***/ function(module, exports) {
     4983
     4984        "use strict";
     4985        /* tslint:disable:max-classes-per-file */
     4986        Object.defineProperty(exports, "__esModule", { value: true });
     4987        var ErrorHandler = (function () {
     4988            function ErrorHandler() {
     4989                this.errors = [];
     4990                this.tolerant = false;
     4991            }
     4992            ErrorHandler.prototype.recordError = function (error) {
     4993                this.errors.push(error);
     4994            };
     4995            ErrorHandler.prototype.tolerate = function (error) {
     4996                if (this.tolerant) {
     4997                    this.recordError(error);
     4998                }
     4999                else {
     5000                    throw error;
     5001                }
     5002            };
     5003            ErrorHandler.prototype.constructError = function (msg, column) {
     5004                var error = new Error(msg);
     5005                try {
     5006                    throw error;
     5007                }
     5008                catch (base) {
     5009                    /* istanbul ignore else */
     5010                    if (Object.create && Object.defineProperty) {
     5011                        error = Object.create(base);
     5012                        Object.defineProperty(error, 'column', { value: column });
     5013                    }
     5014                }
     5015                /* istanbul ignore next */
     5016                return error;
     5017            };
     5018            ErrorHandler.prototype.createError = function (index, line, col, description) {
     5019                var msg = 'Line ' + line + ': ' + description;
     5020                var error = this.constructError(msg, col);
     5021                error.index = index;
     5022                error.lineNumber = line;
     5023                error.description = description;
     5024                return error;
     5025            };
     5026            ErrorHandler.prototype.throwError = function (index, line, col, description) {
     5027                throw this.createError(index, line, col, description);
     5028            };
     5029            ErrorHandler.prototype.tolerateError = function (index, line, col, description) {
     5030                var error = this.createError(index, line, col, description);
     5031                if (this.tolerant) {
     5032                    this.recordError(error);
     5033                }
     5034                else {
     5035                    throw error;
     5036                }
     5037            };
     5038            return ErrorHandler;
     5039        }());
     5040        exports.ErrorHandler = ErrorHandler;
     5041
     5042
     5043/***/ },
     5044/* 11 */
     5045/***/ function(module, exports) {
     5046
     5047        "use strict";
     5048        Object.defineProperty(exports, "__esModule", { value: true });
     5049        // Error messages should be identical to V8.
     5050        exports.Messages = {
     5051            BadGetterArity: 'Getter must not have any formal parameters',
     5052            BadSetterArity: 'Setter must have exactly one formal parameter',
     5053            BadSetterRestParameter: 'Setter function argument must not be a rest parameter',
     5054            ConstructorIsAsync: 'Class constructor may not be an async method',
     5055            ConstructorSpecialMethod: 'Class constructor may not be an accessor',
     5056            DeclarationMissingInitializer: 'Missing initializer in %0 declaration',
     5057            DefaultRestParameter: 'Unexpected token =',
     5058            DuplicateBinding: 'Duplicate binding %0',
     5059            DuplicateConstructor: 'A class may only have one constructor',
     5060            DuplicateProtoProperty: 'Duplicate __proto__ fields are not allowed in object literals',
     5061            ForInOfLoopInitializer: '%0 loop variable declaration may not have an initializer',
     5062            GeneratorInLegacyContext: 'Generator declarations are not allowed in legacy contexts',
     5063            IllegalBreak: 'Illegal break statement',
     5064            IllegalContinue: 'Illegal continue statement',
     5065            IllegalExportDeclaration: 'Unexpected token',
     5066            IllegalImportDeclaration: 'Unexpected token',
     5067            IllegalLanguageModeDirective: 'Illegal \'use strict\' directive in function with non-simple parameter list',
     5068            IllegalReturn: 'Illegal return statement',
     5069            InvalidEscapedReservedWord: 'Keyword must not contain escaped characters',
     5070            InvalidHexEscapeSequence: 'Invalid hexadecimal escape sequence',
     5071            InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
     5072            InvalidLHSInForIn: 'Invalid left-hand side in for-in',
     5073            InvalidLHSInForLoop: 'Invalid left-hand side in for-loop',
     5074            InvalidModuleSpecifier: 'Unexpected token',
     5075            InvalidRegExp: 'Invalid regular expression',
     5076            LetInLexicalBinding: 'let is disallowed as a lexically bound name',
     5077            MissingFromClause: 'Unexpected token',
     5078            MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
     5079            NewlineAfterThrow: 'Illegal newline after throw',
     5080            NoAsAfterImportNamespace: 'Unexpected token',
     5081            NoCatchOrFinally: 'Missing catch or finally after try',
     5082            ParameterAfterRestParameter: 'Rest parameter must be last formal parameter',
     5083            Redeclaration: '%0 \'%1\' has already been declared',
     5084            StaticPrototype: 'Classes may not have static property named prototype',
     5085            StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
     5086            StrictDelete: 'Delete of an unqualified identifier in strict mode.',
     5087            StrictFunction: 'In strict mode code, functions can only be declared at top level or inside a block',
     5088            StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
     5089            StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
     5090            StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
     5091            StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
     5092            StrictModeWith: 'Strict mode code may not include a with statement',
     5093            StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
     5094            StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
     5095            StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
     5096            StrictReservedWord: 'Use of future reserved word in strict mode',
     5097            StrictVarName: 'Variable name may not be eval or arguments in strict mode',
     5098            TemplateOctalLiteral: 'Octal literals are not allowed in template strings.',
     5099            UnexpectedEOS: 'Unexpected end of input',
     5100            UnexpectedIdentifier: 'Unexpected identifier',
     5101            UnexpectedNumber: 'Unexpected number',
     5102            UnexpectedReserved: 'Unexpected reserved word',
     5103            UnexpectedString: 'Unexpected string',
     5104            UnexpectedTemplate: 'Unexpected quasi %0',
     5105            UnexpectedToken: 'Unexpected token %0',
     5106            UnexpectedTokenIllegal: 'Unexpected token ILLEGAL',
     5107            UnknownLabel: 'Undefined label \'%0\'',
     5108            UnterminatedRegExp: 'Invalid regular expression: missing /'
     5109        };
     5110
     5111
     5112/***/ },
     5113/* 12 */
     5114/***/ function(module, exports, __webpack_require__) {
     5115
     5116        "use strict";
     5117        Object.defineProperty(exports, "__esModule", { value: true });
     5118        var assert_1 = __webpack_require__(9);
     5119        var character_1 = __webpack_require__(4);
     5120        var messages_1 = __webpack_require__(11);
     5121        function hexValue(ch) {
     5122            return '0123456789abcdef'.indexOf(ch.toLowerCase());
     5123        }
     5124        function octalValue(ch) {
     5125            return '01234567'.indexOf(ch);
     5126        }
     5127        var Scanner = (function () {
     5128            function Scanner(code, handler) {
     5129                this.source = code;
     5130                this.errorHandler = handler;
     5131                this.trackComment = false;
     5132                this.length = code.length;
     5133                this.index = 0;
     5134                this.lineNumber = (code.length > 0) ? 1 : 0;
     5135                this.lineStart = 0;
     5136                this.curlyStack = [];
     5137            }
     5138            Scanner.prototype.saveState = function () {
     5139                return {
     5140                    index: this.index,
     5141                    lineNumber: this.lineNumber,
     5142                    lineStart: this.lineStart
     5143                };
     5144            };
     5145            Scanner.prototype.restoreState = function (state) {
     5146                this.index = state.index;
     5147                this.lineNumber = state.lineNumber;
     5148                this.lineStart = state.lineStart;
     5149            };
     5150            Scanner.prototype.eof = function () {
     5151                return this.index >= this.length;
     5152            };
     5153            Scanner.prototype.throwUnexpectedToken = function (message) {
     5154                if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
     5155                return this.errorHandler.throwError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
     5156            };
     5157            Scanner.prototype.tolerateUnexpectedToken = function (message) {
     5158                if (message === void 0) { message = messages_1.Messages.UnexpectedTokenIllegal; }
     5159                this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
     5160            };
     5161            // https://tc39.github.io/ecma262/#sec-comments
     5162            Scanner.prototype.skipSingleLineComment = function (offset) {
     5163                var comments = [];
     5164                var start, loc;
     5165                if (this.trackComment) {
     5166                    comments = [];
     5167                    start = this.index - offset;
     5168                    loc = {
     5169                        start: {
     5170                            line: this.lineNumber,
     5171                            column: this.index - this.lineStart - offset
     5172                        },
     5173                        end: {}
     5174                    };
     5175                }
     5176                while (!this.eof()) {
     5177                    var ch = this.source.charCodeAt(this.index);
     5178                    ++this.index;
     5179                    if (character_1.Character.isLineTerminator(ch)) {
     5180                        if (this.trackComment) {
     5181                            loc.end = {
     5182                                line: this.lineNumber,
     5183                                column: this.index - this.lineStart - 1
     5184                            };
     5185                            var entry = {
     5186                                multiLine: false,
     5187                                slice: [start + offset, this.index - 1],
     5188                                range: [start, this.index - 1],
     5189                                loc: loc
     5190                            };
     5191                            comments.push(entry);
     5192                        }
     5193                        if (ch === 13 && this.source.charCodeAt(this.index) === 10) {
     5194                            ++this.index;
     5195                        }
     5196                        ++this.lineNumber;
     5197                        this.lineStart = this.index;
     5198                        return comments;
     5199                    }
     5200                }
     5201                if (this.trackComment) {
     5202                    loc.end = {
     5203                        line: this.lineNumber,
     5204                        column: this.index - this.lineStart
     5205                    };
     5206                    var entry = {
     5207                        multiLine: false,
     5208                        slice: [start + offset, this.index],
     5209                        range: [start, this.index],
     5210                        loc: loc
     5211                    };
     5212                    comments.push(entry);
     5213                }
     5214                return comments;
     5215            };
     5216            Scanner.prototype.skipMultiLineComment = function () {
     5217                var comments = [];
     5218                var start, loc;
     5219                if (this.trackComment) {
     5220                    comments = [];
     5221                    start = this.index - 2;
     5222                    loc = {
     5223                        start: {
     5224                            line: this.lineNumber,
     5225                            column: this.index - this.lineStart - 2
     5226                        },
     5227                        end: {}
     5228                    };
     5229                }
     5230                while (!this.eof()) {
     5231                    var ch = this.source.charCodeAt(this.index);
     5232                    if (character_1.Character.isLineTerminator(ch)) {
     5233                        if (ch === 0x0D && this.source.charCodeAt(this.index + 1) === 0x0A) {
     5234                            ++this.index;
     5235                        }
     5236                        ++this.lineNumber;
     5237                        ++this.index;
     5238                        this.lineStart = this.index;
     5239                    }
     5240                    else if (ch === 0x2A) {
     5241                        // Block comment ends with '*/'.
     5242                        if (this.source.charCodeAt(this.index + 1) === 0x2F) {
     5243                            this.index += 2;
     5244                            if (this.trackComment) {
     5245                                loc.end = {
     5246                                    line: this.lineNumber,
     5247                                    column: this.index - this.lineStart
     5248                                };
     5249                                var entry = {
     5250                                    multiLine: true,
     5251                                    slice: [start + 2, this.index - 2],
     5252                                    range: [start, this.index],
     5253                                    loc: loc
     5254                                };
     5255                                comments.push(entry);
     5256                            }
     5257                            return comments;
     5258                        }
     5259                        ++this.index;
     5260                    }
     5261                    else {
     5262                        ++this.index;
     5263                    }
     5264                }
     5265                // Ran off the end of the file - the whole thing is a comment
     5266                if (this.trackComment) {
     5267                    loc.end = {
     5268                        line: this.lineNumber,
     5269                        column: this.index - this.lineStart
     5270                    };
     5271                    var entry = {
     5272                        multiLine: true,
     5273                        slice: [start + 2, this.index],
     5274                        range: [start, this.index],
     5275                        loc: loc
     5276                    };
     5277                    comments.push(entry);
     5278                }
     5279                this.tolerateUnexpectedToken();
     5280                return comments;
     5281            };
     5282            Scanner.prototype.scanComments = function () {
     5283                var comments;
     5284                if (this.trackComment) {
     5285                    comments = [];
     5286                }
     5287                var start = (this.index === 0);
     5288                while (!this.eof()) {
     5289                    var ch = this.source.charCodeAt(this.index);
     5290                    if (character_1.Character.isWhiteSpace(ch)) {
     5291                        ++this.index;
     5292                    }
     5293                    else if (character_1.Character.isLineTerminator(ch)) {
     5294                        ++this.index;
     5295                        if (ch === 0x0D && this.source.charCodeAt(this.index) === 0x0A) {
     5296                            ++this.index;
     5297                        }
     5298                        ++this.lineNumber;
     5299                        this.lineStart = this.index;
     5300                        start = true;
     5301                    }
     5302                    else if (ch === 0x2F) {
     5303                        ch = this.source.charCodeAt(this.index + 1);
     5304                        if (ch === 0x2F) {
     5305                            this.index += 2;
     5306                            var comment = this.skipSingleLineComment(2);
     5307                            if (this.trackComment) {
     5308                                comments = comments.concat(comment);
     5309                            }
     5310                            start = true;
     5311                        }
     5312                        else if (ch === 0x2A) {
     5313                            this.index += 2;
     5314                            var comment = this.skipMultiLineComment();
     5315                            if (this.trackComment) {
     5316                                comments = comments.concat(comment);
     5317                            }
     5318                        }
     5319                        else {
     5320                            break;
     5321                        }
     5322                    }
     5323                    else if (start && ch === 0x2D) {
     5324                        // U+003E is '>'
     5325                        if ((this.source.charCodeAt(this.index + 1) === 0x2D) && (this.source.charCodeAt(this.index + 2) === 0x3E)) {
     5326                            // '-->' is a single-line comment
     5327                            this.index += 3;
     5328                            var comment = this.skipSingleLineComment(3);
     5329                            if (this.trackComment) {
     5330                                comments = comments.concat(comment);
     5331                            }
     5332                        }
     5333                        else {
     5334                            break;
     5335                        }
     5336                    }
     5337                    else if (ch === 0x3C) {
     5338                        if (this.source.slice(this.index + 1, this.index + 4) === '!--') {
     5339                            this.index += 4; // `<!--`
     5340                            var comment = this.skipSingleLineComment(4);
     5341                            if (this.trackComment) {
     5342                                comments = comments.concat(comment);
     5343                            }
     5344                        }
     5345                        else {
     5346                            break;
     5347                        }
     5348                    }
     5349                    else {
     5350                        break;
     5351                    }
     5352                }
     5353                return comments;
     5354            };
     5355            // https://tc39.github.io/ecma262/#sec-future-reserved-words
     5356            Scanner.prototype.isFutureReservedWord = function (id) {
     5357                switch (id) {
     5358                    case 'enum':
     5359                    case 'export':
     5360                    case 'import':
     5361                    case 'super':
     5362                        return true;
     5363                    default:
     5364                        return false;
     5365                }
     5366            };
     5367            Scanner.prototype.isStrictModeReservedWord = function (id) {
     5368                switch (id) {
     5369                    case 'implements':
     5370                    case 'interface':
     5371                    case 'package':
     5372                    case 'private':
     5373                    case 'protected':
     5374                    case 'public':
     5375                    case 'static':
     5376                    case 'yield':
     5377                    case 'let':
     5378                        return true;
     5379                    default:
     5380                        return false;
     5381                }
     5382            };
     5383            Scanner.prototype.isRestrictedWord = function (id) {
     5384                return id === 'eval' || id === 'arguments';
     5385            };
     5386            // https://tc39.github.io/ecma262/#sec-keywords
     5387            Scanner.prototype.isKeyword = function (id) {
     5388                switch (id.length) {
     5389                    case 2:
     5390                        return (id === 'if') || (id === 'in') || (id === 'do');
     5391                    case 3:
     5392                        return (id === 'var') || (id === 'for') || (id === 'new') ||
     5393                            (id === 'try') || (id === 'let');
     5394                    case 4:
     5395                        return (id === 'this') || (id === 'else') || (id === 'case') ||
     5396                            (id === 'void') || (id === 'with') || (id === 'enum');
     5397                    case 5:
     5398                        return (id === 'while') || (id === 'break') || (id === 'catch') ||
     5399                            (id === 'throw') || (id === 'const') || (id === 'yield') ||
     5400                            (id === 'class') || (id === 'super');
     5401                    case 6:
     5402                        return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
     5403                            (id === 'switch') || (id === 'export') || (id === 'import');
     5404                    case 7:
     5405                        return (id === 'default') || (id === 'finally') || (id === 'extends');
     5406                    case 8:
     5407                        return (id === 'function') || (id === 'continue') || (id === 'debugger');
     5408                    case 10:
     5409                        return (id === 'instanceof');
     5410                    default:
     5411                        return false;
     5412                }
     5413            };
     5414            Scanner.prototype.codePointAt = function (i) {
     5415                var cp = this.source.charCodeAt(i);
     5416                if (cp >= 0xD800 && cp <= 0xDBFF) {
     5417                    var second = this.source.charCodeAt(i + 1);
     5418                    if (second >= 0xDC00 && second <= 0xDFFF) {
     5419                        var first = cp;
     5420                        cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
     5421                    }
     5422                }
     5423                return cp;
     5424            };
     5425            Scanner.prototype.scanHexEscape = function (prefix) {
     5426                var len = (prefix === 'u') ? 4 : 2;
     5427                var code = 0;
     5428                for (var i = 0; i < len; ++i) {
     5429                    if (!this.eof() && character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
     5430                        code = code * 16 + hexValue(this.source[this.index++]);
     5431                    }
     5432                    else {
     5433                        return null;
     5434                    }
     5435                }
     5436                return String.fromCharCode(code);
     5437            };
     5438            Scanner.prototype.scanUnicodeCodePointEscape = function () {
     5439                var ch = this.source[this.index];
     5440                var code = 0;
     5441                // At least, one hex digit is required.
     5442                if (ch === '}') {
     5443                    this.throwUnexpectedToken();
     5444                }
     5445                while (!this.eof()) {
     5446                    ch = this.source[this.index++];
     5447                    if (!character_1.Character.isHexDigit(ch.charCodeAt(0))) {
     5448                        break;
     5449                    }
     5450                    code = code * 16 + hexValue(ch);
     5451                }
     5452                if (code > 0x10FFFF || ch !== '}') {
     5453                    this.throwUnexpectedToken();
     5454                }
     5455                return character_1.Character.fromCodePoint(code);
     5456            };
     5457            Scanner.prototype.getIdentifier = function () {
     5458                var start = this.index++;
     5459                while (!this.eof()) {
     5460                    var ch = this.source.charCodeAt(this.index);
     5461                    if (ch === 0x5C) {
     5462                        // Blackslash (U+005C) marks Unicode escape sequence.
     5463                        this.index = start;
     5464                        return this.getComplexIdentifier();
     5465                    }
     5466                    else if (ch >= 0xD800 && ch < 0xDFFF) {
     5467                        // Need to handle surrogate pairs.
     5468                        this.index = start;
     5469                        return this.getComplexIdentifier();
     5470                    }
     5471                    if (character_1.Character.isIdentifierPart(ch)) {
     5472                        ++this.index;
     5473                    }
     5474                    else {
     5475                        break;
     5476                    }
     5477                }
     5478                return this.source.slice(start, this.index);
     5479            };
     5480            Scanner.prototype.getComplexIdentifier = function () {
     5481                var cp = this.codePointAt(this.index);
     5482                var id = character_1.Character.fromCodePoint(cp);
     5483                this.index += id.length;
     5484                // '\u' (U+005C, U+0075) denotes an escaped character.
     5485                var ch;
     5486                if (cp === 0x5C) {
     5487                    if (this.source.charCodeAt(this.index) !== 0x75) {
     5488                        this.throwUnexpectedToken();
     5489                    }
     5490                    ++this.index;
     5491                    if (this.source[this.index] === '{') {
     5492                        ++this.index;
     5493                        ch = this.scanUnicodeCodePointEscape();
     5494                    }
     5495                    else {
     5496                        ch = this.scanHexEscape('u');
     5497                        if (ch === null || ch === '\\' || !character_1.Character.isIdentifierStart(ch.charCodeAt(0))) {
     5498                            this.throwUnexpectedToken();
     5499                        }
     5500                    }
     5501                    id = ch;
     5502                }
     5503                while (!this.eof()) {
     5504                    cp = this.codePointAt(this.index);
     5505                    if (!character_1.Character.isIdentifierPart(cp)) {
     5506                        break;
     5507                    }
     5508                    ch = character_1.Character.fromCodePoint(cp);
     5509                    id += ch;
     5510                    this.index += ch.length;
     5511                    // '\u' (U+005C, U+0075) denotes an escaped character.
     5512                    if (cp === 0x5C) {
     5513                        id = id.substr(0, id.length - 1);
     5514                        if (this.source.charCodeAt(this.index) !== 0x75) {
     5515                            this.throwUnexpectedToken();
     5516                        }
     5517                        ++this.index;
     5518                        if (this.source[this.index] === '{') {
     5519                            ++this.index;
     5520                            ch = this.scanUnicodeCodePointEscape();
     5521                        }
     5522                        else {
     5523                            ch = this.scanHexEscape('u');
     5524                            if (ch === null || ch === '\\' || !character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
     5525                                this.throwUnexpectedToken();
     5526                            }
     5527                        }
     5528                        id += ch;
     5529                    }
     5530                }
     5531                return id;
     5532            };
     5533            Scanner.prototype.octalToDecimal = function (ch) {
     5534                // \0 is not octal escape sequence
     5535                var octal = (ch !== '0');
     5536                var code = octalValue(ch);
     5537                if (!this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
     5538                    octal = true;
     5539                    code = code * 8 + octalValue(this.source[this.index++]);
     5540                    // 3 digits are only allowed when string starts
     5541                    // with 0, 1, 2, 3
     5542                    if ('0123'.indexOf(ch) >= 0 && !this.eof() && character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
     5543                        code = code * 8 + octalValue(this.source[this.index++]);
     5544                    }
     5545                }
     5546                return {
     5547                    code: code,
     5548                    octal: octal
     5549                };
     5550            };
     5551            // https://tc39.github.io/ecma262/#sec-names-and-keywords
     5552            Scanner.prototype.scanIdentifier = function () {
     5553                var type;
     5554                var start = this.index;
     5555                // Backslash (U+005C) starts an escaped character.
     5556                var id = (this.source.charCodeAt(start) === 0x5C) ? this.getComplexIdentifier() : this.getIdentifier();
     5557                // There is no keyword or literal with only one character.
     5558                // Thus, it must be an identifier.
     5559                if (id.length === 1) {
     5560                    type = 3 /* Identifier */;
     5561                }
     5562                else if (this.isKeyword(id)) {
     5563                    type = 4 /* Keyword */;
     5564                }
     5565                else if (id === 'null') {
     5566                    type = 5 /* NullLiteral */;
     5567                }
     5568                else if (id === 'true' || id === 'false') {
     5569                    type = 1 /* BooleanLiteral */;
     5570                }
     5571                else {
     5572                    type = 3 /* Identifier */;
     5573                }
     5574                if (type !== 3 /* Identifier */ && (start + id.length !== this.index)) {
     5575                    var restore = this.index;
     5576                    this.index = start;
     5577                    this.tolerateUnexpectedToken(messages_1.Messages.InvalidEscapedReservedWord);
     5578                    this.index = restore;
     5579                }
     5580                return {
     5581                    type: type,
     5582                    value: id,
     5583                    lineNumber: this.lineNumber,
     5584                    lineStart: this.lineStart,
     5585                    start: start,
     5586                    end: this.index
     5587                };
     5588            };
     5589            // https://tc39.github.io/ecma262/#sec-punctuators
     5590            Scanner.prototype.scanPunctuator = function () {
     5591                var start = this.index;
     5592                // Check for most common single-character punctuators.
     5593                var str = this.source[this.index];
     5594                switch (str) {
     5595                    case '(':
     5596                    case '{':
     5597                        if (str === '{') {
     5598                            this.curlyStack.push('{');
     5599                        }
     5600                        ++this.index;
     5601                        break;
     5602                    case '.':
     5603                        ++this.index;
     5604                        if (this.source[this.index] === '.' && this.source[this.index + 1] === '.') {
     5605                            // Spread operator: ...
     5606                            this.index += 2;
     5607                            str = '...';
     5608                        }
     5609                        break;
     5610                    case '}':
     5611                        ++this.index;
     5612                        this.curlyStack.pop();
     5613                        break;
     5614                    case ')':
     5615                    case ';':
     5616                    case ',':
     5617                    case '[':
     5618                    case ']':
     5619                    case ':':
     5620                    case '?':
     5621                    case '~':
     5622                        ++this.index;
     5623                        break;
     5624                    default:
     5625                        // 4-character punctuator.
     5626                        str = this.source.substr(this.index, 4);
     5627                        if (str === '>>>=') {
     5628                            this.index += 4;
     5629                        }
     5630                        else {
     5631                            // 3-character punctuators.
     5632                            str = str.substr(0, 3);
     5633                            if (str === '===' || str === '!==' || str === '>>>' ||
     5634                                str === '<<=' || str === '>>=' || str === '**=') {
     5635                                this.index += 3;
     5636                            }
     5637                            else {
     5638                                // 2-character punctuators.
     5639                                str = str.substr(0, 2);
     5640                                if (str === '&&' || str === '||' || str === '==' || str === '!=' ||
     5641                                    str === '+=' || str === '-=' || str === '*=' || str === '/=' ||
     5642                                    str === '++' || str === '--' || str === '<<' || str === '>>' ||
     5643                                    str === '&=' || str === '|=' || str === '^=' || str === '%=' ||
     5644                                    str === '<=' || str === '>=' || str === '=>' || str === '**') {
     5645                                    this.index += 2;
     5646                                }
     5647                                else {
     5648                                    // 1-character punctuators.
     5649                                    str = this.source[this.index];
     5650                                    if ('<>=!+-*%&|^/'.indexOf(str) >= 0) {
     5651                                        ++this.index;
     5652                                    }
     5653                                }
     5654                            }
     5655                        }
     5656                }
     5657                if (this.index === start) {
     5658                    this.throwUnexpectedToken();
     5659                }
     5660                return {
     5661                    type: 7 /* Punctuator */,
     5662                    value: str,
     5663                    lineNumber: this.lineNumber,
     5664                    lineStart: this.lineStart,
     5665                    start: start,
     5666                    end: this.index
     5667                };
     5668            };
     5669            // https://tc39.github.io/ecma262/#sec-literals-numeric-literals
     5670            Scanner.prototype.scanHexLiteral = function (start) {
     5671                var num = '';
     5672                while (!this.eof()) {
     5673                    if (!character_1.Character.isHexDigit(this.source.charCodeAt(this.index))) {
     5674                        break;
     5675                    }
     5676                    num += this.source[this.index++];
     5677                }
     5678                if (num.length === 0) {
     5679                    this.throwUnexpectedToken();
     5680                }
     5681                if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
     5682                    this.throwUnexpectedToken();
     5683                }
     5684                return {
     5685                    type: 6 /* NumericLiteral */,
     5686                    value: parseInt('0x' + num, 16),
     5687                    lineNumber: this.lineNumber,
     5688                    lineStart: this.lineStart,
     5689                    start: start,
     5690                    end: this.index
     5691                };
     5692            };
     5693            Scanner.prototype.scanBinaryLiteral = function (start) {
     5694                var num = '';
     5695                var ch;
     5696                while (!this.eof()) {
     5697                    ch = this.source[this.index];
     5698                    if (ch !== '0' && ch !== '1') {
     5699                        break;
     5700                    }
     5701                    num += this.source[this.index++];
     5702                }
     5703                if (num.length === 0) {
     5704                    // only 0b or 0B
     5705                    this.throwUnexpectedToken();
     5706                }
     5707                if (!this.eof()) {
     5708                    ch = this.source.charCodeAt(this.index);
     5709                    /* istanbul ignore else */
     5710                    if (character_1.Character.isIdentifierStart(ch) || character_1.Character.isDecimalDigit(ch)) {
     5711                        this.throwUnexpectedToken();
     5712                    }
     5713                }
     5714                return {
     5715                    type: 6 /* NumericLiteral */,
     5716                    value: parseInt(num, 2),
     5717                    lineNumber: this.lineNumber,
     5718                    lineStart: this.lineStart,
     5719                    start: start,
     5720                    end: this.index
     5721                };
     5722            };
     5723            Scanner.prototype.scanOctalLiteral = function (prefix, start) {
     5724                var num = '';
     5725                var octal = false;
     5726                if (character_1.Character.isOctalDigit(prefix.charCodeAt(0))) {
     5727                    octal = true;
     5728                    num = '0' + this.source[this.index++];
     5729                }
     5730                else {
     5731                    ++this.index;
     5732                }
     5733                while (!this.eof()) {
     5734                    if (!character_1.Character.isOctalDigit(this.source.charCodeAt(this.index))) {
     5735                        break;
     5736                    }
     5737                    num += this.source[this.index++];
     5738                }
     5739                if (!octal && num.length === 0) {
     5740                    // only 0o or 0O
     5741                    this.throwUnexpectedToken();
     5742                }
     5743                if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index)) || character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
     5744                    this.throwUnexpectedToken();
     5745                }
     5746                return {
     5747                    type: 6 /* NumericLiteral */,
     5748                    value: parseInt(num, 8),
     5749                    octal: octal,
     5750                    lineNumber: this.lineNumber,
     5751                    lineStart: this.lineStart,
     5752                    start: start,
     5753                    end: this.index
     5754                };
     5755            };
     5756            Scanner.prototype.isImplicitOctalLiteral = function () {
     5757                // Implicit octal, unless there is a non-octal digit.
     5758                // (Annex B.1.1 on Numeric Literals)
     5759                for (var i = this.index + 1; i < this.length; ++i) {
     5760                    var ch = this.source[i];
     5761                    if (ch === '8' || ch === '9') {
     5762                        return false;
     5763                    }
     5764                    if (!character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
     5765                        return true;
     5766                    }
     5767                }
     5768                return true;
     5769            };
     5770            Scanner.prototype.scanNumericLiteral = function () {
     5771                var start = this.index;
     5772                var ch = this.source[start];
     5773                assert_1.assert(character_1.Character.isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), 'Numeric literal must start with a decimal digit or a decimal point');
     5774                var num = '';
     5775                if (ch !== '.') {
     5776                    num = this.source[this.index++];
     5777                    ch = this.source[this.index];
     5778                    // Hex number starts with '0x'.
     5779                    // Octal number starts with '0'.
     5780                    // Octal number in ES6 starts with '0o'.
     5781                    // Binary number in ES6 starts with '0b'.
     5782                    if (num === '0') {
     5783                        if (ch === 'x' || ch === 'X') {
     5784                            ++this.index;
     5785                            return this.scanHexLiteral(start);
     5786                        }
     5787                        if (ch === 'b' || ch === 'B') {
     5788                            ++this.index;
     5789                            return this.scanBinaryLiteral(start);
     5790                        }
     5791                        if (ch === 'o' || ch === 'O') {
     5792                            return this.scanOctalLiteral(ch, start);
     5793                        }
     5794                        if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
     5795                            if (this.isImplicitOctalLiteral()) {
     5796                                return this.scanOctalLiteral(ch, start);
     5797                            }
     5798                        }
     5799                    }
     5800                    while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
     5801                        num += this.source[this.index++];
     5802                    }
     5803                    ch = this.source[this.index];
     5804                }
     5805                if (ch === '.') {
     5806                    num += this.source[this.index++];
     5807                    while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
     5808                        num += this.source[this.index++];
     5809                    }
     5810                    ch = this.source[this.index];
     5811                }
     5812                if (ch === 'e' || ch === 'E') {
     5813                    num += this.source[this.index++];
     5814                    ch = this.source[this.index];
     5815                    if (ch === '+' || ch === '-') {
     5816                        num += this.source[this.index++];
     5817                    }
     5818                    if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
     5819                        while (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
     5820                            num += this.source[this.index++];
     5821                        }
     5822                    }
     5823                    else {
     5824                        this.throwUnexpectedToken();
     5825                    }
     5826                }
     5827                if (character_1.Character.isIdentifierStart(this.source.charCodeAt(this.index))) {
     5828                    this.throwUnexpectedToken();
     5829                }
     5830                return {
     5831                    type: 6 /* NumericLiteral */,
     5832                    value: parseFloat(num),
     5833                    lineNumber: this.lineNumber,
     5834                    lineStart: this.lineStart,
     5835                    start: start,
     5836                    end: this.index
     5837                };
     5838            };
     5839            // https://tc39.github.io/ecma262/#sec-literals-string-literals
     5840            Scanner.prototype.scanStringLiteral = function () {
     5841                var start = this.index;
     5842                var quote = this.source[start];
     5843                assert_1.assert((quote === '\'' || quote === '"'), 'String literal must starts with a quote');
     5844                ++this.index;
     5845                var octal = false;
     5846                var str = '';
     5847                while (!this.eof()) {
     5848                    var ch = this.source[this.index++];
     5849                    if (ch === quote) {
     5850                        quote = '';
     5851                        break;
     5852                    }
     5853                    else if (ch === '\\') {
     5854                        ch = this.source[this.index++];
     5855                        if (!ch || !character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     5856                            switch (ch) {
     5857                                case 'u':
     5858                                    if (this.source[this.index] === '{') {
     5859                                        ++this.index;
     5860                                        str += this.scanUnicodeCodePointEscape();
     5861                                    }
     5862                                    else {
     5863                                        var unescaped_1 = this.scanHexEscape(ch);
     5864                                        if (unescaped_1 === null) {
     5865                                            this.throwUnexpectedToken();
     5866                                        }
     5867                                        str += unescaped_1;
     5868                                    }
     5869                                    break;
     5870                                case 'x':
     5871                                    var unescaped = this.scanHexEscape(ch);
     5872                                    if (unescaped === null) {
     5873                                        this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
     5874                                    }
     5875                                    str += unescaped;
     5876                                    break;
     5877                                case 'n':
     5878                                    str += '\n';
     5879                                    break;
     5880                                case 'r':
     5881                                    str += '\r';
     5882                                    break;
     5883                                case 't':
     5884                                    str += '\t';
     5885                                    break;
     5886                                case 'b':
     5887                                    str += '\b';
     5888                                    break;
     5889                                case 'f':
     5890                                    str += '\f';
     5891                                    break;
     5892                                case 'v':
     5893                                    str += '\x0B';
     5894                                    break;
     5895                                case '8':
     5896                                case '9':
     5897                                    str += ch;
     5898                                    this.tolerateUnexpectedToken();
     5899                                    break;
     5900                                default:
     5901                                    if (ch && character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
     5902                                        var octToDec = this.octalToDecimal(ch);
     5903                                        octal = octToDec.octal || octal;
     5904                                        str += String.fromCharCode(octToDec.code);
     5905                                    }
     5906                                    else {
     5907                                        str += ch;
     5908                                    }
     5909                                    break;
     5910                            }
     5911                        }
     5912                        else {
     5913                            ++this.lineNumber;
     5914                            if (ch === '\r' && this.source[this.index] === '\n') {
     5915                                ++this.index;
     5916                            }
     5917                            this.lineStart = this.index;
     5918                        }
     5919                    }
     5920                    else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     5921                        break;
     5922                    }
     5923                    else {
     5924                        str += ch;
     5925                    }
     5926                }
     5927                if (quote !== '') {
     5928                    this.index = start;
     5929                    this.throwUnexpectedToken();
     5930                }
     5931                return {
     5932                    type: 8 /* StringLiteral */,
     5933                    value: str,
     5934                    octal: octal,
     5935                    lineNumber: this.lineNumber,
     5936                    lineStart: this.lineStart,
     5937                    start: start,
     5938                    end: this.index
     5939                };
     5940            };
     5941            // https://tc39.github.io/ecma262/#sec-template-literal-lexical-components
     5942            Scanner.prototype.scanTemplate = function () {
     5943                var cooked = '';
     5944                var terminated = false;
     5945                var start = this.index;
     5946                var head = (this.source[start] === '`');
     5947                var tail = false;
     5948                var rawOffset = 2;
     5949                ++this.index;
     5950                while (!this.eof()) {
     5951                    var ch = this.source[this.index++];
     5952                    if (ch === '`') {
     5953                        rawOffset = 1;
     5954                        tail = true;
     5955                        terminated = true;
     5956                        break;
     5957                    }
     5958                    else if (ch === '$') {
     5959                        if (this.source[this.index] === '{') {
     5960                            this.curlyStack.push('${');
     5961                            ++this.index;
     5962                            terminated = true;
     5963                            break;
     5964                        }
     5965                        cooked += ch;
     5966                    }
     5967                    else if (ch === '\\') {
     5968                        ch = this.source[this.index++];
     5969                        if (!character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     5970                            switch (ch) {
     5971                                case 'n':
     5972                                    cooked += '\n';
     5973                                    break;
     5974                                case 'r':
     5975                                    cooked += '\r';
     5976                                    break;
     5977                                case 't':
     5978                                    cooked += '\t';
     5979                                    break;
     5980                                case 'u':
     5981                                    if (this.source[this.index] === '{') {
     5982                                        ++this.index;
     5983                                        cooked += this.scanUnicodeCodePointEscape();
     5984                                    }
     5985                                    else {
     5986                                        var restore = this.index;
     5987                                        var unescaped_2 = this.scanHexEscape(ch);
     5988                                        if (unescaped_2 !== null) {
     5989                                            cooked += unescaped_2;
     5990                                        }
     5991                                        else {
     5992                                            this.index = restore;
     5993                                            cooked += ch;
     5994                                        }
     5995                                    }
     5996                                    break;
     5997                                case 'x':
     5998                                    var unescaped = this.scanHexEscape(ch);
     5999                                    if (unescaped === null) {
     6000                                        this.throwUnexpectedToken(messages_1.Messages.InvalidHexEscapeSequence);
     6001                                    }
     6002                                    cooked += unescaped;
     6003                                    break;
     6004                                case 'b':
     6005                                    cooked += '\b';
     6006                                    break;
     6007                                case 'f':
     6008                                    cooked += '\f';
     6009                                    break;
     6010                                case 'v':
     6011                                    cooked += '\v';
     6012                                    break;
     6013                                default:
     6014                                    if (ch === '0') {
     6015                                        if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index))) {
     6016                                            // Illegal: \01 \02 and so on
     6017                                            this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
     6018                                        }
     6019                                        cooked += '\0';
     6020                                    }
     6021                                    else if (character_1.Character.isOctalDigit(ch.charCodeAt(0))) {
     6022                                        // Illegal: \1 \2
     6023                                        this.throwUnexpectedToken(messages_1.Messages.TemplateOctalLiteral);
     6024                                    }
     6025                                    else {
     6026                                        cooked += ch;
     6027                                    }
     6028                                    break;
     6029                            }
     6030                        }
     6031                        else {
     6032                            ++this.lineNumber;
     6033                            if (ch === '\r' && this.source[this.index] === '\n') {
     6034                                ++this.index;
     6035                            }
     6036                            this.lineStart = this.index;
     6037                        }
     6038                    }
     6039                    else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     6040                        ++this.lineNumber;
     6041                        if (ch === '\r' && this.source[this.index] === '\n') {
     6042                            ++this.index;
     6043                        }
     6044                        this.lineStart = this.index;
     6045                        cooked += '\n';
     6046                    }
     6047                    else {
     6048                        cooked += ch;
     6049                    }
     6050                }
     6051                if (!terminated) {
     6052                    this.throwUnexpectedToken();
     6053                }
     6054                if (!head) {
     6055                    this.curlyStack.pop();
     6056                }
     6057                return {
     6058                    type: 10 /* Template */,
     6059                    value: this.source.slice(start + 1, this.index - rawOffset),
     6060                    cooked: cooked,
     6061                    head: head,
     6062                    tail: tail,
     6063                    lineNumber: this.lineNumber,
     6064                    lineStart: this.lineStart,
     6065                    start: start,
     6066                    end: this.index
     6067                };
     6068            };
     6069            // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
     6070            Scanner.prototype.testRegExp = function (pattern, flags) {
     6071                // The BMP character to use as a replacement for astral symbols when
     6072                // translating an ES6 "u"-flagged pattern to an ES5-compatible
     6073                // approximation.
     6074                // Note: replacing with '\uFFFF' enables false positives in unlikely
     6075                // scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
     6076                // pattern that would not be detected by this substitution.
     6077                var astralSubstitute = '\uFFFF';
     6078                var tmp = pattern;
     6079                var self = this;
     6080                if (flags.indexOf('u') >= 0) {
     6081                    tmp = tmp
     6082                        .replace(/\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})/g, function ($0, $1, $2) {
     6083                        var codePoint = parseInt($1 || $2, 16);
     6084                        if (codePoint > 0x10FFFF) {
     6085                            self.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
     6086                        }
     6087                        if (codePoint <= 0xFFFF) {
     6088                            return String.fromCharCode(codePoint);
     6089                        }
     6090                        return astralSubstitute;
     6091                    })
     6092                        .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, astralSubstitute);
     6093                }
     6094                // First, detect invalid regular expressions.
     6095                try {
     6096                    RegExp(tmp);
     6097                }
     6098                catch (e) {
     6099                    this.throwUnexpectedToken(messages_1.Messages.InvalidRegExp);
     6100                }
     6101                // Return a regular expression object for this pattern-flag pair, or
     6102                // `null` in case the current environment doesn't support the flags it
     6103                // uses.
     6104                try {
     6105                    return new RegExp(pattern, flags);
     6106                }
     6107                catch (exception) {
     6108                    /* istanbul ignore next */
     6109                    return null;
     6110                }
     6111            };
     6112            Scanner.prototype.scanRegExpBody = function () {
     6113                var ch = this.source[this.index];
     6114                assert_1.assert(ch === '/', 'Regular expression literal must start with a slash');
     6115                var str = this.source[this.index++];
     6116                var classMarker = false;
     6117                var terminated = false;
     6118                while (!this.eof()) {
     6119                    ch = this.source[this.index++];
     6120                    str += ch;
     6121                    if (ch === '\\') {
     6122                        ch = this.source[this.index++];
     6123                        // https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
     6124                        if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     6125                            this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
     6126                        }
     6127                        str += ch;
     6128                    }
     6129                    else if (character_1.Character.isLineTerminator(ch.charCodeAt(0))) {
     6130                        this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
     6131                    }
     6132                    else if (classMarker) {
     6133                        if (ch === ']') {
     6134                            classMarker = false;
     6135                        }
     6136                    }
     6137                    else {
     6138                        if (ch === '/') {
     6139                            terminated = true;
     6140                            break;
     6141                        }
     6142                        else if (ch === '[') {
     6143                            classMarker = true;
     6144                        }
     6145                    }
     6146                }
     6147                if (!terminated) {
     6148                    this.throwUnexpectedToken(messages_1.Messages.UnterminatedRegExp);
     6149                }
     6150                // Exclude leading and trailing slash.
     6151                return str.substr(1, str.length - 2);
     6152            };
     6153            Scanner.prototype.scanRegExpFlags = function () {
     6154                var str = '';
     6155                var flags = '';
     6156                while (!this.eof()) {
     6157                    var ch = this.source[this.index];
     6158                    if (!character_1.Character.isIdentifierPart(ch.charCodeAt(0))) {
     6159                        break;
     6160                    }
     6161                    ++this.index;
     6162                    if (ch === '\\' && !this.eof()) {
     6163                        ch = this.source[this.index];
     6164                        if (ch === 'u') {
     6165                            ++this.index;
     6166                            var restore = this.index;
     6167                            var char = this.scanHexEscape('u');
     6168                            if (char !== null) {
     6169                                flags += char;
     6170                                for (str += '\\u'; restore < this.index; ++restore) {
     6171                                    str += this.source[restore];
     6172                                }
     6173                            }
     6174                            else {
     6175                                this.index = restore;
     6176                                flags += 'u';
     6177                                str += '\\u';
     6178                            }
     6179                            this.tolerateUnexpectedToken();
     6180                        }
     6181                        else {
     6182                            str += '\\';
     6183                            this.tolerateUnexpectedToken();
     6184                        }
     6185                    }
     6186                    else {
     6187                        flags += ch;
     6188                        str += ch;
     6189                    }
     6190                }
     6191                return flags;
     6192            };
     6193            Scanner.prototype.scanRegExp = function () {
     6194                var start = this.index;
     6195                var pattern = this.scanRegExpBody();
     6196                var flags = this.scanRegExpFlags();
     6197                var value = this.testRegExp(pattern, flags);
     6198                return {
     6199                    type: 9 /* RegularExpression */,
     6200                    value: '',
     6201                    pattern: pattern,
     6202                    flags: flags,
     6203                    regex: value,
     6204                    lineNumber: this.lineNumber,
     6205                    lineStart: this.lineStart,
     6206                    start: start,
     6207                    end: this.index
     6208                };
     6209            };
     6210            Scanner.prototype.lex = function () {
     6211                if (this.eof()) {
     6212                    return {
     6213                        type: 2 /* EOF */,
     6214                        value: '',
     6215                        lineNumber: this.lineNumber,
     6216                        lineStart: this.lineStart,
     6217                        start: this.index,
     6218                        end: this.index
     6219                    };
     6220                }
     6221                var cp = this.source.charCodeAt(this.index);
     6222                if (character_1.Character.isIdentifierStart(cp)) {
     6223                    return this.scanIdentifier();
     6224                }
     6225                // Very common: ( and ) and ;
     6226                if (cp === 0x28 || cp === 0x29 || cp === 0x3B) {
     6227                    return this.scanPunctuator();
     6228                }
     6229                // String literal starts with single quote (U+0027) or double quote (U+0022).
     6230                if (cp === 0x27 || cp === 0x22) {
     6231                    return this.scanStringLiteral();
     6232                }
     6233                // Dot (.) U+002E can also start a floating-point number, hence the need
     6234                // to check the next character.
     6235                if (cp === 0x2E) {
     6236                    if (character_1.Character.isDecimalDigit(this.source.charCodeAt(this.index + 1))) {
     6237                        return this.scanNumericLiteral();
     6238                    }
     6239                    return this.scanPunctuator();
     6240                }
     6241                if (character_1.Character.isDecimalDigit(cp)) {
     6242                    return this.scanNumericLiteral();
     6243                }
     6244                // Template literals start with ` (U+0060) for template head
     6245                // or } (U+007D) for template middle or template tail.
     6246                if (cp === 0x60 || (cp === 0x7D && this.curlyStack[this.curlyStack.length - 1] === '${')) {
     6247                    return this.scanTemplate();
     6248                }
     6249                // Possible identifier start in a surrogate pair.
     6250                if (cp >= 0xD800 && cp < 0xDFFF) {
     6251                    if (character_1.Character.isIdentifierStart(this.codePointAt(this.index))) {
     6252                        return this.scanIdentifier();
     6253                    }
     6254                }
     6255                return this.scanPunctuator();
     6256            };
     6257            return Scanner;
     6258        }());
     6259        exports.Scanner = Scanner;
     6260
     6261
     6262/***/ },
     6263/* 13 */
     6264/***/ function(module, exports) {
     6265
     6266        "use strict";
     6267        Object.defineProperty(exports, "__esModule", { value: true });
     6268        exports.TokenName = {};
     6269        exports.TokenName[1 /* BooleanLiteral */] = 'Boolean';
     6270        exports.TokenName[2 /* EOF */] = '<end>';
     6271        exports.TokenName[3 /* Identifier */] = 'Identifier';
     6272        exports.TokenName[4 /* Keyword */] = 'Keyword';
     6273        exports.TokenName[5 /* NullLiteral */] = 'Null';
     6274        exports.TokenName[6 /* NumericLiteral */] = 'Numeric';
     6275        exports.TokenName[7 /* Punctuator */] = 'Punctuator';
     6276        exports.TokenName[8 /* StringLiteral */] = 'String';
     6277        exports.TokenName[9 /* RegularExpression */] = 'RegularExpression';
     6278        exports.TokenName[10 /* Template */] = 'Template';
     6279
     6280
     6281/***/ },
     6282/* 14 */
     6283/***/ function(module, exports) {
     6284
     6285        "use strict";
     6286        // Generated by generate-xhtml-entities.js. DO NOT MODIFY!
     6287        Object.defineProperty(exports, "__esModule", { value: true });
     6288        exports.XHTMLEntities = {
     6289            quot: '\u0022',
     6290            amp: '\u0026',
     6291            apos: '\u0027',
     6292            gt: '\u003E',
     6293            nbsp: '\u00A0',
     6294            iexcl: '\u00A1',
     6295            cent: '\u00A2',
     6296            pound: '\u00A3',
     6297            curren: '\u00A4',
     6298            yen: '\u00A5',
     6299            brvbar: '\u00A6',
     6300            sect: '\u00A7',
     6301            uml: '\u00A8',
     6302            copy: '\u00A9',
     6303            ordf: '\u00AA',
     6304            laquo: '\u00AB',
     6305            not: '\u00AC',
     6306            shy: '\u00AD',
     6307            reg: '\u00AE',
     6308            macr: '\u00AF',
     6309            deg: '\u00B0',
     6310            plusmn: '\u00B1',
     6311            sup2: '\u00B2',
     6312            sup3: '\u00B3',
     6313            acute: '\u00B4',
     6314            micro: '\u00B5',
     6315            para: '\u00B6',
     6316            middot: '\u00B7',
     6317            cedil: '\u00B8',
     6318            sup1: '\u00B9',
     6319            ordm: '\u00BA',
     6320            raquo: '\u00BB',
     6321            frac14: '\u00BC',
     6322            frac12: '\u00BD',
     6323            frac34: '\u00BE',
     6324            iquest: '\u00BF',
     6325            Agrave: '\u00C0',
     6326            Aacute: '\u00C1',
     6327            Acirc: '\u00C2',
     6328            Atilde: '\u00C3',
     6329            Auml: '\u00C4',
     6330            Aring: '\u00C5',
     6331            AElig: '\u00C6',
     6332            Ccedil: '\u00C7',
     6333            Egrave: '\u00C8',
     6334            Eacute: '\u00C9',
     6335            Ecirc: '\u00CA',
     6336            Euml: '\u00CB',
     6337            Igrave: '\u00CC',
     6338            Iacute: '\u00CD',
     6339            Icirc: '\u00CE',
     6340            Iuml: '\u00CF',
     6341            ETH: '\u00D0',
     6342            Ntilde: '\u00D1',
     6343            Ograve: '\u00D2',
     6344            Oacute: '\u00D3',
     6345            Ocirc: '\u00D4',
     6346            Otilde: '\u00D5',
     6347            Ouml: '\u00D6',
     6348            times: '\u00D7',
     6349            Oslash: '\u00D8',
     6350            Ugrave: '\u00D9',
     6351            Uacute: '\u00DA',
     6352            Ucirc: '\u00DB',
     6353            Uuml: '\u00DC',
     6354            Yacute: '\u00DD',
     6355            THORN: '\u00DE',
     6356            szlig: '\u00DF',
     6357            agrave: '\u00E0',
     6358            aacute: '\u00E1',
     6359            acirc: '\u00E2',
     6360            atilde: '\u00E3',
     6361            auml: '\u00E4',
     6362            aring: '\u00E5',
     6363            aelig: '\u00E6',
     6364            ccedil: '\u00E7',
     6365            egrave: '\u00E8',
     6366            eacute: '\u00E9',
     6367            ecirc: '\u00EA',
     6368            euml: '\u00EB',
     6369            igrave: '\u00EC',
     6370            iacute: '\u00ED',
     6371            icirc: '\u00EE',
     6372            iuml: '\u00EF',
     6373            eth: '\u00F0',
     6374            ntilde: '\u00F1',
     6375            ograve: '\u00F2',
     6376            oacute: '\u00F3',
     6377            ocirc: '\u00F4',
     6378            otilde: '\u00F5',
     6379            ouml: '\u00F6',
     6380            divide: '\u00F7',
     6381            oslash: '\u00F8',
     6382            ugrave: '\u00F9',
     6383            uacute: '\u00FA',
     6384            ucirc: '\u00FB',
     6385            uuml: '\u00FC',
     6386            yacute: '\u00FD',
     6387            thorn: '\u00FE',
     6388            yuml: '\u00FF',
     6389            OElig: '\u0152',
     6390            oelig: '\u0153',
     6391            Scaron: '\u0160',
     6392            scaron: '\u0161',
     6393            Yuml: '\u0178',
     6394            fnof: '\u0192',
     6395            circ: '\u02C6',
     6396            tilde: '\u02DC',
     6397            Alpha: '\u0391',
     6398            Beta: '\u0392',
     6399            Gamma: '\u0393',
     6400            Delta: '\u0394',
     6401            Epsilon: '\u0395',
     6402            Zeta: '\u0396',
     6403            Eta: '\u0397',
     6404            Theta: '\u0398',
     6405            Iota: '\u0399',
     6406            Kappa: '\u039A',
     6407            Lambda: '\u039B',
     6408            Mu: '\u039C',
     6409            Nu: '\u039D',
     6410            Xi: '\u039E',
     6411            Omicron: '\u039F',
     6412            Pi: '\u03A0',
     6413            Rho: '\u03A1',
     6414            Sigma: '\u03A3',
     6415            Tau: '\u03A4',
     6416            Upsilon: '\u03A5',
     6417            Phi: '\u03A6',
     6418            Chi: '\u03A7',
     6419            Psi: '\u03A8',
     6420            Omega: '\u03A9',
     6421            alpha: '\u03B1',
     6422            beta: '\u03B2',
     6423            gamma: '\u03B3',
     6424            delta: '\u03B4',
     6425            epsilon: '\u03B5',
     6426            zeta: '\u03B6',
     6427            eta: '\u03B7',
     6428            theta: '\u03B8',
     6429            iota: '\u03B9',
     6430            kappa: '\u03BA',
     6431            lambda: '\u03BB',
     6432            mu: '\u03BC',
     6433            nu: '\u03BD',
     6434            xi: '\u03BE',
     6435            omicron: '\u03BF',
     6436            pi: '\u03C0',
     6437            rho: '\u03C1',
     6438            sigmaf: '\u03C2',
     6439            sigma: '\u03C3',
     6440            tau: '\u03C4',
     6441            upsilon: '\u03C5',
     6442            phi: '\u03C6',
     6443            chi: '\u03C7',
     6444            psi: '\u03C8',
     6445            omega: '\u03C9',
     6446            thetasym: '\u03D1',
     6447            upsih: '\u03D2',
     6448            piv: '\u03D6',
     6449            ensp: '\u2002',
     6450            emsp: '\u2003',
     6451            thinsp: '\u2009',
     6452            zwnj: '\u200C',
     6453            zwj: '\u200D',
     6454            lrm: '\u200E',
     6455            rlm: '\u200F',
     6456            ndash: '\u2013',
     6457            mdash: '\u2014',
     6458            lsquo: '\u2018',
     6459            rsquo: '\u2019',
     6460            sbquo: '\u201A',
     6461            ldquo: '\u201C',
     6462            rdquo: '\u201D',
     6463            bdquo: '\u201E',
     6464            dagger: '\u2020',
     6465            Dagger: '\u2021',
     6466            bull: '\u2022',
     6467            hellip: '\u2026',
     6468            permil: '\u2030',
     6469            prime: '\u2032',
     6470            Prime: '\u2033',
     6471            lsaquo: '\u2039',
     6472            rsaquo: '\u203A',
     6473            oline: '\u203E',
     6474            frasl: '\u2044',
     6475            euro: '\u20AC',
     6476            image: '\u2111',
     6477            weierp: '\u2118',
     6478            real: '\u211C',
     6479            trade: '\u2122',
     6480            alefsym: '\u2135',
     6481            larr: '\u2190',
     6482            uarr: '\u2191',
     6483            rarr: '\u2192',
     6484            darr: '\u2193',
     6485            harr: '\u2194',
     6486            crarr: '\u21B5',
     6487            lArr: '\u21D0',
     6488            uArr: '\u21D1',
     6489            rArr: '\u21D2',
     6490            dArr: '\u21D3',
     6491            hArr: '\u21D4',
     6492            forall: '\u2200',
     6493            part: '\u2202',
     6494            exist: '\u2203',
     6495            empty: '\u2205',
     6496            nabla: '\u2207',
     6497            isin: '\u2208',
     6498            notin: '\u2209',
     6499            ni: '\u220B',
     6500            prod: '\u220F',
     6501            sum: '\u2211',
     6502            minus: '\u2212',
     6503            lowast: '\u2217',
     6504            radic: '\u221A',
     6505            prop: '\u221D',
     6506            infin: '\u221E',
     6507            ang: '\u2220',
     6508            and: '\u2227',
     6509            or: '\u2228',
     6510            cap: '\u2229',
     6511            cup: '\u222A',
     6512            int: '\u222B',
     6513            there4: '\u2234',
     6514            sim: '\u223C',
     6515            cong: '\u2245',
     6516            asymp: '\u2248',
     6517            ne: '\u2260',
     6518            equiv: '\u2261',
     6519            le: '\u2264',
     6520            ge: '\u2265',
     6521            sub: '\u2282',
     6522            sup: '\u2283',
     6523            nsub: '\u2284',
     6524            sube: '\u2286',
     6525            supe: '\u2287',
     6526            oplus: '\u2295',
     6527            otimes: '\u2297',
     6528            perp: '\u22A5',
     6529            sdot: '\u22C5',
     6530            lceil: '\u2308',
     6531            rceil: '\u2309',
     6532            lfloor: '\u230A',
     6533            rfloor: '\u230B',
     6534            loz: '\u25CA',
     6535            spades: '\u2660',
     6536            clubs: '\u2663',
     6537            hearts: '\u2665',
     6538            diams: '\u2666',
     6539            lang: '\u27E8',
     6540            rang: '\u27E9'
     6541        };
     6542
     6543
     6544/***/ },
     6545/* 15 */
     6546/***/ function(module, exports, __webpack_require__) {
     6547
     6548        "use strict";
     6549        Object.defineProperty(exports, "__esModule", { value: true });
     6550        var error_handler_1 = __webpack_require__(10);
     6551        var scanner_1 = __webpack_require__(12);
     6552        var token_1 = __webpack_require__(13);
     6553        var Reader = (function () {
     6554            function Reader() {
     6555                this.values = [];
     6556                this.curly = this.paren = -1;
     6557            }
     6558            // A function following one of those tokens is an expression.
     6559            Reader.prototype.beforeFunctionExpression = function (t) {
     6560                return ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
     6561                    'return', 'case', 'delete', 'throw', 'void',
     6562                    // assignment operators
     6563                    '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=',
     6564                    '&=', '|=', '^=', ',',
     6565                    // binary/unary operators
     6566                    '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
     6567                    '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
     6568                    '<=', '<', '>', '!=', '!=='].indexOf(t) >= 0;
     6569            };
     6570            // Determine if forward slash (/) is an operator or part of a regular expression
     6571            // https://github.com/mozilla/sweet.js/wiki/design
     6572            Reader.prototype.isRegexStart = function () {
     6573                var previous = this.values[this.values.length - 1];
     6574                var regex = (previous !== null);
     6575                switch (previous) {
     6576                    case 'this':
     6577                    case ']':
     6578                        regex = false;
     6579                        break;
     6580                    case ')':
     6581                        var keyword = this.values[this.paren - 1];
     6582                        regex = (keyword === 'if' || keyword === 'while' || keyword === 'for' || keyword === 'with');
     6583                        break;
     6584                    case '}':
     6585                        // Dividing a function by anything makes little sense,
     6586                        // but we have to check for that.
     6587                        regex = false;
     6588                        if (this.values[this.curly - 3] === 'function') {
     6589                            // Anonymous function, e.g. function(){} /42
     6590                            var check = this.values[this.curly - 4];
     6591                            regex = check ? !this.beforeFunctionExpression(check) : false;
     6592                        }
     6593                        else if (this.values[this.curly - 4] === 'function') {
     6594                            // Named function, e.g. function f(){} /42/
     6595                            var check = this.values[this.curly - 5];
     6596                            regex = check ? !this.beforeFunctionExpression(check) : true;
     6597                        }
     6598                        break;
     6599                    default:
     6600                        break;
     6601                }
     6602                return regex;
     6603            };
     6604            Reader.prototype.push = function (token) {
     6605                if (token.type === 7 /* Punctuator */ || token.type === 4 /* Keyword */) {
     6606                    if (token.value === '{') {
     6607                        this.curly = this.values.length;
     6608                    }
     6609                    else if (token.value === '(') {
     6610                        this.paren = this.values.length;
     6611                    }
     6612                    this.values.push(token.value);
     6613                }
     6614                else {
     6615                    this.values.push(null);
     6616                }
     6617            };
     6618            return Reader;
     6619        }());
     6620        var Tokenizer = (function () {
     6621            function Tokenizer(code, config) {
     6622                this.errorHandler = new error_handler_1.ErrorHandler();
     6623                this.errorHandler.tolerant = config ? (typeof config.tolerant === 'boolean' && config.tolerant) : false;
     6624                this.scanner = new scanner_1.Scanner(code, this.errorHandler);
     6625                this.scanner.trackComment = config ? (typeof config.comment === 'boolean' && config.comment) : false;
     6626                this.trackRange = config ? (typeof config.range === 'boolean' && config.range) : false;
     6627                this.trackLoc = config ? (typeof config.loc === 'boolean' && config.loc) : false;
     6628                this.buffer = [];
     6629                this.reader = new Reader();
     6630            }
     6631            Tokenizer.prototype.errors = function () {
     6632                return this.errorHandler.errors;
     6633            };
     6634            Tokenizer.prototype.getNextToken = function () {
     6635                if (this.buffer.length === 0) {
     6636                    var comments = this.scanner.scanComments();
     6637                    if (this.scanner.trackComment) {
     6638                        for (var i = 0; i < comments.length; ++i) {
     6639                            var e = comments[i];
     6640                            var value = this.scanner.source.slice(e.slice[0], e.slice[1]);
     6641                            var comment = {
     6642                                type: e.multiLine ? 'BlockComment' : 'LineComment',
     6643                                value: value
     6644                            };
     6645                            if (this.trackRange) {
     6646                                comment.range = e.range;
     6647                            }
     6648                            if (this.trackLoc) {
     6649                                comment.loc = e.loc;
     6650                            }
     6651                            this.buffer.push(comment);
     6652                        }
     6653                    }
     6654                    if (!this.scanner.eof()) {
     6655                        var loc = void 0;
     6656                        if (this.trackLoc) {
     6657                            loc = {
     6658                                start: {
     6659                                    line: this.scanner.lineNumber,
     6660                                    column: this.scanner.index - this.scanner.lineStart
     6661                                },
     6662                                end: {}
     6663                            };
     6664                        }
     6665                        var startRegex = (this.scanner.source[this.scanner.index] === '/') && this.reader.isRegexStart();
     6666                        var token = startRegex ? this.scanner.scanRegExp() : this.scanner.lex();
     6667                        this.reader.push(token);
     6668                        var entry = {
     6669                            type: token_1.TokenName[token.type],
     6670                            value: this.scanner.source.slice(token.start, token.end)
     6671                        };
     6672                        if (this.trackRange) {
     6673                            entry.range = [token.start, token.end];
     6674                        }
     6675                        if (this.trackLoc) {
     6676                            loc.end = {
     6677                                line: this.scanner.lineNumber,
     6678                                column: this.scanner.index - this.scanner.lineStart
     6679                            };
     6680                            entry.loc = loc;
     6681                        }
     6682                        if (token.type === 9 /* RegularExpression */) {
     6683                            var pattern = token.pattern;
     6684                            var flags = token.flags;
     6685                            entry.regex = { pattern: pattern, flags: flags };
     6686                        }
     6687                        this.buffer.push(entry);
     6688                    }
     6689                }
     6690                return this.buffer.shift();
     6691            };
     6692            return Tokenizer;
     6693        }());
     6694        exports.Tokenizer = Tokenizer;
     6695
     6696
     6697/***/ }
     6698/******/ ])
     6699});
     6700;
     6701
     6702// JSHINT has some GPL Compatability issues, so we are faking it out and using esprima for validation
     6703// Based on https://github.com/jquery/esprima/blob/gh-pages/demo/validate.js which is MIT licensed
     6704
     6705var fakeJSHINT = new function() {
     6706        var syntax, errors;
     6707        var that = this;
     6708        this.data = [];
     6709        this.convertError = function( error ){
     6710                return {
     6711                        line: error.lineNumber,
     6712                        character: error.column,
     6713                        reason: error.description,
     6714                        code: 'E'
     6715                };
     6716        };
     6717        this.parse = function( code ){
     6718                try {
     6719                        syntax = window.esprima.parse(code, { tolerant: true, loc: true });
     6720                        errors = syntax.errors;
     6721                        if ( errors.length > 0 ) {
     6722                                for ( var i = 0; i < errors.length; i++) {
     6723                                        var error = errors[i];
     6724                                        that.data.push( that.convertError( error ) );
     6725                                }
     6726                        } else {
     6727                                that.data = [];
     6728                        }
     6729                } catch (e) {
     6730                        that.data.push( that.convertError( e ) );
     6731                }
     6732        };
    286733};
    296734
    30 },{}],2:[function(require,module,exports){
    31 var str = '768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,1155,1156,1157,1158,1159,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1471,1473,1474,1476,1477,1479,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1648,1750,1751,1752,1753,1754,1755,1756,1759,1760,1761,1762,1763,1764,1767,1768,1770,1771,1772,1773,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1809,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,2027,2028,2029,2030,2031,2032,2033,2034,2035,2070,2071,2072,2073,2075,2076,2077,2078,2079,2080,2081,2082,2083,2085,2086,2087,2089,2090,2091,2092,2093,2137,2138,2139,2276,2277,2278,2279,2280,2281,2282,2283,2284,2285,2286,2287,2288,2289,2290,2291,2292,2293,2294,2295,2296,2297,2298,2299,2300,2301,2302,2304,2305,2306,2307,2362,2363,2364,2366,2367,2368,2369,2370,2371,2372,2373,2374,2375,2376,2377,2378,2379,2380,2381,2382,2383,2385,2386,2387,2388,2389,2390,2391,2402,2403,2406,2407,2408,2409,2410,2411,2412,2413,2414,2415,2433,2434,2435,2492,2494,2495,2496,2497,2498,2499,2500,2503,2504,2507,2508,2509,2519,2530,2531,2534,2535,2536,2537,2538,2539,2540,2541,2542,2543,2561,2562,2563,2620,2622,2623,2624,2625,2626,2631,2632,2635,2636,2637,2641,2662,2663,2664,2665,2666,2667,2668,2669,2670,2671,2672,2673,2677,2689,2690,2691,2748,2750,2751,2752,2753,2754,2755,2756,2757,2759,2760,2761,2763,2764,2765,2786,2787,2790,2791,2792,2793,2794,2795,2796,2797,2798,2799,2817,2818,2819,2876,2878,2879,2880,2881,2882,2883,2884,2887,2888,2891,2892,2893,2902,2903,2914,2915,2918,2919,2920,2921,2922,2923,2924,2925,2926,2927,2946,3006,3007,3008,3009,3010,3014,3015,3016,3018,3019,3020,3021,3031,3046,3047,3048,3049,3050,3051,3052,3053,3054,3055,3073,3074,3075,3134,3135,3136,3137,3138,3139,3140,3142,3143,3144,3146,3147,3148,3149,3157,3158,3170,3171,3174,3175,3176,3177,3178,3179,3180,3181,3182,3183,3202,3203,3260,3262,3263,3264,3265,3266,3267,3268,3270,3271,3272,3274,3275,3276,3277,3285,3286,3298,3299,3302,3303,3304,3305,3306,3307,3308,3309,3310,3311,3330,3331,3390,3391,3392,3393,3394,3395,3396,3398,3399,3400,3402,3403,3404,3405,3415,3426,3427,3430,3431,3432,3433,3434,3435,3436,3437,3438,3439,3458,3459,3530,3535,3536,3537,3538,3539,3540,3542,3544,3545,3546,3547,3548,3549,3550,3551,3570,3571,3633,3636,3637,3638,3639,3640,3641,3642,3655,3656,3657,3658,3659,3660,3661,3662,3664,3665,3666,3667,3668,3669,3670,3671,3672,3673,3761,3764,3765,3766,3767,3768,3769,3771,3772,3784,3785,3786,3787,3788,3789,3792,3793,3794,3795,3796,3797,3798,3799,3800,3801,3864,3865,3872,3873,3874,3875,3876,3877,3878,3879,3880,3881,3893,3895,3897,3902,3903,3953,3954,3955,3956,3957,3958,3959,3960,3961,3962,3963,3964,3965,3966,3967,3968,3969,3970,3971,3972,3974,3975,3981,3982,3983,3984,3985,3986,3987,3988,3989,3990,3991,3993,3994,3995,3996,3997,3998,3999,4000,4001,4002,4003,4004,4005,4006,4007,4008,4009,4010,4011,4012,4013,4014,4015,4016,4017,4018,4019,4020,4021,4022,4023,4024,4025,4026,4027,4028,4038,4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,4153,4154,4155,4156,4157,4158,4160,4161,4162,4163,4164,4165,4166,4167,4168,4169,4182,4183,4184,4185,4190,4191,4192,4194,4195,4196,4199,4200,4201,4202,4203,4204,4205,4209,4210,4211,4212,4226,4227,4228,4229,4230,4231,4232,4233,4234,4235,4236,4237,4239,4240,4241,4242,4243,4244,4245,4246,4247,4248,4249,4250,4251,4252,4253,4957,4958,4959,5906,5907,5908,5938,5939,5940,5970,5971,6002,6003,6068,6069,6070,6071,6072,6073,6074,6075,6076,6077,6078,6079,6080,6081,6082,6083,6084,6085,6086,6087,6088,6089,6090,6091,6092,6093,6094,6095,6096,6097,6098,6099,6109,6112,6113,6114,6115,6116,6117,6118,6119,6120,6121,6155,6156,6157,6160,6161,6162,6163,6164,6165,6166,6167,6168,6169,6313,6432,6433,6434,6435,6436,6437,6438,6439,6440,6441,6442,6443,6448,6449,6450,6451,6452,6453,6454,6455,6456,6457,6458,6459,6470,6471,6472,6473,6474,6475,6476,6477,6478,6479,6576,6577,6578,6579,6580,6581,6582,6583,6584,6585,6586,6587,6588,6589,6590,6591,6592,6600,6601,6608,6609,6610,6611,6612,6613,6614,6615,6616,6617,6679,6680,6681,6682,6683,6741,6742,6743,6744,6745,6746,6747,6748,6749,6750,6752,6753,6754,6755,6756,6757,6758,6759,6760,6761,6762,6763,6764,6765,6766,6767,6768,6769,6770,6771,6772,6773,6774,6775,6776,6777,6778,6779,6780,6783,6784,6785,6786,6787,6788,6789,6790,6791,6792,6793,6800,6801,6802,6803,6804,6805,6806,6807,6808,6809,6912,6913,6914,6915,6916,6964,6965,6966,6967,6968,6969,6970,6971,6972,6973,6974,6975,6976,6977,6978,6979,6980,6992,6993,6994,6995,6996,6997,6998,6999,7000,7001,7019,7020,7021,7022,7023,7024,7025,7026,7027,7040,7041,7042,7073,7074,7075,7076,7077,7078,7079,7080,7081,7082,7083,7084,7085,7088,7089,7090,7091,7092,7093,7094,7095,7096,7097,7142,7143,7144,7145,7146,7147,7148,7149,7150,7151,7152,7153,7154,7155,7204,7205,7206,7207,7208,7209,7210,7211,7212,7213,7214,7215,7216,7217,7218,7219,7220,7221,7222,7223,7232,7233,7234,7235,7236,7237,7238,7239,7240,7241,7248,7249,7250,7251,7252,7253,7254,7255,7256,7257,7376,7377,7378,7380,7381,7382,7383,7384,7385,7386,7387,7388,7389,7390,7391,7392,7393,7394,7395,7396,7397,7398,7399,7400,7405,7410,7411,7412,7616,7617,7618,7619,7620,7621,7622,7623,7624,7625,7626,7627,7628,7629,7630,7631,7632,7633,7634,7635,7636,7637,7638,7639,7640,7641,7642,7643,7644,7645,7646,7647,7648,7649,7650,7651,7652,7653,7654,7676,7677,7678,7679,8204,8205,8255,8256,8276,8400,8401,8402,8403,8404,8405,8406,8407,8408,8409,8410,8411,8412,8417,8421,8422,8423,8424,8425,8426,8427,8428,8429,8430,8431,8432,11503,11504,11505,11647,11744,11745,11746,11747,11748,11749,11750,11751,11752,11753,11754,11755,11756,11757,11758,11759,11760,11761,11762,11763,11764,11765,11766,11767,11768,11769,11770,11771,11772,11773,11774,11775,12330,12331,12332,12333,12334,12335,12441,12442,42528,42529,42530,42531,42532,42533,42534,42535,42536,42537,42607,42612,42613,42614,42615,42616,42617,42618,42619,42620,42621,42655,42736,42737,43010,43014,43019,43043,43044,43045,43046,43047,43136,43137,43188,43189,43190,43191,43192,43193,43194,43195,43196,43197,43198,43199,43200,43201,43202,43203,43204,43216,43217,43218,43219,43220,43221,43222,43223,43224,43225,43232,43233,43234,43235,43236,43237,43238,43239,43240,43241,43242,43243,43244,43245,43246,43247,43248,43249,43264,43265,43266,43267,43268,43269,43270,43271,43272,43273,43302,43303,43304,43305,43306,43307,43308,43309,43335,43336,43337,43338,43339,43340,43341,43342,43343,43344,43345,43346,43347,43392,43393,43394,43395,43443,43444,43445,43446,43447,43448,43449,43450,43451,43452,43453,43454,43455,43456,43472,43473,43474,43475,43476,43477,43478,43479,43480,43481,43561,43562,43563,43564,43565,43566,43567,43568,43569,43570,43571,43572,43573,43574,43587,43596,43597,43600,43601,43602,43603,43604,43605,43606,43607,43608,43609,43643,43696,43698,43699,43700,43703,43704,43710,43711,43713,43755,43756,43757,43758,43759,43765,43766,44003,44004,44005,44006,44007,44008,44009,44010,44012,44013,44016,44017,44018,44019,44020,44021,44022,44023,44024,44025,64286,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65056,65057,65058,65059,65060,65061,65062,65075,65076,65101,65102,65103,65296,65297,65298,65299,65300,65301,65302,65303,65304,65305,65343';
    32 var arr = str.split(',').map(function(code) {
    33   return parseInt(code, 10);
    34 });
    35 module.exports = arr;
    36 },{}],3:[function(require,module,exports){
    37 var str = '170,181,186,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,710,711,712,713,714,715,716,717,718,719,720,721,736,737,738,739,740,748,750,880,881,882,883,884,886,887,890,891,892,893,902,904,905,906,908,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1369,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1520,1521,1522,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1646,1647,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1749,1765,1766,1774,1775,1786,1787,1788,1791,1808,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1969,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2036,2037,2042,2048,2049,2050,2051,2052,2053,2054,2055,2056,2057,2058,2059,2060,2061,2062,2063,2064,2065,2066,2067,2068,2069,2074,2084,2088,2112,2113,2114,2115,2116,2117,2118,2119,2120,2121,2122,2123,2124,2125,2126,2127,2128,2129,2130,2131,2132,2133,2134,2135,2136,2208,2210,2211,2212,2213,2214,2215,2216,2217,2218,2219,2220,2308,2309,2310,2311,2312,2313,2314,2315,2316,2317,2318,2319,2320,2321,2322,2323,2324,2325,2326,2327,2328,2329,2330,2331,2332,2333,2334,2335,2336,2337,2338,2339,2340,2341,2342,2343,2344,2345,2346,2347,2348,2349,2350,2351,2352,2353,2354,2355,2356,2357,2358,2359,2360,2361,2365,2384,2392,2393,2394,2395,2396,2397,2398,2399,2400,2401,2417,2418,2419,2420,2421,2422,2423,2425,2426,2427,2428,2429,2430,2431,2437,2438,2439,2440,2441,2442,2443,2444,2447,2448,2451,2452,2453,2454,2455,2456,2457,2458,2459,2460,2461,2462,2463,2464,2465,2466,2467,2468,2469,2470,2471,2472,2474,2475,2476,2477,2478,2479,2480,2482,2486,2487,2488,2489,2493,2510,2524,2525,2527,2528,2529,2544,2545,2565,2566,2567,2568,2569,2570,2575,2576,2579,2580,2581,2582,2583,2584,2585,2586,2587,2588,2589,2590,2591,2592,2593,2594,2595,2596,2597,2598,2599,2600,2602,2603,2604,2605,2606,2607,2608,2610,2611,2613,2614,2616,2617,2649,2650,2651,2652,2654,2674,2675,2676,2693,2694,2695,2696,2697,2698,2699,2700,2701,2703,2704,2705,2707,2708,2709,2710,2711,2712,2713,2714,2715,2716,2717,2718,2719,2720,2721,2722,2723,2724,2725,2726,2727,2728,2730,2731,2732,2733,2734,2735,2736,2738,2739,2741,2742,2743,2744,2745,2749,2768,2784,2785,2821,2822,2823,2824,2825,2826,2827,2828,2831,2832,2835,2836,2837,2838,2839,2840,2841,2842,2843,2844,2845,2846,2847,2848,2849,2850,2851,2852,2853,2854,2855,2856,2858,2859,2860,2861,2862,2863,2864,2866,2867,2869,2870,2871,2872,2873,2877,2908,2909,2911,2912,2913,2929,2947,2949,2950,2951,2952,2953,2954,2958,2959,2960,2962,2963,2964,2965,2969,2970,2972,2974,2975,2979,2980,2984,2985,2986,2990,2991,2992,2993,2994,2995,2996,2997,2998,2999,3000,3001,3024,3077,3078,3079,3080,3081,3082,3083,3084,3086,3087,3088,3090,3091,3092,3093,3094,3095,3096,3097,3098,3099,3100,3101,3102,3103,3104,3105,3106,3107,3108,3109,3110,3111,3112,3114,3115,3116,3117,3118,3119,3120,3121,3122,3123,3125,3126,3127,3128,3129,3133,3160,3161,3168,3169,3205,3206,3207,3208,3209,3210,3211,3212,3214,3215,3216,3218,3219,3220,3221,3222,3223,3224,3225,3226,3227,3228,3229,3230,3231,3232,3233,3234,3235,3236,3237,3238,3239,3240,3242,3243,3244,3245,3246,3247,3248,3249,3250,3251,3253,3254,3255,3256,3257,3261,3294,3296,3297,3313,3314,3333,3334,3335,3336,3337,3338,3339,3340,3342,3343,3344,3346,3347,3348,3349,3350,3351,3352,3353,3354,3355,3356,3357,3358,3359,3360,3361,3362,3363,3364,3365,3366,3367,3368,3369,3370,3371,3372,3373,3374,3375,3376,3377,3378,3379,3380,3381,3382,3383,3384,3385,3386,3389,3406,3424,3425,3450,3451,3452,3453,3454,3455,3461,3462,3463,3464,3465,3466,3467,3468,3469,3470,3471,3472,3473,3474,3475,3476,3477,3478,3482,3483,3484,3485,3486,3487,3488,3489,3490,3491,3492,3493,3494,3495,3496,3497,3498,3499,3500,3501,3502,3503,3504,3505,3507,3508,3509,3510,3511,3512,3513,3514,3515,3517,3520,3521,3522,3523,3524,3525,3526,3585,3586,3587,3588,3589,3590,3591,3592,3593,3594,3595,3596,3597,3598,3599,3600,3601,3602,3603,3604,3605,3606,3607,3608,3609,3610,3611,3612,3613,3614,3615,3616,3617,3618,3619,3620,3621,3622,3623,3624,3625,3626,3627,3628,3629,3630,3631,3632,3634,3635,3648,3649,3650,3651,3652,3653,3654,3713,3714,3716,3719,3720,3722,3725,3732,3733,3734,3735,3737,3738,3739,3740,3741,3742,3743,3745,3746,3747,3749,3751,3754,3755,3757,3758,3759,3760,3762,3763,3773,3776,3777,3778,3779,3780,3782,3804,3805,3806,3807,3840,3904,3905,3906,3907,3908,3909,3910,3911,3913,3914,3915,3916,3917,3918,3919,3920,3921,3922,3923,3924,3925,3926,3927,3928,3929,3930,3931,3932,3933,3934,3935,3936,3937,3938,3939,3940,3941,3942,3943,3944,3945,3946,3947,3948,3976,3977,3978,3979,3980,4096,4097,4098,4099,4100,4101,4102,4103,4104,4105,4106,4107,4108,4109,4110,4111,4112,4113,4114,4115,4116,4117,4118,4119,4120,4121,4122,4123,4124,4125,4126,4127,4128,4129,4130,4131,4132,4133,4134,4135,4136,4137,4138,4159,4176,4177,4178,4179,4180,4181,4186,4187,4188,4189,4193,4197,4198,4206,4207,4208,4213,4214,4215,4216,4217,4218,4219,4220,4221,4222,4223,4224,4225,4238,4256,4257,4258,4259,4260,4261,4262,4263,4264,4265,4266,4267,4268,4269,4270,4271,4272,4273,4274,4275,4276,4277,4278,4279,4280,4281,4282,4283,4284,4285,4286,4287,4288,4289,4290,4291,4292,4293,4295,4301,4304,4305,4306,4307,4308,4309,4310,4311,4312,4313,4314,4315,4316,4317,4318,4319,4320,4321,4322,4323,4324,4325,4326,4327,4328,4329,4330,4331,4332,4333,4334,4335,4336,4337,4338,4339,4340,4341,4342,4343,4344,4345,4346,4348,4349,4350,4351,4352,4353,4354,4355,4356,4357,4358,4359,4360,4361,4362,4363,4364,4365,4366,4367,4368,4369,4370,4371,4372,4373,4374,4375,4376,4377,4378,4379,4380,4381,4382,4383,4384,4385,4386,4387,4388,4389,4390,4391,4392,4393,4394,4395,4396,4397,4398,4399,4400,4401,4402,4403,4404,4405,4406,4407,4408,4409,4410,4411,4412,4413,4414,4415,4416,4417,4418,4419,4420,4421,4422,4423,4424,4425,4426,4427,4428,4429,4430,4431,4432,4433,4434,4435,4436,4437,4438,4439,4440,4441,4442,4443,4444,4445,4446,4447,4448,4449,4450,4451,4452,4453,4454,4455,4456,4457,4458,4459,4460,4461,4462,4463,4464,4465,4466,4467,4468,4469,4470,4471,4472,4473,4474,4475,4476,4477,4478,4479,4480,4481,4482,4483,4484,4485,4486,4487,4488,4489,4490,4491,4492,4493,4494,4495,4496,4497,4498,4499,4500,4501,4502,4503,4504,4505,4506,4507,4508,4509,4510,4511,4512,4513,4514,4515,4516,4517,4518,4519,4520,4521,4522,4523,4524,4525,4526,4527,4528,4529,4530,4531,4532,4533,4534,4535,4536,4537,4538,4539,4540,4541,4542,4543,4544,4545,4546,4547,4548,4549,4550,4551,4552,4553,4554,4555,4556,4557,4558,4559,4560,4561,4562,4563,4564,4565,4566,4567,4568,4569,4570,4571,4572,4573,4574,4575,4576,4577,4578,4579,4580,4581,4582,4583,4584,4585,4586,4587,4588,4589,4590,4591,4592,4593,4594,4595,4596,4597,4598,4599,4600,4601,4602,4603,4604,4605,4606,4607,4608,4609,4610,4611,4612,4613,4614,4615,4616,4617,4618,4619,4620,4621,4622,4623,4624,4625,4626,4627,4628,4629,4630,4631,4632,4633,4634,4635,4636,4637,4638,4639,4640,4641,4642,4643,4644,4645,4646,4647,4648,4649,4650,4651,4652,4653,4654,4655,4656,4657,4658,4659,4660,4661,4662,4663,4664,4665,4666,4667,4668,4669,4670,4671,4672,4673,4674,4675,4676,4677,4678,4679,4680,4682,4683,4684,4685,4688,4689,4690,4691,4692,4693,4694,4696,4698,4699,4700,4701,4704,4705,4706,4707,4708,4709,4710,4711,4712,4713,4714,4715,4716,4717,4718,4719,4720,4721,4722,4723,4724,4725,4726,4727,4728,4729,4730,4731,4732,4733,4734,4735,4736,4737,4738,4739,4740,4741,4742,4743,4744,4746,4747,4748,4749,4752,4753,4754,4755,4756,4757,4758,4759,4760,4761,4762,4763,4764,4765,4766,4767,4768,4769,4770,4771,4772,4773,4774,4775,4776,4777,4778,4779,4780,4781,4782,4783,4784,4786,4787,4788,4789,4792,4793,4794,4795,4796,4797,4798,4800,4802,4803,4804,4805,4808,4809,4810,4811,4812,4813,4814,4815,4816,4817,4818,4819,4820,4821,4822,4824,4825,4826,4827,4828,4829,4830,4831,4832,4833,4834,4835,4836,4837,4838,4839,4840,4841,4842,4843,4844,4845,4846,4847,4848,4849,4850,4851,4852,4853,4854,4855,4856,4857,4858,4859,4860,4861,4862,4863,4864,4865,4866,4867,4868,4869,4870,4871,4872,4873,4874,4875,4876,4877,4878,4879,4880,4882,4883,4884,4885,4888,4889,4890,4891,4892,4893,4894,4895,4896,4897,4898,4899,4900,4901,4902,4903,4904,4905,4906,4907,4908,4909,4910,4911,4912,4913,4914,4915,4916,4917,4918,4919,4920,4921,4922,4923,4924,4925,4926,4927,4928,4929,4930,4931,4932,4933,4934,4935,4936,4937,4938,4939,4940,4941,4942,4943,4944,4945,4946,4947,4948,4949,4950,4951,4952,4953,4954,4992,4993,4994,4995,4996,4997,4998,4999,5000,5001,5002,5003,5004,5005,5006,5007,5024,5025,5026,5027,5028,5029,5030,5031,5032,5033,5034,5035,5036,5037,5038,5039,5040,5041,5042,5043,5044,5045,5046,5047,5048,5049,5050,5051,5052,5053,5054,5055,5056,5057,5058,5059,5060,5061,5062,5063,5064,5065,5066,5067,5068,5069,5070,5071,5072,5073,5074,5075,5076,5077,5078,5079,5080,5081,5082,5083,5084,5085,5086,5087,5088,5089,5090,5091,5092,5093,5094,5095,5096,5097,5098,5099,5100,5101,5102,5103,5104,5105,5106,5107,5108,5121,5122,5123,5124,5125,5126,5127,5128,5129,5130,5131,5132,5133,5134,5135,5136,5137,5138,5139,5140,5141,5142,5143,5144,5145,5146,5147,5148,5149,5150,5151,5152,5153,5154,5155,5156,5157,5158,5159,5160,5161,5162,5163,5164,5165,5166,5167,5168,5169,5170,5171,5172,5173,5174,5175,5176,5177,5178,5179,5180,5181,5182,5183,5184,5185,5186,5187,5188,5189,5190,5191,5192,5193,5194,5195,5196,5197,5198,5199,5200,5201,5202,5203,5204,5205,5206,5207,5208,5209,5210,5211,5212,5213,5214,5215,5216,5217,5218,5219,5220,5221,5222,5223,5224,5225,5226,5227,5228,5229,5230,5231,5232,5233,5234,5235,5236,5237,5238,5239,5240,5241,5242,5243,5244,5245,5246,5247,5248,5249,5250,5251,5252,5253,5254,5255,5256,5257,5258,5259,5260,5261,5262,5263,5264,5265,5266,5267,5268,5269,5270,5271,5272,5273,5274,5275,5276,5277,5278,5279,5280,5281,5282,5283,5284,5285,5286,5287,5288,5289,5290,5291,5292,5293,5294,5295,5296,5297,5298,5299,5300,5301,5302,5303,5304,5305,5306,5307,5308,5309,5310,5311,5312,5313,5314,5315,5316,5317,5318,5319,5320,5321,5322,5323,5324,5325,5326,5327,5328,5329,5330,5331,5332,5333,5334,5335,5336,5337,5338,5339,5340,5341,5342,5343,5344,5345,5346,5347,5348,5349,5350,5351,5352,5353,5354,5355,5356,5357,5358,5359,5360,5361,5362,5363,5364,5365,5366,5367,5368,5369,5370,5371,5372,5373,5374,5375,5376,5377,5378,5379,5380,5381,5382,5383,5384,5385,5386,5387,5388,5389,5390,5391,5392,5393,5394,5395,5396,5397,5398,5399,5400,5401,5402,5403,5404,5405,5406,5407,5408,5409,5410,5411,5412,5413,5414,5415,5416,5417,5418,5419,5420,5421,5422,5423,5424,5425,5426,5427,5428,5429,5430,5431,5432,5433,5434,5435,5436,5437,5438,5439,5440,5441,5442,5443,5444,5445,5446,5447,5448,5449,5450,5451,5452,5453,5454,5455,5456,5457,5458,5459,5460,5461,5462,5463,5464,5465,5466,5467,5468,5469,5470,5471,5472,5473,5474,5475,5476,5477,5478,5479,5480,5481,5482,5483,5484,5485,5486,5487,5488,5489,5490,5491,5492,5493,5494,5495,5496,5497,5498,5499,5500,5501,5502,5503,5504,5505,5506,5507,5508,5509,5510,5511,5512,5513,5514,5515,5516,5517,5518,5519,5520,5521,5522,5523,5524,5525,5526,5527,5528,5529,5530,5531,5532,5533,5534,5535,5536,5537,5538,5539,5540,5541,5542,5543,5544,5545,5546,5547,5548,5549,5550,5551,5552,5553,5554,5555,5556,5557,5558,5559,5560,5561,5562,5563,5564,5565,5566,5567,5568,5569,5570,5571,5572,5573,5574,5575,5576,5577,5578,5579,5580,5581,5582,5583,5584,5585,5586,5587,5588,5589,5590,5591,5592,5593,5594,5595,5596,5597,5598,5599,5600,5601,5602,5603,5604,5605,5606,5607,5608,5609,5610,5611,5612,5613,5614,5615,5616,5617,5618,5619,5620,5621,5622,5623,5624,5625,5626,5627,5628,5629,5630,5631,5632,5633,5634,5635,5636,5637,5638,5639,5640,5641,5642,5643,5644,5645,5646,5647,5648,5649,5650,5651,5652,5653,5654,5655,5656,5657,5658,5659,5660,5661,5662,5663,5664,5665,5666,5667,5668,5669,5670,5671,5672,5673,5674,5675,5676,5677,5678,5679,5680,5681,5682,5683,5684,5685,5686,5687,5688,5689,5690,5691,5692,5693,5694,5695,5696,5697,5698,5699,5700,5701,5702,5703,5704,5705,5706,5707,5708,5709,5710,5711,5712,5713,5714,5715,5716,5717,5718,5719,5720,5721,5722,5723,5724,5725,5726,5727,5728,5729,5730,5731,5732,5733,5734,5735,5736,5737,5738,5739,5740,5743,5744,5745,5746,5747,5748,5749,5750,5751,5752,5753,5754,5755,5756,5757,5758,5759,5761,5762,5763,5764,5765,5766,5767,5768,5769,5770,5771,5772,5773,5774,5775,5776,5777,5778,5779,5780,5781,5782,5783,5784,5785,5786,5792,5793,5794,5795,5796,5797,5798,5799,5800,5801,5802,5803,5804,5805,5806,5807,5808,5809,5810,5811,5812,5813,5814,5815,5816,5817,5818,5819,5820,5821,5822,5823,5824,5825,5826,5827,5828,5829,5830,5831,5832,5833,5834,5835,5836,5837,5838,5839,5840,5841,5842,5843,5844,5845,5846,5847,5848,5849,5850,5851,5852,5853,5854,5855,5856,5857,5858,5859,5860,5861,5862,5863,5864,5865,5866,5870,5871,5872,5888,5889,5890,5891,5892,5893,5894,5895,5896,5897,5898,5899,5900,5902,5903,5904,5905,5920,5921,5922,5923,5924,5925,5926,5927,5928,5929,5930,5931,5932,5933,5934,5935,5936,5937,5952,5953,5954,5955,5956,5957,5958,5959,5960,5961,5962,5963,5964,5965,5966,5967,5968,5969,5984,5985,5986,5987,5988,5989,5990,5991,5992,5993,5994,5995,5996,5998,5999,6000,6016,6017,6018,6019,6020,6021,6022,6023,6024,6025,6026,6027,6028,6029,6030,6031,6032,6033,6034,6035,6036,6037,6038,6039,6040,6041,6042,6043,6044,6045,6046,6047,6048,6049,6050,6051,6052,6053,6054,6055,6056,6057,6058,6059,6060,6061,6062,6063,6064,6065,6066,6067,6103,6108,6176,6177,6178,6179,6180,6181,6182,6183,6184,6185,6186,6187,6188,6189,6190,6191,6192,6193,6194,6195,6196,6197,6198,6199,6200,6201,6202,6203,6204,6205,6206,6207,6208,6209,6210,6211,6212,6213,6214,6215,6216,6217,6218,6219,6220,6221,6222,6223,6224,6225,6226,6227,6228,6229,6230,6231,6232,6233,6234,6235,6236,6237,6238,6239,6240,6241,6242,6243,6244,6245,6246,6247,6248,6249,6250,6251,6252,6253,6254,6255,6256,6257,6258,6259,6260,6261,6262,6263,6272,6273,6274,6275,6276,6277,6278,6279,6280,6281,6282,6283,6284,6285,6286,6287,6288,6289,6290,6291,6292,6293,6294,6295,6296,6297,6298,6299,6300,6301,6302,6303,6304,6305,6306,6307,6308,6309,6310,6311,6312,6314,6320,6321,6322,6323,6324,6325,6326,6327,6328,6329,6330,6331,6332,6333,6334,6335,6336,6337,6338,6339,6340,6341,6342,6343,6344,6345,6346,6347,6348,6349,6350,6351,6352,6353,6354,6355,6356,6357,6358,6359,6360,6361,6362,6363,6364,6365,6366,6367,6368,6369,6370,6371,6372,6373,6374,6375,6376,6377,6378,6379,6380,6381,6382,6383,6384,6385,6386,6387,6388,6389,6400,6401,6402,6403,6404,6405,6406,6407,6408,6409,6410,6411,6412,6413,6414,6415,6416,6417,6418,6419,6420,6421,6422,6423,6424,6425,6426,6427,6428,6480,6481,6482,6483,6484,6485,6486,6487,6488,6489,6490,6491,6492,6493,6494,6495,6496,6497,6498,6499,6500,6501,6502,6503,6504,6505,6506,6507,6508,6509,6512,6513,6514,6515,6516,6528,6529,6530,6531,6532,6533,6534,6535,6536,6537,6538,6539,6540,6541,6542,6543,6544,6545,6546,6547,6548,6549,6550,6551,6552,6553,6554,6555,6556,6557,6558,6559,6560,6561,6562,6563,6564,6565,6566,6567,6568,6569,6570,6571,6593,6594,6595,6596,6597,6598,6599,6656,6657,6658,6659,6660,6661,6662,6663,6664,6665,6666,6667,6668,6669,6670,6671,6672,6673,6674,6675,6676,6677,6678,6688,6689,6690,6691,6692,6693,6694,6695,6696,6697,6698,6699,6700,6701,6702,6703,6704,6705,6706,6707,6708,6709,6710,6711,6712,6713,6714,6715,6716,6717,6718,6719,6720,6721,6722,6723,6724,6725,6726,6727,6728,6729,6730,6731,6732,6733,6734,6735,6736,6737,6738,6739,6740,6823,6917,6918,6919,6920,6921,6922,6923,6924,6925,6926,6927,6928,6929,6930,6931,6932,6933,6934,6935,6936,6937,6938,6939,6940,6941,6942,6943,6944,6945,6946,6947,6948,6949,6950,6951,6952,6953,6954,6955,6956,6957,6958,6959,6960,6961,6962,6963,6981,6982,6983,6984,6985,6986,6987,7043,7044,7045,7046,7047,7048,7049,7050,7051,7052,7053,7054,7055,7056,7057,7058,7059,7060,7061,7062,7063,7064,7065,7066,7067,7068,7069,7070,7071,7072,7086,7087,7098,7099,7100,7101,7102,7103,7104,7105,7106,7107,7108,7109,7110,7111,7112,7113,7114,7115,7116,7117,7118,7119,7120,7121,7122,7123,7124,7125,7126,7127,7128,7129,7130,7131,7132,7133,7134,7135,7136,7137,7138,7139,7140,7141,7168,7169,7170,7171,7172,7173,7174,7175,7176,7177,7178,7179,7180,7181,7182,7183,7184,7185,7186,7187,7188,7189,7190,7191,7192,7193,7194,7195,7196,7197,7198,7199,7200,7201,7202,7203,7245,7246,7247,7258,7259,7260,7261,7262,7263,7264,7265,7266,7267,7268,7269,7270,7271,7272,7273,7274,7275,7276,7277,7278,7279,7280,7281,7282,7283,7284,7285,7286,7287,7288,7289,7290,7291,7292,7293,7401,7402,7403,7404,7406,7407,7408,7409,7413,7414,7424,7425,7426,7427,7428,7429,7430,7431,7432,7433,7434,7435,7436,7437,7438,7439,7440,7441,7442,7443,7444,7445,7446,7447,7448,7449,7450,7451,7452,7453,7454,7455,7456,7457,7458,7459,7460,7461,7462,7463,7464,7465,7466,7467,7468,7469,7470,7471,7472,7473,7474,7475,7476,7477,7478,7479,7480,7481,7482,7483,7484,7485,7486,7487,7488,7489,7490,7491,7492,7493,7494,7495,7496,7497,7498,7499,7500,7501,7502,7503,7504,7505,7506,7507,7508,7509,7510,7511,7512,7513,7514,7515,7516,7517,7518,7519,7520,7521,7522,7523,7524,7525,7526,7527,7528,7529,7530,7531,7532,7533,7534,7535,7536,7537,7538,7539,7540,7541,7542,7543,7544,7545,7546,7547,7548,7549,7550,7551,7552,7553,7554,7555,7556,7557,7558,7559,7560,7561,7562,7563,7564,7565,7566,7567,7568,7569,7570,7571,7572,7573,7574,7575,7576,7577,7578,7579,7580,7581,7582,7583,7584,7585,7586,7587,7588,7589,7590,7591,7592,7593,7594,7595,7596,7597,7598,7599,7600,7601,7602,7603,7604,7605,7606,7607,7608,7609,7610,7611,7612,7613,7614,7615,7680,7681,7682,7683,7684,7685,7686,7687,7688,7689,7690,7691,7692,7693,7694,7695,7696,7697,7698,7699,7700,7701,7702,7703,7704,7705,7706,7707,7708,7709,7710,7711,7712,7713,7714,7715,7716,7717,7718,7719,7720,7721,7722,7723,7724,7725,7726,7727,7728,7729,7730,7731,7732,7733,7734,7735,7736,7737,7738,7739,7740,7741,7742,7743,7744,7745,7746,7747,7748,7749,7750,7751,7752,7753,7754,7755,7756,7757,7758,7759,7760,7761,7762,7763,7764,7765,7766,7767,7768,7769,7770,7771,7772,7773,7774,7775,7776,7777,7778,7779,7780,7781,7782,7783,7784,7785,7786,7787,7788,7789,7790,7791,7792,7793,7794,7795,7796,7797,7798,7799,7800,7801,7802,7803,7804,7805,7806,7807,7808,7809,7810,7811,7812,7813,7814,7815,7816,7817,7818,7819,7820,7821,7822,7823,7824,7825,7826,7827,7828,7829,7830,7831,7832,7833,7834,7835,7836,7837,7838,7839,7840,7841,7842,7843,7844,7845,7846,7847,7848,7849,7850,7851,7852,7853,7854,7855,7856,7857,7858,7859,7860,7861,7862,7863,7864,7865,7866,7867,7868,7869,7870,7871,7872,7873,7874,7875,7876,7877,7878,7879,7880,7881,7882,7883,7884,7885,7886,7887,7888,7889,7890,7891,7892,7893,7894,7895,7896,7897,7898,7899,7900,7901,7902,7903,7904,7905,7906,7907,7908,7909,7910,7911,7912,7913,7914,7915,7916,7917,7918,7919,7920,7921,7922,7923,7924,7925,7926,7927,7928,7929,7930,7931,7932,7933,7934,7935,7936,7937,7938,7939,7940,7941,7942,7943,7944,7945,7946,7947,7948,7949,7950,7951,7952,7953,7954,7955,7956,7957,7960,7961,7962,7963,7964,7965,7968,7969,7970,7971,7972,7973,7974,7975,7976,7977,7978,7979,7980,7981,7982,7983,7984,7985,7986,7987,7988,7989,7990,7991,7992,7993,7994,7995,7996,7997,7998,7999,8000,8001,8002,8003,8004,8005,8008,8009,8010,8011,8012,8013,8016,8017,8018,8019,8020,8021,8022,8023,8025,8027,8029,8031,8032,8033,8034,8035,8036,8037,8038,8039,8040,8041,8042,8043,8044,8045,8046,8047,8048,8049,8050,8051,8052,8053,8054,8055,8056,8057,8058,8059,8060,8061,8064,8065,8066,8067,8068,8069,8070,8071,8072,8073,8074,8075,8076,8077,8078,8079,8080,8081,8082,8083,8084,8085,8086,8087,8088,8089,8090,8091,8092,8093,8094,8095,8096,8097,8098,8099,8100,8101,8102,8103,8104,8105,8106,8107,8108,8109,8110,8111,8112,8113,8114,8115,8116,8118,8119,8120,8121,8122,8123,8124,8126,8130,8131,8132,8134,8135,8136,8137,8138,8139,8140,8144,8145,8146,8147,8150,8151,8152,8153,8154,8155,8160,8161,8162,8163,8164,8165,8166,8167,8168,8169,8170,8171,8172,8178,8179,8180,8182,8183,8184,8185,8186,8187,8188,8305,8319,8336,8337,8338,8339,8340,8341,8342,8343,8344,8345,8346,8347,8348,8450,8455,8458,8459,8460,8461,8462,8463,8464,8465,8466,8467,8469,8473,8474,8475,8476,8477,8484,8486,8488,8490,8491,8492,8493,8495,8496,8497,8498,8499,8500,8501,8502,8503,8504,8505,8508,8509,8510,8511,8517,8518,8519,8520,8521,8526,8544,8545,8546,8547,8548,8549,8550,8551,8552,8553,8554,8555,8556,8557,8558,8559,8560,8561,8562,8563,8564,8565,8566,8567,8568,8569,8570,8571,8572,8573,8574,8575,8576,8577,8578,8579,8580,8581,8582,8583,8584,11264,11265,11266,11267,11268,11269,11270,11271,11272,11273,11274,11275,11276,11277,11278,11279,11280,11281,11282,11283,11284,11285,11286,11287,11288,11289,11290,11291,11292,11293,11294,11295,11296,11297,11298,11299,11300,11301,11302,11303,11304,11305,11306,11307,11308,11309,11310,11312,11313,11314,11315,11316,11317,11318,11319,11320,11321,11322,11323,11324,11325,11326,11327,11328,11329,11330,11331,11332,11333,11334,11335,11336,11337,11338,11339,11340,11341,11342,11343,11344,11345,11346,11347,11348,11349,11350,11351,11352,11353,11354,11355,11356,11357,11358,11360,11361,11362,11363,11364,11365,11366,11367,11368,11369,11370,11371,11372,11373,11374,11375,11376,11377,11378,11379,11380,11381,11382,11383,11384,11385,11386,11387,11388,11389,11390,11391,11392,11393,11394,11395,11396,11397,11398,11399,11400,11401,11402,11403,11404,11405,11406,11407,11408,11409,11410,11411,11412,11413,11414,11415,11416,11417,11418,11419,11420,11421,11422,11423,11424,11425,11426,11427,11428,11429,11430,11431,11432,11433,11434,11435,11436,11437,11438,11439,11440,11441,11442,11443,11444,11445,11446,11447,11448,11449,11450,11451,11452,11453,11454,11455,11456,11457,11458,11459,11460,11461,11462,11463,11464,11465,11466,11467,11468,11469,11470,11471,11472,11473,11474,11475,11476,11477,11478,11479,11480,11481,11482,11483,11484,11485,11486,11487,11488,11489,11490,11491,11492,11499,11500,11501,11502,11506,11507,11520,11521,11522,11523,11524,11525,11526,11527,11528,11529,11530,11531,11532,11533,11534,11535,11536,11537,11538,11539,11540,11541,11542,11543,11544,11545,11546,11547,11548,11549,11550,11551,11552,11553,11554,11555,11556,11557,11559,11565,11568,11569,11570,11571,11572,11573,11574,11575,11576,11577,11578,11579,11580,11581,11582,11583,11584,11585,11586,11587,11588,11589,11590,11591,11592,11593,11594,11595,11596,11597,11598,11599,11600,11601,11602,11603,11604,11605,11606,11607,11608,11609,11610,11611,11612,11613,11614,11615,11616,11617,11618,11619,11620,11621,11622,11623,11631,11648,11649,11650,11651,11652,11653,11654,11655,11656,11657,11658,11659,11660,11661,11662,11663,11664,11665,11666,11667,11668,11669,11670,11680,11681,11682,11683,11684,11685,11686,11688,11689,11690,11691,11692,11693,11694,11696,11697,11698,11699,11700,11701,11702,11704,11705,11706,11707,11708,11709,11710,11712,11713,11714,11715,11716,11717,11718,11720,11721,11722,11723,11724,11725,11726,11728,11729,11730,11731,11732,11733,11734,11736,11737,11738,11739,11740,11741,11742,11823,12293,12294,12295,12321,12322,12323,12324,12325,12326,12327,12328,12329,12337,12338,12339,12340,12341,12344,12345,12346,12347,12348,12353,12354,12355,12356,12357,12358,12359,12360,12361,12362,12363,12364,12365,12366,12367,12368,12369,12370,12371,12372,12373,12374,12375,12376,12377,12378,12379,12380,12381,12382,12383,12384,12385,12386,12387,12388,12389,12390,12391,12392,12393,12394,12395,12396,12397,12398,12399,12400,12401,12402,12403,12404,12405,12406,12407,12408,12409,12410,12411,12412,12413,12414,12415,12416,12417,12418,12419,12420,12421,12422,12423,12424,12425,12426,12427,12428,12429,12430,12431,12432,12433,12434,12435,12436,12437,12438,12445,12446,12447,12449,12450,12451,12452,12453,12454,12455,12456,12457,12458,12459,12460,12461,12462,12463,12464,12465,12466,12467,12468,12469,12470,12471,12472,12473,12474,12475,12476,12477,12478,12479,12480,12481,12482,12483,12484,12485,12486,12487,12488,12489,12490,12491,12492,12493,12494,12495,12496,12497,12498,12499,12500,12501,12502,12503,12504,12505,12506,12507,12508,12509,12510,12511,12512,12513,12514,12515,12516,12517,12518,12519,12520,12521,12522,12523,12524,12525,12526,12527,12528,12529,12530,12531,12532,12533,12534,12535,12536,12537,12538,12540,12541,12542,12543,12549,12550,12551,12552,12553,12554,12555,12556,12557,12558,12559,12560,12561,12562,12563,12564,12565,12566,12567,12568,12569,12570,12571,12572,12573,12574,12575,12576,12577,12578,12579,12580,12581,12582,12583,12584,12585,12586,12587,12588,12589,12593,12594,12595,12596,12597,12598,12599,12600,12601,12602,12603,12604,12605,12606,12607,12608,12609,12610,12611,12612,12613,12614,12615,12616,12617,12618,12619,12620,12621,12622,12623,12624,12625,12626,12627,12628,12629,12630,12631,12632,12633,12634,12635,12636,12637,12638,12639,12640,12641,12642,12643,12644,12645,12646,12647,12648,12649,12650,12651,12652,12653,12654,12655,12656,12657,12658,12659,12660,12661,12662,12663,12664,12665,12666,12667,12668,12669,12670,12671,12672,12673,12674,12675,12676,12677,12678,12679,12680,12681,12682,12683,12684,12685,12686,12704,12705,12706,12707,12708,12709,12710,12711,12712,12713,12714,12715,12716,12717,12718,12719,12720,12721,12722,12723,12724,12725,12726,12727,12728,12729,12730,12784,12785,12786,12787,12788,12789,12790,12791,12792,12793,12794,12795,12796,12797,12798,12799,13312,13313,13314,13315,13316,13317,13318,13319,13320,13321,13322,13323,13324,13325,13326,13327,13328,13329,13330,13331,13332,13333,13334,13335,13336,13337,13338,13339,13340,13341,13342,13343,13344,13345,13346,13347,13348,13349,13350,13351,13352,13353,13354,13355,13356,13357,13358,13359,13360,13361,13362,13363,13364,13365,13366,13367,13368,13369,13370,13371,13372,13373,13374,13375,13376,13377,13378,13379,13380,13381,13382,13383,13384,13385,13386,13387,13388,13389,13390,13391,13392,13393,13394,13395,13396,13397,13398,13399,13400,13401,13402,13403,13404,13405,13406,13407,13408,13409,13410,13411,13412,13413,13414,13415,13416,13417,13418,13419,13420,13421,13422,13423,13424,13425,13426,13427,13428,13429,13430,13431,13432,13433,13434,13435,13436,13437,13438,13439,13440,13441,13442,13443,13444,13445,13446,13447,13448,13449,13450,13451,13452,13453,13454,13455,13456,13457,13458,13459,13460,13461,13462,13463,13464,13465,13466,13467,13468,13469,13470,13471,13472,13473,13474,13475,13476,13477,13478,13479,13480,13481,13482,13483,13484,13485,13486,13487,13488,13489,13490,13491,13492,13493,13494,13495,13496,13497,13498,13499,13500,13501,13502,13503,13504,13505,13506,13507,13508,13509,13510,13511,13512,13513,13514,13515,13516,13517,13518,13519,13520,13521,13522,13523,13524,13525,13526,13527,13528,13529,13530,13531,13532,13533,13534,13535,13536,13537,13538,13539,13540,13541,13542,13543,13544,13545,13546,13547,13548,13549,13550,13551,13552,13553,13554,13555,13556,13557,13558,13559,13560,13561,13562,13563,13564,13565,13566,13567,13568,13569,13570,13571,13572,13573,13574,13575,13576,13577,13578,13579,13580,13581,13582,13583,13584,13585,13586,13587,13588,13589,13590,13591,13592,13593,13594,13595,13596,13597,13598,13599,13600,13601,13602,13603,13604,13605,13606,13607,13608,13609,13610,13611,13612,13613,13614,13615,13616,13617,13618,13619,13620,13621,13622,13623,13624,13625,13626,13627,13628,13629,13630,13631,13632,13633,13634,13635,13636,13637,13638,13639,13640,13641,13642,13643,13644,13645,13646,13647,13648,13649,13650,13651,13652,13653,13654,13655,13656,13657,13658,13659,13660,13661,13662,13663,13664,13665,13666,13667,13668,13669,13670,13671,13672,13673,13674,13675,13676,13677,13678,13679,13680,13681,13682,13683,13684,13685,13686,13687,13688,13689,13690,13691,13692,13693,13694,13695,13696,13697,13698,13699,13700,13701,13702,13703,13704,13705,13706,13707,13708,13709,13710,13711,13712,13713,13714,13715,13716,13717,13718,13719,13720,13721,13722,13723,13724,13725,13726,13727,13728,13729,13730,13731,13732,13733,13734,13735,13736,13737,13738,13739,13740,13741,13742,13743,13744,13745,13746,13747,13748,13749,13750,13751,13752,13753,13754,13755,13756,13757,13758,13759,13760,13761,13762,13763,13764,13765,13766,13767,13768,13769,13770,13771,13772,13773,13774,13775,13776,13777,13778,13779,13780,13781,13782,13783,13784,13785,13786,13787,13788,13789,13790,13791,13792,13793,13794,13795,13796,13797,13798,13799,13800,13801,13802,13803,13804,13805,13806,13807,13808,13809,13810,13811,13812,13813,13814,13815,13816,13817,13818,13819,13820,13821,13822,13823,13824,13825,13826,13827,13828,13829,13830,13831,13832,13833,13834,13835,13836,13837,13838,13839,13840,13841,13842,13843,13844,13845,13846,13847,13848,13849,13850,13851,13852,13853,13854,13855,13856,13857,13858,13859,13860,13861,13862,13863,13864,13865,13866,13867,13868,13869,13870,13871,13872,13873,13874,13875,13876,13877,13878,13879,13880,13881,13882,13883,13884,13885,13886,13887,13888,13889,13890,13891,13892,13893,13894,13895,13896,13897,13898,13899,13900,13901,13902,13903,13904,13905,13906,13907,13908,13909,13910,13911,13912,13913,13914,13915,13916,13917,13918,13919,13920,13921,13922,13923,13924,13925,13926,13927,13928,13929,13930,13931,13932,13933,13934,13935,13936,13937,13938,13939,13940,13941,13942,13943,13944,13945,13946,13947,13948,13949,13950,13951,13952,13953,13954,13955,13956,13957,13958,13959,13960,13961,13962,13963,13964,13965,13966,13967,13968,13969,13970,13971,13972,13973,13974,13975,13976,13977,13978,13979,13980,13981,13982,13983,13984,13985,13986,13987,13988,13989,13990,13991,13992,13993,13994,13995,13996,13997,13998,13999,14000,14001,14002,14003,14004,14005,14006,14007,14008,14009,14010,14011,14012,14013,14014,14015,14016,14017,14018,14019,14020,14021,14022,14023,14024,14025,14026,14027,14028,14029,14030,14031,14032,14033,14034,14035,14036,14037,14038,14039,14040,14041,14042,14043,14044,14045,14046,14047,14048,14049,14050,14051,14052,14053,14054,14055,14056,14057,14058,14059,14060,14061,14062,14063,14064,14065,14066,14067,14068,14069,14070,14071,14072,14073,14074,14075,14076,14077,14078,14079,14080,14081,14082,14083,14084,14085,14086,14087,14088,14089,14090,14091,14092,14093,14094,14095,14096,14097,14098,14099,14100,14101,14102,14103,14104,14105,14106,14107,14108,14109,14110,14111,14112,14113,14114,14115,14116,14117,14118,14119,14120,14121,14122,14123,14124,14125,14126,14127,14128,14129,14130,14131,14132,14133,14134,14135,14136,14137,14138,14139,14140,14141,14142,14143,14144,14145,14146,14147,14148,14149,14150,14151,14152,14153,14154,14155,14156,14157,14158,14159,14160,14161,14162,14163,14164,14165,14166,14167,14168,14169,14170,14171,14172,14173,14174,14175,14176,14177,14178,14179,14180,14181,14182,14183,14184,14185,14186,14187,14188,14189,14190,14191,14192,14193,14194,14195,14196,14197,14198,14199,14200,14201,14202,14203,14204,14205,14206,14207,14208,14209,14210,14211,14212,14213,14214,14215,14216,14217,14218,14219,14220,14221,14222,14223,14224,14225,14226,14227,14228,14229,14230,14231,14232,14233,14234,14235,14236,14237,14238,14239,14240,14241,14242,14243,14244,14245,14246,14247,14248,14249,14250,14251,14252,14253,14254,14255,14256,14257,14258,14259,14260,14261,14262,14263,14264,14265,14266,14267,14268,14269,14270,14271,14272,14273,14274,14275,14276,14277,14278,14279,14280,14281,14282,14283,14284,14285,14286,14287,14288,14289,14290,14291,14292,14293,14294,14295,14296,14297,14298,14299,14300,14301,14302,14303,14304,14305,14306,14307,14308,14309,14310,14311,14312,14313,14314,14315,14316,14317,14318,14319,14320,14321,14322,14323,14324,14325,14326,14327,14328,14329,14330,14331,14332,14333,14334,14335,14336,14337,14338,14339,14340,14341,14342,14343,14344,14345,14346,14347,14348,14349,14350,14351,14352,14353,14354,14355,14356,14357,14358,14359,14360,14361,14362,14363,14364,14365,14366,14367,14368,14369,14370,14371,14372,14373,14374,14375,14376,14377,14378,14379,14380,14381,14382,14383,14384,14385,14386,14387,14388,14389,14390,14391,14392,14393,14394,14395,14396,14397,14398,14399,14400,14401,14402,14403,14404,14405,14406,14407,14408,14409,14410,14411,14412,14413,14414,14415,14416,14417,14418,14419,14420,14421,14422,14423,14424,14425,14426,14427,14428,14429,14430,14431,14432,14433,14434,14435,14436,14437,14438,14439,14440,14441,14442,14443,14444,14445,14446,14447,14448,14449,14450,14451,14452,14453,14454,14455,14456,14457,14458,14459,14460,14461,14462,14463,14464,14465,14466,14467,14468,14469,14470,14471,14472,14473,14474,14475,14476,14477,14478,14479,14480,14481,14482,14483,14484,14485,14486,14487,14488,14489,14490,14491,14492,14493,14494,14495,14496,14497,14498,14499,14500,14501,14502,14503,14504,14505,14506,14507,14508,14509,14510,14511,14512,14513,14514,14515,14516,14517,14518,14519,14520,14521,14522,14523,14524,14525,14526,14527,14528,14529,14530,14531,14532,14533,14534,14535,14536,14537,14538,14539,14540,14541,14542,14543,14544,14545,14546,14547,14548,14549,14550,14551,14552,14553,14554,14555,14556,14557,14558,14559,14560,14561,14562,14563,14564,14565,14566,14567,14568,14569,14570,14571,14572,14573,14574,14575,14576,14577,14578,14579,14580,14581,14582,14583,14584,14585,14586,14587,14588,14589,14590,14591,14592,14593,14594,14595,14596,14597,14598,14599,14600,14601,14602,14603,14604,14605,14606,14607,14608,14609,14610,14611,14612,14613,14614,14615,14616,14617,14618,14619,14620,14621,14622,14623,14624,14625,14626,14627,14628,14629,14630,14631,14632,14633,14634,14635,14636,14637,14638,14639,14640,14641,14642,14643,14644,14645,14646,14647,14648,14649,14650,14651,14652,14653,14654,14655,14656,14657,14658,14659,14660,14661,14662,14663,14664,14665,14666,14667,14668,14669,14670,14671,14672,14673,14674,14675,14676,14677,14678,14679,14680,14681,14682,14683,14684,14685,14686,14687,14688,14689,14690,14691,14692,14693,14694,14695,14696,14697,14698,14699,14700,14701,14702,14703,14704,14705,14706,14707,14708,14709,14710,14711,14712,14713,14714,14715,14716,14717,14718,14719,14720,14721,14722,14723,14724,14725,14726,14727,14728,14729,14730,14731,14732,14733,14734,14735,14736,14737,14738,14739,14740,14741,14742,14743,14744,14745,14746,14747,14748,14749,14750,14751,14752,14753,14754,14755,14756,14757,14758,14759,14760,14761,14762,14763,14764,14765,14766,14767,14768,14769,14770,14771,14772,14773,14774,14775,14776,14777,14778,14779,14780,14781,14782,14783,14784,14785,14786,14787,14788,14789,14790,14791,14792,14793,14794,14795,14796,14797,14798,14799,14800,14801,14802,14803,14804,14805,14806,14807,14808,14809,14810,14811,14812,14813,14814,14815,14816,14817,14818,14819,14820,14821,14822,14823,14824,14825,14826,14827,14828,14829,14830,14831,14832,14833,14834,14835,14836,14837,14838,14839,14840,14841,14842,14843,14844,14845,14846,14847,14848,14849,14850,14851,14852,14853,14854,14855,14856,14857,14858,14859,14860,14861,14862,14863,14864,14865,14866,14867,14868,14869,14870,14871,14872,14873,14874,14875,14876,14877,14878,14879,14880,14881,14882,14883,14884,14885,14886,14887,14888,14889,14890,14891,14892,14893,14894,14895,14896,14897,14898,14899,14900,14901,14902,14903,14904,14905,14906,14907,14908,14909,14910,14911,14912,14913,14914,14915,14916,14917,14918,14919,14920,14921,14922,14923,14924,14925,14926,14927,14928,14929,14930,14931,14932,14933,14934,14935,14936,14937,14938,14939,14940,14941,14942,14943,14944,14945,14946,14947,14948,14949,14950,14951,14952,14953,14954,14955,14956,14957,14958,14959,14960,14961,14962,14963,14964,14965,14966,14967,14968,14969,14970,14971,14972,14973,14974,14975,14976,14977,14978,14979,14980,14981,14982,14983,14984,14985,14986,14987,14988,14989,14990,14991,14992,14993,14994,14995,14996,14997,14998,14999,15000,15001,15002,15003,15004,15005,15006,15007,15008,15009,15010,15011,15012,15013,15014,15015,15016,15017,15018,15019,15020,15021,15022,15023,15024,15025,15026,15027,15028,15029,15030,15031,15032,15033,15034,15035,15036,15037,15038,15039,15040,15041,15042,15043,15044,15045,15046,15047,15048,15049,15050,15051,15052,15053,15054,15055,15056,15057,15058,15059,15060,15061,15062,15063,15064,15065,15066,15067,15068,15069,15070,15071,15072,15073,15074,15075,15076,15077,15078,15079,15080,15081,15082,15083,15084,15085,15086,15087,15088,15089,15090,15091,15092,15093,15094,15095,15096,15097,15098,15099,15100,15101,15102,15103,15104,15105,15106,15107,15108,15109,15110,15111,15112,15113,15114,15115,15116,15117,15118,15119,15120,15121,15122,15123,15124,15125,15126,15127,15128,15129,15130,15131,15132,15133,15134,15135,15136,15137,15138,15139,15140,15141,15142,15143,15144,15145,15146,15147,15148,15149,15150,15151,15152,15153,15154,15155,15156,15157,15158,15159,15160,15161,15162,15163,15164,15165,15166,15167,15168,15169,15170,15171,15172,15173,15174,15175,15176,15177,15178,15179,15180,15181,15182,15183,15184,15185,15186,15187,15188,15189,15190,15191,15192,15193,15194,15195,15196,15197,15198,15199,15200,15201,15202,15203,15204,15205,15206,15207,15208,15209,15210,15211,15212,15213,15214,15215,15216,15217,15218,15219,15220,15221,15222,15223,15224,15225,15226,15227,15228,15229,15230,15231,15232,15233,15234,15235,15236,15237,15238,15239,15240,15241,15242,15243,15244,15245,15246,15247,15248,15249,15250,15251,15252,15253,15254,15255,15256,15257,15258,15259,15260,15261,15262,15263,15264,15265,15266,15267,15268,15269,15270,15271,15272,15273,15274,15275,15276,15277,15278,15279,15280,15281,15282,15283,15284,15285,15286,15287,15288,15289,15290,15291,15292,15293,15294,15295,15296,15297,15298,15299,15300,15301,15302,15303,15304,15305,15306,15307,15308,15309,15310,15311,15312,15313,15314,15315,15316,15317,15318,15319,15320,15321,15322,15323,15324,15325,15326,15327,15328,15329,15330,15331,15332,15333,15334,15335,15336,15337,15338,15339,15340,15341,15342,15343,15344,15345,15346,15347,15348,15349,15350,15351,15352,15353,15354,15355,15356,15357,15358,15359,15360,15361,15362,15363,15364,15365,15366,15367,15368,15369,15370,15371,15372,15373,15374,15375,15376,15377,15378,15379,15380,15381,15382,15383,15384,15385,15386,15387,15388,15389,15390,15391,15392,15393,15394,15395,15396,15397,15398,15399,15400,15401,15402,15403,15404,15405,15406,15407,15408,15409,15410,15411,15412,15413,15414,15415,15416,15417,15418,15419,15420,15421,15422,15423,15424,15425,15426,15427,15428,15429,15430,15431,15432,15433,15434,15435,15436,15437,15438,15439,15440,15441,15442,15443,15444,15445,15446,15447,15448,15449,15450,15451,15452,15453,15454,15455,15456,15457,15458,15459,15460,15461,15462,15463,15464,15465,15466,15467,15468,15469,15470,15471,15472,15473,15474,15475,15476,15477,15478,15479,15480,15481,15482,15483,15484,15485,15486,15487,15488,15489,15490,15491,15492,15493,15494,15495,15496,15497,15498,15499,15500,15501,15502,15503,15504,15505,15506,15507,15508,15509,15510,15511,15512,15513,15514,15515,15516,15517,15518,15519,15520,15521,15522,15523,15524,15525,15526,15527,15528,15529,15530,15531,15532,15533,15534,15535,15536,15537,15538,15539,15540,15541,15542,15543,15544,15545,15546,15547,15548,15549,15550,15551,15552,15553,15554,15555,15556,15557,15558,15559,15560,15561,15562,15563,15564,15565,15566,15567,15568,15569,15570,15571,15572,15573,15574,15575,15576,15577,15578,15579,15580,15581,15582,15583,15584,15585,15586,15587,15588,15589,15590,15591,15592,15593,15594,15595,15596,15597,15598,15599,15600,15601,15602,15603,15604,15605,15606,15607,15608,15609,15610,15611,15612,15613,15614,15615,15616,15617,15618,15619,15620,15621,15622,15623,15624,15625,15626,15627,15628,15629,15630,15631,15632,15633,15634,15635,15636,15637,15638,15639,15640,15641,15642,15643,15644,15645,15646,15647,15648,15649,15650,15651,15652,15653,15654,15655,15656,15657,15658,15659,15660,15661,15662,15663,15664,15665,15666,15667,15668,15669,15670,15671,15672,15673,15674,15675,15676,15677,15678,15679,15680,15681,15682,15683,15684,15685,15686,15687,15688,15689,15690,15691,15692,15693,15694,15695,15696,15697,15698,15699,15700,15701,15702,15703,15704,15705,15706,15707,15708,15709,15710,15711,15712,15713,15714,15715,15716,15717,15718,15719,15720,15721,15722,15723,15724,15725,15726,15727,15728,15729,15730,15731,15732,15733,15734,15735,15736,15737,15738,15739,15740,15741,15742,15743,15744,15745,15746,15747,15748,15749,15750,15751,15752,15753,15754,15755,15756,15757,15758,15759,15760,15761,15762,15763,15764,15765,15766,15767,15768,15769,15770,15771,15772,15773,15774,15775,15776,15777,15778,15779,15780,15781,15782,15783,15784,15785,15786,15787,15788,15789,15790,15791,15792,15793,15794,15795,15796,15797,15798,15799,15800,15801,15802,15803,15804,15805,15806,15807,15808,15809,15810,15811,15812,15813,15814,15815,15816,15817,15818,15819,15820,15821,15822,15823,15824,15825,15826,15827,15828,15829,15830,15831,15832,15833,15834,15835,15836,15837,15838,15839,15840,15841,15842,15843,15844,15845,15846,15847,15848,15849,15850,15851,15852,15853,15854,15855,15856,15857,15858,15859,15860,15861,15862,15863,15864,15865,15866,15867,15868,15869,15870,15871,15872,15873,15874,15875,15876,15877,15878,15879,15880,15881,15882,15883,15884,15885,15886,15887,15888,15889,15890,15891,15892,15893,15894,15895,15896,15897,15898,15899,15900,15901,15902,15903,15904,15905,15906,15907,15908,15909,15910,15911,15912,15913,15914,15915,15916,15917,15918,15919,15920,15921,15922,15923,15924,15925,15926,15927,15928,15929,15930,15931,15932,15933,15934,15935,15936,15937,15938,15939,15940,15941,15942,15943,15944,15945,15946,15947,15948,15949,15950,15951,15952,15953,15954,15955,15956,15957,15958,15959,15960,15961,15962,15963,15964,15965,15966,15967,15968,15969,15970,15971,15972,15973,15974,15975,15976,15977,15978,15979,15980,15981,15982,15983,15984,15985,15986,15987,15988,15989,15990,15991,15992,15993,15994,15995,15996,15997,15998,15999,16000,16001,16002,16003,16004,16005,16006,16007,16008,16009,16010,16011,16012,16013,16014,16015,16016,16017,16018,16019,16020,16021,16022,16023,16024,16025,16026,16027,16028,16029,16030,16031,16032,16033,16034,16035,16036,16037,16038,16039,16040,16041,16042,16043,16044,16045,16046,16047,16048,16049,16050,16051,16052,16053,16054,16055,16056,16057,16058,16059,16060,16061,16062,16063,16064,16065,16066,16067,16068,16069,16070,16071,16072,16073,16074,16075,16076,16077,16078,16079,16080,16081,16082,16083,16084,16085,16086,16087,16088,16089,16090,16091,16092,16093,16094,16095,16096,16097,16098,16099,16100,16101,16102,16103,16104,16105,16106,16107,16108,16109,16110,16111,16112,16113,16114,16115,16116,16117,16118,16119,16120,16121,16122,16123,16124,16125,16126,16127,16128,16129,16130,16131,16132,16133,16134,16135,16136,16137,16138,16139,16140,16141,16142,16143,16144,16145,16146,16147,16148,16149,16150,16151,16152,16153,16154,16155,16156,16157,16158,16159,16160,16161,16162,16163,16164,16165,16166,16167,16168,16169,16170,16171,16172,16173,16174,16175,16176,16177,16178,16179,16180,16181,16182,16183,16184,16185,16186,16187,16188,16189,16190,16191,16192,16193,16194,16195,16196,16197,16198,16199,16200,16201,16202,16203,16204,16205,16206,16207,16208,16209,16210,16211,16212,16213,16214,16215,16216,16217,16218,16219,16220,16221,16222,16223,16224,16225,16226,16227,16228,16229,16230,16231,16232,16233,16234,16235,16236,16237,16238,16239,16240,16241,16242,16243,16244,16245,16246,16247,16248,16249,16250,16251,16252,16253,16254,16255,16256,16257,16258,16259,16260,16261,16262,16263,16264,16265,16266,16267,16268,16269,16270,16271,16272,16273,16274,16275,16276,16277,16278,16279,16280,16281,16282,16283,16284,16285,16286,16287,16288,16289,16290,16291,16292,16293,16294,16295,16296,16297,16298,16299,16300,16301,16302,16303,16304,16305,16306,16307,16308,16309,16310,16311,16312,16313,16314,16315,16316,16317,16318,16319,16320,16321,16322,16323,16324,16325,16326,16327,16328,16329,16330,16331,16332,16333,16334,16335,16336,16337,16338,16339,16340,16341,16342,16343,16344,16345,16346,16347,16348,16349,16350,16351,16352,16353,16354,16355,16356,16357,16358,16359,16360,16361,16362,16363,16364,16365,16366,16367,16368,16369,16370,16371,16372,16373,16374,16375,16376,16377,16378,16379,16380,16381,16382,16383,16384,16385,16386,16387,16388,16389,16390,16391,16392,16393,16394,16395,16396,16397,16398,16399,16400,16401,16402,16403,16404,16405,16406,16407,16408,16409,16410,16411,16412,16413,16414,16415,16416,16417,16418,16419,16420,16421,16422,16423,16424,16425,16426,16427,16428,16429,16430,16431,16432,16433,16434,16435,16436,16437,16438,16439,16440,16441,16442,16443,16444,16445,16446,16447,16448,16449,16450,16451,16452,16453,16454,16455,16456,16457,16458,16459,16460,16461,16462,16463,16464,16465,16466,16467,16468,16469,16470,16471,16472,16473,16474,16475,16476,16477,16478,16479,16480,16481,16482,16483,16484,16485,16486,16487,16488,16489,16490,16491,16492,16493,16494,16495,16496,16497,16498,16499,16500,16501,16502,16503,16504,16505,16506,16507,16508,16509,16510,16511,16512,16513,16514,16515,16516,16517,16518,16519,16520,16521,16522,16523,16524,16525,16526,16527,16528,16529,16530,16531,16532,16533,16534,16535,16536,16537,16538,16539,16540,16541,16542,16543,16544,16545,16546,16547,16548,16549,16550,16551,16552,16553,16554,16555,16556,16557,16558,16559,16560,16561,16562,16563,16564,16565,16566,16567,16568,16569,16570,16571,16572,16573,16574,16575,16576,16577,16578,16579,16580,16581,16582,16583,16584,16585,16586,16587,16588,16589,16590,16591,16592,16593,16594,16595,16596,16597,16598,16599,16600,16601,16602,16603,16604,16605,16606,16607,16608,16609,16610,16611,16612,16613,16614,16615,16616,16617,16618,16619,16620,16621,16622,16623,16624,16625,16626,16627,16628,16629,16630,16631,16632,16633,16634,16635,16636,16637,16638,16639,16640,16641,16642,16643,16644,16645,16646,16647,16648,16649,16650,16651,16652,16653,16654,16655,16656,16657,16658,16659,16660,16661,16662,16663,16664,16665,16666,16667,16668,16669,16670,16671,16672,16673,16674,16675,16676,16677,16678,16679,16680,16681,16682,16683,16684,16685,16686,16687,16688,16689,16690,16691,16692,16693,16694,16695,16696,16697,16698,16699,16700,16701,16702,16703,16704,16705,16706,16707,16708,16709,16710,16711,16712,16713,16714,16715,16716,16717,16718,16719,16720,16721,16722,16723,16724,16725,16726,16727,16728,16729,16730,16731,16732,16733,16734,16735,16736,16737,16738,16739,16740,16741,16742,16743,16744,16745,16746,16747,16748,16749,16750,16751,16752,16753,16754,16755,16756,16757,16758,16759,16760,16761,16762,16763,16764,16765,16766,16767,16768,16769,16770,16771,16772,16773,16774,16775,16776,16777,16778,16779,16780,16781,16782,16783,16784,16785,16786,16787,16788,16789,16790,16791,16792,16793,16794,16795,16796,16797,16798,16799,16800,16801,16802,16803,16804,16805,16806,16807,16808,16809,16810,16811,16812,16813,16814,16815,16816,16817,16818,16819,16820,16821,16822,16823,16824,16825,16826,16827,16828,16829,16830,16831,16832,16833,16834,16835,16836,16837,16838,16839,16840,16841,16842,16843,16844,16845,16846,16847,16848,16849,16850,16851,16852,16853,16854,16855,16856,16857,16858,16859,16860,16861,16862,16863,16864,16865,16866,16867,16868,16869,16870,16871,16872,16873,16874,16875,16876,16877,16878,16879,16880,16881,16882,16883,16884,16885,16886,16887,16888,16889,16890,16891,16892,16893,16894,16895,16896,16897,16898,16899,16900,16901,16902,16903,16904,16905,16906,16907,16908,16909,16910,16911,16912,16913,16914,16915,16916,16917,16918,16919,16920,16921,16922,16923,16924,16925,16926,16927,16928,16929,16930,16931,16932,16933,16934,16935,16936,16937,16938,16939,16940,16941,16942,16943,16944,16945,16946,16947,16948,16949,16950,16951,16952,16953,16954,16955,16956,16957,16958,16959,16960,16961,16962,16963,16964,16965,16966,16967,16968,16969,16970,16971,16972,16973,16974,16975,16976,16977,16978,16979,16980,16981,16982,16983,16984,16985,16986,16987,16988,16989,16990,16991,16992,16993,16994,16995,16996,16997,16998,16999,17000,17001,17002,17003,17004,17005,17006,17007,17008,17009,17010,17011,17012,17013,17014,17015,17016,17017,17018,17019,17020,17021,17022,17023,17024,17025,17026,17027,17028,17029,17030,17031,17032,17033,17034,17035,17036,17037,17038,17039,17040,17041,17042,17043,17044,17045,17046,17047,17048,17049,17050,17051,17052,17053,17054,17055,17056,17057,17058,17059,17060,17061,17062,17063,17064,17065,17066,17067,17068,17069,17070,17071,17072,17073,17074,17075,17076,17077,17078,17079,17080,17081,17082,17083,17084,17085,17086,17087,17088,17089,17090,17091,17092,17093,17094,17095,17096,17097,17098,17099,17100,17101,17102,17103,17104,17105,17106,17107,17108,17109,17110,17111,17112,17113,17114,17115,17116,17117,17118,17119,17120,17121,17122,17123,17124,17125,17126,17127,17128,17129,17130,17131,17132,17133,17134,17135,17136,17137,17138,17139,17140,17141,17142,17143,17144,17145,17146,17147,17148,17149,17150,17151,17152,17153,17154,17155,17156,17157,17158,17159,17160,17161,17162,17163,17164,17165,17166,17167,17168,17169,17170,17171,17172,17173,17174,17175,17176,17177,17178,17179,17180,17181,17182,17183,17184,17185,17186,17187,17188,17189,17190,17191,17192,17193,17194,17195,17196,17197,17198,17199,17200,17201,17202,17203,17204,17205,17206,17207,17208,17209,17210,17211,17212,17213,17214,17215,17216,17217,17218,17219,17220,17221,17222,17223,17224,17225,17226,17227,17228,17229,17230,17231,17232,17233,17234,17235,17236,17237,17238,17239,17240,17241,17242,17243,17244,17245,17246,17247,17248,17249,17250,17251,17252,17253,17254,17255,17256,17257,17258,17259,17260,17261,17262,17263,17264,17265,17266,17267,17268,17269,17270,17271,17272,17273,17274,17275,17276,17277,17278,17279,17280,17281,17282,17283,17284,17285,17286,17287,17288,17289,17290,17291,17292,17293,17294,17295,17296,17297,17298,17299,17300,17301,17302,17303,17304,17305,17306,17307,17308,17309,17310,17311,17312,17313,17314,17315,17316,17317,17318,17319,17320,17321,17322,17323,17324,17325,17326,17327,17328,17329,17330,17331,17332,17333,17334,17335,17336,17337,17338,17339,17340,17341,17342,17343,17344,17345,17346,17347,17348,17349,17350,17351,17352,17353,17354,17355,17356,17357,17358,17359,17360,17361,17362,17363,17364,17365,17366,17367,17368,17369,17370,17371,17372,17373,17374,17375,17376,17377,17378,17379,17380,17381,17382,17383,17384,17385,17386,17387,17388,17389,17390,17391,17392,17393,17394,17395,17396,17397,17398,17399,17400,17401,17402,17403,17404,17405,17406,17407,17408,17409,17410,17411,17412,17413,17414,17415,17416,17417,17418,17419,17420,17421,17422,17423,17424,17425,17426,17427,17428,17429,17430,17431,17432,17433,17434,17435,17436,17437,17438,17439,17440,17441,17442,17443,17444,17445,17446,17447,17448,17449,17450,17451,17452,17453,17454,17455,17456,17457,17458,17459,17460,17461,17462,17463,17464,17465,17466,17467,17468,17469,17470,17471,17472,17473,17474,17475,17476,17477,17478,17479,17480,17481,17482,17483,17484,17485,17486,17487,17488,17489,17490,17491,17492,17493,17494,17495,17496,17497,17498,17499,17500,17501,17502,17503,17504,17505,17506,17507,17508,17509,17510,17511,17512,17513,17514,17515,17516,17517,17518,17519,17520,17521,17522,17523,17524,17525,17526,17527,17528,17529,17530,17531,17532,17533,17534,17535,17536,17537,17538,17539,17540,17541,17542,17543,17544,17545,17546,17547,17548,17549,17550,17551,17552,17553,17554,17555,17556,17557,17558,17559,17560,17561,17562,17563,17564,17565,17566,17567,17568,17569,17570,17571,17572,17573,17574,17575,17576,17577,17578,17579,17580,17581,17582,17583,17584,17585,17586,17587,17588,17589,17590,17591,17592,17593,17594,17595,17596,17597,17598,17599,17600,17601,17602,17603,17604,17605,17606,17607,17608,17609,17610,17611,17612,17613,17614,17615,17616,17617,17618,17619,17620,17621,17622,17623,17624,17625,17626,17627,17628,17629,17630,17631,17632,17633,17634,17635,17636,17637,17638,17639,17640,17641,17642,17643,17644,17645,17646,17647,17648,17649,17650,17651,17652,17653,17654,17655,17656,17657,17658,17659,17660,17661,17662,17663,17664,17665,17666,17667,17668,17669,17670,17671,17672,17673,17674,17675,17676,17677,17678,17679,17680,17681,17682,17683,17684,17685,17686,17687,17688,17689,17690,17691,17692,17693,17694,17695,17696,17697,17698,17699,17700,17701,17702,17703,17704,17705,17706,17707,17708,17709,17710,17711,17712,17713,17714,17715,17716,17717,17718,17719,17720,17721,17722,17723,17724,17725,17726,17727,17728,17729,17730,17731,17732,17733,17734,17735,17736,17737,17738,17739,17740,17741,17742,17743,17744,17745,17746,17747,17748,17749,17750,17751,17752,17753,17754,17755,17756,17757,17758,17759,17760,17761,17762,17763,17764,17765,17766,17767,17768,17769,17770,17771,17772,17773,17774,17775,17776,17777,17778,17779,17780,17781,17782,17783,17784,17785,17786,17787,17788,17789,17790,17791,17792,17793,17794,17795,17796,17797,17798,17799,17800,17801,17802,17803,17804,17805,17806,17807,17808,17809,17810,17811,17812,17813,17814,17815,17816,17817,17818,17819,17820,17821,17822,17823,17824,17825,17826,17827,17828,17829,17830,17831,17832,17833,17834,17835,17836,17837,17838,17839,17840,17841,17842,17843,17844,17845,17846,17847,17848,17849,17850,17851,17852,17853,17854,17855,17856,17857,17858,17859,17860,17861,17862,17863,17864,17865,17866,17867,17868,17869,17870,17871,17872,17873,17874,17875,17876,17877,17878,17879,17880,17881,17882,17883,17884,17885,17886,17887,17888,17889,17890,17891,17892,17893,17894,17895,17896,17897,17898,17899,17900,17901,17902,17903,17904,17905,17906,17907,17908,17909,17910,17911,17912,17913,17914,17915,17916,17917,17918,17919,17920,17921,17922,17923,17924,17925,17926,17927,17928,17929,17930,17931,17932,17933,17934,17935,17936,17937,17938,17939,17940,17941,17942,17943,17944,17945,17946,17947,17948,17949,17950,17951,17952,17953,17954,17955,17956,17957,17958,17959,17960,17961,17962,17963,17964,17965,17966,17967,17968,17969,17970,17971,17972,17973,17974,17975,17976,17977,17978,17979,17980,17981,17982,17983,17984,17985,17986,17987,17988,17989,17990,17991,17992,17993,17994,17995,17996,17997,17998,17999,18000,18001,18002,18003,18004,18005,18006,18007,18008,18009,18010,18011,18012,18013,18014,18015,18016,18017,18018,18019,18020,18021,18022,18023,18024,18025,18026,18027,18028,18029,18030,18031,18032,18033,18034,18035,18036,18037,18038,18039,18040,18041,18042,18043,18044,18045,18046,18047,18048,18049,18050,18051,18052,18053,18054,18055,18056,18057,18058,18059,18060,18061,18062,18063,18064,18065,18066,18067,18068,18069,18070,18071,18072,18073,18074,18075,18076,18077,18078,18079,18080,18081,18082,18083,18084,18085,18086,18087,18088,18089,18090,18091,18092,18093,18094,18095,18096,18097,18098,18099,18100,18101,18102,18103,18104,18105,18106,18107,18108,18109,18110,18111,18112,18113,18114,18115,18116,18117,18118,18119,18120,18121,18122,18123,18124,18125,18126,18127,18128,18129,18130,18131,18132,18133,18134,18135,18136,18137,18138,18139,18140,18141,18142,18143,18144,18145,18146,18147,18148,18149,18150,18151,18152,18153,18154,18155,18156,18157,18158,18159,18160,18161,18162,18163,18164,18165,18166,18167,18168,18169,18170,18171,18172,18173,18174,18175,18176,18177,18178,18179,18180,18181,18182,18183,18184,18185,18186,18187,18188,18189,18190,18191,18192,18193,18194,18195,18196,18197,18198,18199,18200,18201,18202,18203,18204,18205,18206,18207,18208,18209,18210,18211,18212,18213,18214,18215,18216,18217,18218,18219,18220,18221,18222,18223,18224,18225,18226,18227,18228,18229,18230,18231,18232,18233,18234,18235,18236,18237,18238,18239,18240,18241,18242,18243,18244,18245,18246,18247,18248,18249,18250,18251,18252,18253,18254,18255,18256,18257,18258,18259,18260,18261,18262,18263,18264,18265,18266,18267,18268,18269,18270,18271,18272,18273,18274,18275,18276,18277,18278,18279,18280,18281,18282,18283,18284,18285,18286,18287,18288,18289,18290,18291,18292,18293,18294,18295,18296,18297,18298,18299,18300,18301,18302,18303,18304,18305,18306,18307,18308,18309,18310,18311,18312,18313,18314,18315,18316,18317,18318,18319,18320,18321,18322,18323,18324,18325,18326,18327,18328,18329,18330,18331,18332,18333,18334,18335,18336,18337,18338,18339,18340,18341,18342,18343,18344,18345,18346,18347,18348,18349,18350,18351,18352,18353,18354,18355,18356,18357,18358,18359,18360,18361,18362,18363,18364,18365,18366,18367,18368,18369,18370,18371,18372,18373,18374,18375,18376,18377,18378,18379,18380,18381,18382,18383,18384,18385,18386,18387,18388,18389,18390,18391,18392,18393,18394,18395,18396,18397,18398,18399,18400,18401,18402,18403,18404,18405,18406,18407,18408,18409,18410,18411,18412,18413,18414,18415,18416,18417,18418,18419,18420,18421,18422,18423,18424,18425,18426,18427,18428,18429,18430,18431,18432,18433,18434,18435,18436,18437,18438,18439,18440,18441,18442,18443,18444,18445,18446,18447,18448,18449,18450,18451,18452,18453,18454,18455,18456,18457,18458,18459,18460,18461,18462,18463,18464,18465,18466,18467,18468,18469,18470,18471,18472,18473,18474,18475,18476,18477,18478,18479,18480,18481,18482,18483,18484,18485,18486,18487,18488,18489,18490,18491,18492,18493,18494,18495,18496,18497,18498,18499,18500,18501,18502,18503,18504,18505,18506,18507,18508,18509,18510,18511,18512,18513,18514,18515,18516,18517,18518,18519,18520,18521,18522,18523,18524,18525,18526,18527,18528,18529,18530,18531,18532,18533,18534,18535,18536,18537,18538,18539,18540,18541,18542,18543,18544,18545,18546,18547,18548,18549,18550,18551,18552,18553,18554,18555,18556,18557,18558,18559,18560,18561,18562,18563,18564,18565,18566,18567,18568,18569,18570,18571,18572,18573,18574,18575,18576,18577,18578,18579,18580,18581,18582,18583,18584,18585,18586,18587,18588,18589,18590,18591,18592,18593,18594,18595,18596,18597,18598,18599,18600,18601,18602,18603,18604,18605,18606,18607,18608,18609,18610,18611,18612,18613,18614,18615,18616,18617,18618,18619,18620,18621,18622,18623,18624,18625,18626,18627,18628,18629,18630,18631,18632,18633,18634,18635,18636,18637,18638,18639,18640,18641,18642,18643,18644,18645,18646,18647,18648,18649,18650,18651,18652,18653,18654,18655,18656,18657,18658,18659,18660,18661,18662,18663,18664,18665,18666,18667,18668,18669,18670,18671,18672,18673,18674,18675,18676,18677,18678,18679,18680,18681,18682,18683,18684,18685,18686,18687,18688,18689,18690,18691,18692,18693,18694,18695,18696,18697,18698,18699,18700,18701,18702,18703,18704,18705,18706,18707,18708,18709,18710,18711,18712,18713,18714,18715,18716,18717,18718,18719,18720,18721,18722,18723,18724,18725,18726,18727,18728,18729,18730,18731,18732,18733,18734,18735,18736,18737,18738,18739,18740,18741,18742,18743,18744,18745,18746,18747,18748,18749,18750,18751,18752,18753,18754,18755,18756,18757,18758,18759,18760,18761,18762,18763,18764,18765,18766,18767,18768,18769,18770,18771,18772,18773,18774,18775,18776,18777,18778,18779,18780,18781,18782,18783,18784,18785,18786,18787,18788,18789,18790,18791,18792,18793,18794,18795,18796,18797,18798,18799,18800,18801,18802,18803,18804,18805,18806,18807,18808,18809,18810,18811,18812,18813,18814,18815,18816,18817,18818,18819,18820,18821,18822,18823,18824,18825,18826,18827,18828,18829,18830,18831,18832,18833,18834,18835,18836,18837,18838,18839,18840,18841,18842,18843,18844,18845,18846,18847,18848,18849,18850,18851,18852,18853,18854,18855,18856,18857,18858,18859,18860,18861,18862,18863,18864,18865,18866,18867,18868,18869,18870,18871,18872,18873,18874,18875,18876,18877,18878,18879,18880,18881,18882,18883,18884,18885,18886,18887,18888,18889,18890,18891,18892,18893,18894,18895,18896,18897,18898,18899,18900,18901,18902,18903,18904,18905,18906,18907,18908,18909,18910,18911,18912,18913,18914,18915,18916,18917,18918,18919,18920,18921,18922,18923,18924,18925,18926,18927,18928,18929,18930,18931,18932,18933,18934,18935,18936,18937,18938,18939,18940,18941,18942,18943,18944,18945,18946,18947,18948,18949,18950,18951,18952,18953,18954,18955,18956,18957,18958,18959,18960,18961,18962,18963,18964,18965,18966,18967,18968,18969,18970,18971,18972,18973,18974,18975,18976,18977,18978,18979,18980,18981,18982,18983,18984,18985,18986,18987,18988,18989,18990,18991,18992,18993,18994,18995,18996,18997,18998,18999,19000,19001,19002,19003,19004,19005,19006,19007,19008,19009,19010,19011,19012,19013,19014,19015,19016,19017,19018,19019,19020,19021,19022,19023,19024,19025,19026,19027,19028,19029,19030,19031,19032,19033,19034,19035,19036,19037,19038,19039,19040,19041,19042,19043,19044,19045,19046,19047,19048,19049,19050,19051,19052,19053,19054,19055,19056,19057,19058,19059,19060,19061,19062,19063,19064,19065,19066,19067,19068,19069,19070,19071,19072,19073,19074,19075,19076,19077,19078,19079,19080,19081,19082,19083,19084,19085,19086,19087,19088,19089,19090,19091,19092,19093,19094,19095,19096,19097,19098,19099,19100,19101,19102,19103,19104,19105,19106,19107,19108,19109,19110,19111,19112,19113,19114,19115,19116,19117,19118,19119,19120,19121,19122,19123,19124,19125,19126,19127,19128,19129,19130,19131,19132,19133,19134,19135,19136,19137,19138,19139,19140,19141,19142,19143,19144,19145,19146,19147,19148,19149,19150,19151,19152,19153,19154,19155,19156,19157,19158,19159,19160,19161,19162,19163,19164,19165,19166,19167,19168,19169,19170,19171,19172,19173,19174,19175,19176,19177,19178,19179,19180,19181,19182,19183,19184,19185,19186,19187,19188,19189,19190,19191,19192,19193,19194,19195,19196,19197,19198,19199,19200,19201,19202,19203,19204,19205,19206,19207,19208,19209,19210,19211,19212,19213,19214,19215,19216,19217,19218,19219,19220,19221,19222,19223,19224,19225,19226,19227,19228,19229,19230,19231,19232,19233,19234,19235,19236,19237,19238,19239,19240,19241,19242,19243,19244,19245,19246,19247,19248,19249,19250,19251,19252,19253,19254,19255,19256,19257,19258,19259,19260,19261,19262,19263,19264,19265,19266,19267,19268,19269,19270,19271,19272,19273,19274,19275,19276,19277,19278,19279,19280,19281,19282,19283,19284,19285,19286,19287,19288,19289,19290,19291,19292,19293,19294,19295,19296,19297,19298,19299,19300,19301,19302,19303,19304,19305,19306,19307,19308,19309,19310,19311,19312,19313,19314,19315,19316,19317,19318,19319,19320,19321,19322,19323,19324,19325,19326,19327,19328,19329,19330,19331,19332,19333,19334,19335,19336,19337,19338,19339,19340,19341,19342,19343,19344,19345,19346,19347,19348,19349,19350,19351,19352,19353,19354,19355,19356,19357,19358,19359,19360,19361,19362,19363,19364,19365,19366,19367,19368,19369,19370,19371,19372,19373,19374,19375,19376,19377,19378,19379,19380,19381,19382,19383,19384,19385,19386,19387,19388,19389,19390,19391,19392,19393,19394,19395,19396,19397,19398,19399,19400,19401,19402,19403,19404,19405,19406,19407,19408,19409,19410,19411,19412,19413,19414,19415,19416,19417,19418,19419,19420,19421,19422,19423,19424,19425,19426,19427,19428,19429,19430,19431,19432,19433,19434,19435,19436,19437,19438,19439,19440,19441,19442,19443,19444,19445,19446,19447,19448,19449,19450,19451,19452,19453,19454,19455,19456,19457,19458,19459,19460,19461,19462,19463,19464,19465,19466,19467,19468,19469,19470,19471,19472,19473,19474,19475,19476,19477,19478,19479,19480,19481,19482,19483,19484,19485,19486,19487,19488,19489,19490,19491,19492,19493,19494,19495,19496,19497,19498,19499,19500,19501,19502,19503,19504,19505,19506,19507,19508,19509,19510,19511,19512,19513,19514,19515,19516,19517,19518,19519,19520,19521,19522,19523,19524,19525,19526,19527,19528,19529,19530,19531,19532,19533,19534,19535,19536,19537,19538,19539,19540,19541,19542,19543,19544,19545,19546,19547,19548,19549,19550,19551,19552,19553,19554,19555,19556,19557,19558,19559,19560,19561,19562,19563,19564,19565,19566,19567,19568,19569,19570,19571,19572,19573,19574,19575,19576,19577,19578,19579,19580,19581,19582,19583,19584,19585,19586,19587,19588,19589,19590,19591,19592,19593,19594,19595,19596,19597,19598,19599,19600,19601,19602,19603,19604,19605,19606,19607,19608,19609,19610,19611,19612,19613,19614,19615,19616,19617,19618,19619,19620,19621,19622,19623,19624,19625,19626,19627,19628,19629,19630,19631,19632,19633,19634,19635,19636,19637,19638,19639,19640,19641,19642,19643,19644,19645,19646,19647,19648,19649,19650,19651,19652,19653,19654,19655,19656,19657,19658,19659,19660,19661,19662,19663,19664,19665,19666,19667,19668,19669,19670,19671,19672,19673,19674,19675,19676,19677,19678,19679,19680,19681,19682,19683,19684,19685,19686,19687,19688,19689,19690,19691,19692,19693,19694,19695,19696,19697,19698,19699,19700,19701,19702,19703,19704,19705,19706,19707,19708,19709,19710,19711,19712,19713,19714,19715,19716,19717,19718,19719,19720,19721,19722,19723,19724,19725,19726,19727,19728,19729,19730,19731,19732,19733,19734,19735,19736,19737,19738,19739,19740,19741,19742,19743,19744,19745,19746,19747,19748,19749,19750,19751,19752,19753,19754,19755,19756,19757,19758,19759,19760,19761,19762,19763,19764,19765,19766,19767,19768,19769,19770,19771,19772,19773,19774,19775,19776,19777,19778,19779,19780,19781,19782,19783,19784,19785,19786,19787,19788,19789,19790,19791,19792,19793,19794,19795,19796,19797,19798,19799,19800,19801,19802,19803,19804,19805,19806,19807,19808,19809,19810,19811,19812,19813,19814,19815,19816,19817,19818,19819,19820,19821,19822,19823,19824,19825,19826,19827,19828,19829,19830,19831,19832,19833,19834,19835,19836,19837,19838,19839,19840,19841,19842,19843,19844,19845,19846,19847,19848,19849,19850,19851,19852,19853,19854,19855,19856,19857,19858,19859,19860,19861,19862,19863,19864,19865,19866,19867,19868,19869,19870,19871,19872,19873,19874,19875,19876,19877,19878,19879,19880,19881,19882,19883,19884,19885,19886,19887,19888,19889,19890,19891,19892,19893,19968,19969,19970,19971,19972,19973,19974,19975,19976,19977,19978,19979,19980,19981,19982,19983,19984,19985,19986,19987,19988,19989,19990,19991,19992,19993,19994,19995,19996,19997,19998,19999,20000,20001,20002,20003,20004,20005,20006,20007,20008,20009,20010,20011,20012,20013,20014,20015,20016,20017,20018,20019,20020,20021,20022,20023,20024,20025,20026,20027,20028,20029,20030,20031,20032,20033,20034,20035,20036,20037,20038,20039,20040,20041,20042,20043,20044,20045,20046,20047,20048,20049,20050,20051,20052,20053,20054,20055,20056,20057,20058,20059,20060,20061,20062,20063,20064,20065,20066,20067,20068,20069,20070,20071,20072,20073,20074,20075,20076,20077,20078,20079,20080,20081,20082,20083,20084,20085,20086,20087,20088,20089,20090,20091,20092,20093,20094,20095,20096,20097,20098,20099,20100,20101,20102,20103,20104,20105,20106,20107,20108,20109,20110,20111,20112,20113,20114,20115,20116,20117,20118,20119,20120,20121,20122,20123,20124,20125,20126,20127,20128,20129,20130,20131,20132,20133,20134,20135,20136,20137,20138,20139,20140,20141,20142,20143,20144,20145,20146,20147,20148,20149,20150,20151,20152,20153,20154,20155,20156,20157,20158,20159,20160,20161,20162,20163,20164,20165,20166,20167,20168,20169,20170,20171,20172,20173,20174,20175,20176,20177,20178,20179,20180,20181,20182,20183,20184,20185,20186,20187,20188,20189,20190,20191,20192,20193,20194,20195,20196,20197,20198,20199,20200,20201,20202,20203,20204,20205,20206,20207,20208,20209,20210,20211,20212,20213,20214,20215,20216,20217,20218,20219,20220,20221,20222,20223,20224,20225,20226,20227,20228,20229,20230,20231,20232,20233,20234,20235,20236,20237,20238,20239,20240,20241,20242,20243,20244,20245,20246,20247,20248,20249,20250,20251,20252,20253,20254,20255,20256,20257,20258,20259,20260,20261,20262,20263,20264,20265,20266,20267,20268,20269,20270,20271,20272,20273,20274,20275,20276,20277,20278,20279,20280,20281,20282,20283,20284,20285,20286,20287,20288,20289,20290,20291,20292,20293,20294,20295,20296,20297,20298,20299,20300,20301,20302,20303,20304,20305,20306,20307,20308,20309,20310,20311,20312,20313,20314,20315,20316,20317,20318,20319,20320,20321,20322,20323,20324,20325,20326,20327,20328,20329,20330,20331,20332,20333,20334,20335,20336,20337,20338,20339,20340,20341,20342,20343,20344,20345,20346,20347,20348,20349,20350,20351,20352,20353,20354,20355,20356,20357,20358,20359,20360,20361,20362,20363,20364,20365,20366,20367,20368,20369,20370,20371,20372,20373,20374,20375,20376,20377,20378,20379,20380,20381,20382,20383,20384,20385,20386,20387,20388,20389,20390,20391,20392,20393,20394,20395,20396,20397,20398,20399,20400,20401,20402,20403,20404,20405,20406,20407,20408,20409,20410,20411,20412,20413,20414,20415,20416,20417,20418,20419,20420,20421,20422,20423,20424,20425,20426,20427,20428,20429,20430,20431,20432,20433,20434,20435,20436,20437,20438,20439,20440,20441,20442,20443,20444,20445,20446,20447,20448,20449,20450,20451,20452,20453,20454,20455,20456,20457,20458,20459,20460,20461,20462,20463,20464,20465,20466,20467,20468,20469,20470,20471,20472,20473,20474,20475,20476,20477,20478,20479,20480,20481,20482,20483,20484,20485,20486,20487,20488,20489,20490,20491,20492,20493,20494,20495,20496,20497,20498,20499,20500,20501,20502,20503,20504,20505,20506,20507,20508,20509,20510,20511,20512,20513,20514,20515,20516,20517,20518,20519,20520,20521,20522,20523,20524,20525,20526,20527,20528,20529,20530,20531,20532,20533,20534,20535,20536,20537,20538,20539,20540,20541,20542,20543,20544,20545,20546,20547,20548,20549,20550,20551,20552,20553,20554,20555,20556,20557,20558,20559,20560,20561,20562,20563,20564,20565,20566,20567,20568,20569,20570,20571,20572,20573,20574,20575,20576,20577,20578,20579,20580,20581,20582,20583,20584,20585,20586,20587,20588,20589,20590,20591,20592,20593,20594,20595,20596,20597,20598,20599,20600,20601,20602,20603,20604,20605,20606,20607,20608,20609,20610,20611,20612,20613,20614,20615,20616,20617,20618,20619,20620,20621,20622,20623,20624,20625,20626,20627,20628,20629,20630,20631,20632,20633,20634,20635,20636,20637,20638,20639,20640,20641,20642,20643,20644,20645,20646,20647,20648,20649,20650,20651,20652,20653,20654,20655,20656,20657,20658,20659,20660,20661,20662,20663,20664,20665,20666,20667,20668,20669,20670,20671,20672,20673,20674,20675,20676,20677,20678,20679,20680,20681,20682,20683,20684,20685,20686,20687,20688,20689,20690,20691,20692,20693,20694,20695,20696,20697,20698,20699,20700,20701,20702,20703,20704,20705,20706,20707,20708,20709,20710,20711,20712,20713,20714,20715,20716,20717,20718,20719,20720,20721,20722,20723,20724,20725,20726,20727,20728,20729,20730,20731,20732,20733,20734,20735,20736,20737,20738,20739,20740,20741,20742,20743,20744,20745,20746,20747,20748,20749,20750,20751,20752,20753,20754,20755,20756,20757,20758,20759,20760,20761,20762,20763,20764,20765,20766,20767,20768,20769,20770,20771,20772,20773,20774,20775,20776,20777,20778,20779,20780,20781,20782,20783,20784,20785,20786,20787,20788,20789,20790,20791,20792,20793,20794,20795,20796,20797,20798,20799,20800,20801,20802,20803,20804,20805,20806,20807,20808,20809,20810,20811,20812,20813,20814,20815,20816,20817,20818,20819,20820,20821,20822,20823,20824,20825,20826,20827,20828,20829,20830,20831,20832,20833,20834,20835,20836,20837,20838,20839,20840,20841,20842,20843,20844,20845,20846,20847,20848,20849,20850,20851,20852,20853,20854,20855,20856,20857,20858,20859,20860,20861,20862,20863,20864,20865,20866,20867,20868,20869,20870,20871,20872,20873,20874,20875,20876,20877,20878,20879,20880,20881,20882,20883,20884,20885,20886,20887,20888,20889,20890,20891,20892,20893,20894,20895,20896,20897,20898,20899,20900,20901,20902,20903,20904,20905,20906,20907,20908,20909,20910,20911,20912,20913,20914,20915,20916,20917,20918,20919,20920,20921,20922,20923,20924,20925,20926,20927,20928,20929,20930,20931,20932,20933,20934,20935,20936,20937,20938,20939,20940,20941,20942,20943,20944,20945,20946,20947,20948,20949,20950,20951,20952,20953,20954,20955,20956,20957,20958,20959,20960,20961,20962,20963,20964,20965,20966,20967,20968,20969,20970,20971,20972,20973,20974,20975,20976,20977,20978,20979,20980,20981,20982,20983,20984,20985,20986,20987,20988,20989,20990,20991,20992,20993,20994,20995,20996,20997,20998,20999,21000,21001,21002,21003,21004,21005,21006,21007,21008,21009,21010,21011,21012,21013,21014,21015,21016,21017,21018,21019,21020,21021,21022,21023,21024,21025,21026,21027,21028,21029,21030,21031,21032,21033,21034,21035,21036,21037,21038,21039,21040,21041,21042,21043,21044,21045,21046,21047,21048,21049,21050,21051,21052,21053,21054,21055,21056,21057,21058,21059,21060,21061,21062,21063,21064,21065,21066,21067,21068,21069,21070,21071,21072,21073,21074,21075,21076,21077,21078,21079,21080,21081,21082,21083,21084,21085,21086,21087,21088,21089,21090,21091,21092,21093,21094,21095,21096,21097,21098,21099,21100,21101,21102,21103,21104,21105,21106,21107,21108,21109,21110,21111,21112,21113,21114,21115,21116,21117,21118,21119,21120,21121,21122,21123,21124,21125,21126,21127,21128,21129,21130,21131,21132,21133,21134,21135,21136,21137,21138,21139,21140,21141,21142,21143,21144,21145,21146,21147,21148,21149,21150,21151,21152,21153,21154,21155,21156,21157,21158,21159,21160,21161,21162,21163,21164,21165,21166,21167,21168,21169,21170,21171,21172,21173,21174,21175,21176,21177,21178,21179,21180,21181,21182,21183,21184,21185,21186,21187,21188,21189,21190,21191,21192,21193,21194,21195,21196,21197,21198,21199,21200,21201,21202,21203,21204,21205,21206,21207,21208,21209,21210,21211,21212,21213,21214,21215,21216,21217,21218,21219,21220,21221,21222,21223,21224,21225,21226,21227,21228,21229,21230,21231,21232,21233,21234,21235,21236,21237,21238,21239,21240,21241,21242,21243,21244,21245,21246,21247,21248,21249,21250,21251,21252,21253,21254,21255,21256,21257,21258,21259,21260,21261,21262,21263,21264,21265,21266,21267,21268,21269,21270,21271,21272,21273,21274,21275,21276,21277,21278,21279,21280,21281,21282,21283,21284,21285,21286,21287,21288,21289,21290,21291,21292,21293,21294,21295,21296,21297,21298,21299,21300,21301,21302,21303,21304,21305,21306,21307,21308,21309,21310,21311,21312,21313,21314,21315,21316,21317,21318,21319,21320,21321,21322,21323,21324,21325,21326,21327,21328,21329,21330,21331,21332,21333,21334,21335,21336,21337,21338,21339,21340,21341,21342,21343,21344,21345,21346,21347,21348,21349,21350,21351,21352,21353,21354,21355,21356,21357,21358,21359,21360,21361,21362,21363,21364,21365,21366,21367,21368,21369,21370,21371,21372,21373,21374,21375,21376,21377,21378,21379,21380,21381,21382,21383,21384,21385,21386,21387,21388,21389,21390,21391,21392,21393,21394,21395,21396,21397,21398,21399,21400,21401,21402,21403,21404,21405,21406,21407,21408,21409,21410,21411,21412,21413,21414,21415,21416,21417,21418,21419,21420,21421,21422,21423,21424,21425,21426,21427,21428,21429,21430,21431,21432,21433,21434,21435,21436,21437,21438,21439,21440,21441,21442,21443,21444,21445,21446,21447,21448,21449,21450,21451,21452,21453,21454,21455,21456,21457,21458,21459,21460,21461,21462,21463,21464,21465,21466,21467,21468,21469,21470,21471,21472,21473,21474,21475,21476,21477,21478,21479,21480,21481,21482,21483,21484,21485,21486,21487,21488,21489,21490,21491,21492,21493,21494,21495,21496,21497,21498,21499,21500,21501,21502,21503,21504,21505,21506,21507,21508,21509,21510,21511,21512,21513,21514,21515,21516,21517,21518,21519,21520,21521,21522,21523,21524,21525,21526,21527,21528,21529,21530,21531,21532,21533,21534,21535,21536,21537,21538,21539,21540,21541,21542,21543,21544,21545,21546,21547,21548,21549,21550,21551,21552,21553,21554,21555,21556,21557,21558,21559,21560,21561,21562,21563,21564,21565,21566,21567,21568,21569,21570,21571,21572,21573,21574,21575,21576,21577,21578,21579,21580,21581,21582,21583,21584,21585,21586,21587,21588,21589,21590,21591,21592,21593,21594,21595,21596,21597,21598,21599,21600,21601,21602,21603,21604,21605,21606,21607,21608,21609,21610,21611,21612,21613,21614,21615,21616,21617,21618,21619,21620,21621,21622,21623,21624,21625,21626,21627,21628,21629,21630,21631,21632,21633,21634,21635,21636,21637,21638,21639,21640,21641,21642,21643,21644,21645,21646,21647,21648,21649,21650,21651,21652,21653,21654,21655,21656,21657,21658,21659,21660,21661,21662,21663,21664,21665,21666,21667,21668,21669,21670,21671,21672,21673,21674,21675,21676,21677,21678,21679,21680,21681,21682,21683,21684,21685,21686,21687,21688,21689,21690,21691,21692,21693,21694,21695,21696,21697,21698,21699,21700,21701,21702,21703,21704,21705,21706,21707,21708,21709,21710,21711,21712,21713,21714,21715,21716,21717,21718,21719,21720,21721,21722,21723,21724,21725,21726,21727,21728,21729,21730,21731,21732,21733,21734,21735,21736,21737,21738,21739,21740,21741,21742,21743,21744,21745,21746,21747,21748,21749,21750,21751,21752,21753,21754,21755,21756,21757,21758,21759,21760,21761,21762,21763,21764,21765,21766,21767,21768,21769,21770,21771,21772,21773,21774,21775,21776,21777,21778,21779,21780,21781,21782,21783,21784,21785,21786,21787,21788,21789,21790,21791,21792,21793,21794,21795,21796,21797,21798,21799,21800,21801,21802,21803,21804,21805,21806,21807,21808,21809,21810,21811,21812,21813,21814,21815,21816,21817,21818,21819,21820,21821,21822,21823,21824,21825,21826,21827,21828,21829,21830,21831,21832,21833,21834,21835,21836,21837,21838,21839,21840,21841,21842,21843,21844,21845,21846,21847,21848,21849,21850,21851,21852,21853,21854,21855,21856,21857,21858,21859,21860,21861,21862,21863,21864,21865,21866,21867,21868,21869,21870,21871,21872,21873,21874,21875,21876,21877,21878,21879,21880,21881,21882,21883,21884,21885,21886,21887,21888,21889,21890,21891,21892,21893,21894,21895,21896,21897,21898,21899,21900,21901,21902,21903,21904,21905,21906,21907,21908,21909,21910,21911,21912,21913,21914,21915,21916,21917,21918,21919,21920,21921,21922,21923,21924,21925,21926,21927,21928,21929,21930,21931,21932,21933,21934,21935,21936,21937,21938,21939,21940,21941,21942,21943,21944,21945,21946,21947,21948,21949,21950,21951,21952,21953,21954,21955,21956,21957,21958,21959,21960,21961,21962,21963,21964,21965,21966,21967,21968,21969,21970,21971,21972,21973,21974,21975,21976,21977,21978,21979,21980,21981,21982,21983,21984,21985,21986,21987,21988,21989,21990,21991,21992,21993,21994,21995,21996,21997,21998,21999,22000,22001,22002,22003,22004,22005,22006,22007,22008,22009,22010,22011,22012,22013,22014,22015,22016,22017,22018,22019,22020,22021,22022,22023,22024,22025,22026,22027,22028,22029,22030,22031,22032,22033,22034,22035,22036,22037,22038,22039,22040,22041,22042,22043,22044,22045,22046,22047,22048,22049,22050,22051,22052,22053,22054,22055,22056,22057,22058,22059,22060,22061,22062,22063,22064,22065,22066,22067,22068,22069,22070,22071,22072,22073,22074,22075,22076,22077,22078,22079,22080,22081,22082,22083,22084,22085,22086,22087,22088,22089,22090,22091,22092,22093,22094,22095,22096,22097,22098,22099,22100,22101,22102,22103,22104,22105,22106,22107,22108,22109,22110,22111,22112,22113,22114,22115,22116,22117,22118,22119,22120,22121,22122,22123,22124,22125,22126,22127,22128,22129,22130,22131,22132,22133,22134,22135,22136,22137,22138,22139,22140,22141,22142,22143,22144,22145,22146,22147,22148,22149,22150,22151,22152,22153,22154,22155,22156,22157,22158,22159,22160,22161,22162,22163,22164,22165,22166,22167,22168,22169,22170,22171,22172,22173,22174,22175,22176,22177,22178,22179,22180,22181,22182,22183,22184,22185,22186,22187,22188,22189,22190,22191,22192,22193,22194,22195,22196,22197,22198,22199,22200,22201,22202,22203,22204,22205,22206,22207,22208,22209,22210,22211,22212,22213,22214,22215,22216,22217,22218,22219,22220,22221,22222,22223,22224,22225,22226,22227,22228,22229,22230,22231,22232,22233,22234,22235,22236,22237,22238,22239,22240,22241,22242,22243,22244,22245,22246,22247,22248,22249,22250,22251,22252,22253,22254,22255,22256,22257,22258,22259,22260,22261,22262,22263,22264,22265,22266,22267,22268,22269,22270,22271,22272,22273,22274,22275,22276,22277,22278,22279,22280,22281,22282,22283,22284,22285,22286,22287,22288,22289,22290,22291,22292,22293,22294,22295,22296,22297,22298,22299,22300,22301,22302,22303,22304,22305,22306,22307,22308,22309,22310,22311,22312,22313,22314,22315,22316,22317,22318,22319,22320,22321,22322,22323,22324,22325,22326,22327,22328,22329,22330,22331,22332,22333,22334,22335,22336,22337,22338,22339,22340,22341,22342,22343,22344,22345,22346,22347,22348,22349,22350,22351,22352,22353,22354,22355,22356,22357,22358,22359,22360,22361,22362,22363,22364,22365,22366,22367,22368,22369,22370,22371,22372,22373,22374,22375,22376,22377,22378,22379,22380,22381,22382,22383,22384,22385,22386,22387,22388,22389,22390,22391,22392,22393,22394,22395,22396,22397,22398,22399,22400,22401,22402,22403,22404,22405,22406,22407,22408,22409,22410,22411,22412,22413,22414,22415,22416,22417,22418,22419,22420,22421,22422,22423,22424,22425,22426,22427,22428,22429,22430,22431,22432,22433,22434,22435,22436,22437,22438,22439,22440,22441,22442,22443,22444,22445,22446,22447,22448,22449,22450,22451,22452,22453,22454,22455,22456,22457,22458,22459,22460,22461,22462,22463,22464,22465,22466,22467,22468,22469,22470,22471,22472,22473,22474,22475,22476,22477,22478,22479,22480,22481,22482,22483,22484,22485,22486,22487,22488,22489,22490,22491,22492,22493,22494,22495,22496,22497,22498,22499,22500,22501,22502,22503,22504,22505,22506,22507,22508,22509,22510,22511,22512,22513,22514,22515,22516,22517,22518,22519,22520,22521,22522,22523,22524,22525,22526,22527,22528,22529,22530,22531,22532,22533,22534,22535,22536,22537,22538,22539,22540,22541,22542,22543,22544,22545,22546,22547,22548,22549,22550,22551,22552,22553,22554,22555,22556,22557,22558,22559,22560,22561,22562,22563,22564,22565,22566,22567,22568,22569,22570,22571,22572,22573,22574,22575,22576,22577,22578,22579,22580,22581,22582,22583,22584,22585,22586,22587,22588,22589,22590,22591,22592,22593,22594,22595,22596,22597,22598,22599,22600,22601,22602,22603,22604,22605,22606,22607,22608,22609,22610,22611,22612,22613,22614,22615,22616,22617,22618,22619,22620,22621,22622,22623,22624,22625,22626,22627,22628,22629,22630,22631,22632,22633,22634,22635,22636,22637,22638,22639,22640,22641,22642,22643,22644,22645,22646,22647,22648,22649,22650,22651,22652,22653,22654,22655,22656,22657,22658,22659,22660,22661,22662,22663,22664,22665,22666,22667,22668,22669,22670,22671,22672,22673,22674,22675,22676,22677,22678,22679,22680,22681,22682,22683,22684,22685,22686,22687,22688,22689,22690,22691,22692,22693,22694,22695,22696,22697,22698,22699,22700,22701,22702,22703,22704,22705,22706,22707,22708,22709,22710,22711,22712,22713,22714,22715,22716,22717,22718,22719,22720,22721,22722,22723,22724,22725,22726,22727,22728,22729,22730,22731,22732,22733,22734,22735,22736,22737,22738,22739,22740,22741,22742,22743,22744,22745,22746,22747,22748,22749,22750,22751,22752,22753,22754,22755,22756,22757,22758,22759,22760,22761,22762,22763,22764,22765,22766,22767,22768,22769,22770,22771,22772,22773,22774,22775,22776,22777,22778,22779,22780,22781,22782,22783,22784,22785,22786,22787,22788,22789,22790,22791,22792,22793,22794,22795,22796,22797,22798,22799,22800,22801,22802,22803,22804,22805,22806,22807,22808,22809,22810,22811,22812,22813,22814,22815,22816,22817,22818,22819,22820,22821,22822,22823,22824,22825,22826,22827,22828,22829,22830,22831,22832,22833,22834,22835,22836,22837,22838,22839,22840,22841,22842,22843,22844,22845,22846,22847,22848,22849,22850,22851,22852,22853,22854,22855,22856,22857,22858,22859,22860,22861,22862,22863,22864,22865,22866,22867,22868,22869,22870,22871,22872,22873,22874,22875,22876,22877,22878,22879,22880,22881,22882,22883,22884,22885,22886,22887,22888,22889,22890,22891,22892,22893,22894,22895,22896,22897,22898,22899,22900,22901,22902,22903,22904,22905,22906,22907,22908,22909,22910,22911,22912,22913,22914,22915,22916,22917,22918,22919,22920,22921,22922,22923,22924,22925,22926,22927,22928,22929,22930,22931,22932,22933,22934,22935,22936,22937,22938,22939,22940,22941,22942,22943,22944,22945,22946,22947,22948,22949,22950,22951,22952,22953,22954,22955,22956,22957,22958,22959,22960,22961,22962,22963,22964,22965,22966,22967,22968,22969,22970,22971,22972,22973,22974,22975,22976,22977,22978,22979,22980,22981,22982,22983,22984,22985,22986,22987,22988,22989,22990,22991,22992,22993,22994,22995,22996,22997,22998,22999,23000,23001,23002,23003,23004,23005,23006,23007,23008,23009,23010,23011,23012,23013,23014,23015,23016,23017,23018,23019,23020,23021,23022,23023,23024,23025,23026,23027,23028,23029,23030,23031,23032,23033,23034,23035,23036,23037,23038,23039,23040,23041,23042,23043,23044,23045,23046,23047,23048,23049,23050,23051,23052,23053,23054,23055,23056,23057,23058,23059,23060,23061,23062,23063,23064,23065,23066,23067,23068,23069,23070,23071,23072,23073,23074,23075,23076,23077,23078,23079,23080,23081,23082,23083,23084,23085,23086,23087,23088,23089,23090,23091,23092,23093,23094,23095,23096,23097,23098,23099,23100,23101,23102,23103,23104,23105,23106,23107,23108,23109,23110,23111,23112,23113,23114,23115,23116,23117,23118,23119,23120,23121,23122,23123,23124,23125,23126,23127,23128,23129,23130,23131,23132,23133,23134,23135,23136,23137,23138,23139,23140,23141,23142,23143,23144,23145,23146,23147,23148,23149,23150,23151,23152,23153,23154,23155,23156,23157,23158,23159,23160,23161,23162,23163,23164,23165,23166,23167,23168,23169,23170,23171,23172,23173,23174,23175,23176,23177,23178,23179,23180,23181,23182,23183,23184,23185,23186,23187,23188,23189,23190,23191,23192,23193,23194,23195,23196,23197,23198,23199,23200,23201,23202,23203,23204,23205,23206,23207,23208,23209,23210,23211,23212,23213,23214,23215,23216,23217,23218,23219,23220,23221,23222,23223,23224,23225,23226,23227,23228,23229,23230,23231,23232,23233,23234,23235,23236,23237,23238,23239,23240,23241,23242,23243,23244,23245,23246,23247,23248,23249,23250,23251,23252,23253,23254,23255,23256,23257,23258,23259,23260,23261,23262,23263,23264,23265,23266,23267,23268,23269,23270,23271,23272,23273,23274,23275,23276,23277,23278,23279,23280,23281,23282,23283,23284,23285,23286,23287,23288,23289,23290,23291,23292,23293,23294,23295,23296,23297,23298,23299,23300,23301,23302,23303,23304,23305,23306,23307,23308,23309,23310,23311,23312,23313,23314,23315,23316,23317,23318,23319,23320,23321,23322,23323,23324,23325,23326,23327,23328,23329,23330,23331,23332,23333,23334,23335,23336,23337,23338,23339,23340,23341,23342,23343,23344,23345,23346,23347,23348,23349,23350,23351,23352,23353,23354,23355,23356,23357,23358,23359,23360,23361,23362,23363,23364,23365,23366,23367,23368,23369,23370,23371,23372,23373,23374,23375,23376,23377,23378,23379,23380,23381,23382,23383,23384,23385,23386,23387,23388,23389,23390,23391,23392,23393,23394,23395,23396,23397,23398,23399,23400,23401,23402,23403,23404,23405,23406,23407,23408,23409,23410,23411,23412,23413,23414,23415,23416,23417,23418,23419,23420,23421,23422,23423,23424,23425,23426,23427,23428,23429,23430,23431,23432,23433,23434,23435,23436,23437,23438,23439,23440,23441,23442,23443,23444,23445,23446,23447,23448,23449,23450,23451,23452,23453,23454,23455,23456,23457,23458,23459,23460,23461,23462,23463,23464,23465,23466,23467,23468,23469,23470,23471,23472,23473,23474,23475,23476,23477,23478,23479,23480,23481,23482,23483,23484,23485,23486,23487,23488,23489,23490,23491,23492,23493,23494,23495,23496,23497,23498,23499,23500,23501,23502,23503,23504,23505,23506,23507,23508,23509,23510,23511,23512,23513,23514,23515,23516,23517,23518,23519,23520,23521,23522,23523,23524,23525,23526,23527,23528,23529,23530,23531,23532,23533,23534,23535,23536,23537,23538,23539,23540,23541,23542,23543,23544,23545,23546,23547,23548,23549,23550,23551,23552,23553,23554,23555,23556,23557,23558,23559,23560,23561,23562,23563,23564,23565,23566,23567,23568,23569,23570,23571,23572,23573,23574,23575,23576,23577,23578,23579,23580,23581,23582,23583,23584,23585,23586,23587,23588,23589,23590,23591,23592,23593,23594,23595,23596,23597,23598,23599,23600,23601,23602,23603,23604,23605,23606,23607,23608,23609,23610,23611,23612,23613,23614,23615,23616,23617,23618,23619,23620,23621,23622,23623,23624,23625,23626,23627,23628,23629,23630,23631,23632,23633,23634,23635,23636,23637,23638,23639,23640,23641,23642,23643,23644,23645,23646,23647,23648,23649,23650,23651,23652,23653,23654,23655,23656,23657,23658,23659,23660,23661,23662,23663,23664,23665,23666,23667,23668,23669,23670,23671,23672,23673,23674,23675,23676,23677,23678,23679,23680,23681,23682,23683,23684,23685,23686,23687,23688,23689,23690,23691,23692,23693,23694,23695,23696,23697,23698,23699,23700,23701,23702,23703,23704,23705,23706,23707,23708,23709,23710,23711,23712,23713,23714,23715,23716,23717,23718,23719,23720,23721,23722,23723,23724,23725,23726,23727,23728,23729,23730,23731,23732,23733,23734,23735,23736,23737,23738,23739,23740,23741,23742,23743,23744,23745,23746,23747,23748,23749,23750,23751,23752,23753,23754,23755,23756,23757,23758,23759,23760,23761,23762,23763,23764,23765,23766,23767,23768,23769,23770,23771,23772,23773,23774,23775,23776,23777,23778,23779,23780,23781,23782,23783,23784,23785,23786,23787,23788,23789,23790,23791,23792,23793,23794,23795,23796,23797,23798,23799,23800,23801,23802,23803,23804,23805,23806,23807,23808,23809,23810,23811,23812,23813,23814,23815,23816,23817,23818,23819,23820,23821,23822,23823,23824,23825,23826,23827,23828,23829,23830,23831,23832,23833,23834,23835,23836,23837,23838,23839,23840,23841,23842,23843,23844,23845,23846,23847,23848,23849,23850,23851,23852,23853,23854,23855,23856,23857,23858,23859,23860,23861,23862,23863,23864,23865,23866,23867,23868,23869,23870,23871,23872,23873,23874,23875,23876,23877,23878,23879,23880,23881,23882,23883,23884,23885,23886,23887,23888,23889,23890,23891,23892,23893,23894,23895,23896,23897,23898,23899,23900,23901,23902,23903,23904,23905,23906,23907,23908,23909,23910,23911,23912,23913,23914,23915,23916,23917,23918,23919,23920,23921,23922,23923,23924,23925,23926,23927,23928,23929,23930,23931,23932,23933,23934,23935,23936,23937,23938,23939,23940,23941,23942,23943,23944,23945,23946,23947,23948,23949,23950,23951,23952,23953,23954,23955,23956,23957,23958,23959,23960,23961,23962,23963,23964,23965,23966,23967,23968,23969,23970,23971,23972,23973,23974,23975,23976,23977,23978,23979,23980,23981,23982,23983,23984,23985,23986,23987,23988,23989,23990,23991,23992,23993,23994,23995,23996,23997,23998,23999,24000,24001,24002,24003,24004,24005,24006,24007,24008,24009,24010,24011,24012,24013,24014,24015,24016,24017,24018,24019,24020,24021,24022,24023,24024,24025,24026,24027,24028,24029,24030,24031,24032,24033,24034,24035,24036,24037,24038,24039,24040,24041,24042,24043,24044,24045,24046,24047,24048,24049,24050,24051,24052,24053,24054,24055,24056,24057,24058,24059,24060,24061,24062,24063,24064,24065,24066,24067,24068,24069,24070,24071,24072,24073,24074,24075,24076,24077,24078,24079,24080,24081,24082,24083,24084,24085,24086,24087,24088,24089,24090,24091,24092,24093,24094,24095,24096,24097,24098,24099,24100,24101,24102,24103,24104,24105,24106,24107,24108,24109,24110,24111,24112,24113,24114,24115,24116,24117,24118,24119,24120,24121,24122,24123,24124,24125,24126,24127,24128,24129,24130,24131,24132,24133,24134,24135,24136,24137,24138,24139,24140,24141,24142,24143,24144,24145,24146,24147,24148,24149,24150,24151,24152,24153,24154,24155,24156,24157,24158,24159,24160,24161,24162,24163,24164,24165,24166,24167,24168,24169,24170,24171,24172,24173,24174,24175,24176,24177,24178,24179,24180,24181,24182,24183,24184,24185,24186,24187,24188,24189,24190,24191,24192,24193,24194,24195,24196,24197,24198,24199,24200,24201,24202,24203,24204,24205,24206,24207,24208,24209,24210,24211,24212,24213,24214,24215,24216,24217,24218,24219,24220,24221,24222,24223,24224,24225,24226,24227,24228,24229,24230,24231,24232,24233,24234,24235,24236,24237,24238,24239,24240,24241,24242,24243,24244,24245,24246,24247,24248,24249,24250,24251,24252,24253,24254,24255,24256,24257,24258,24259,24260,24261,24262,24263,24264,24265,24266,24267,24268,24269,24270,24271,24272,24273,24274,24275,24276,24277,24278,24279,24280,24281,24282,24283,24284,24285,24286,24287,24288,24289,24290,24291,24292,24293,24294,24295,24296,24297,24298,24299,24300,24301,24302,24303,24304,24305,24306,24307,24308,24309,24310,24311,24312,24313,24314,24315,24316,24317,24318,24319,24320,24321,24322,24323,24324,24325,24326,24327,24328,24329,24330,24331,24332,24333,24334,24335,24336,24337,24338,24339,24340,24341,24342,24343,24344,24345,24346,24347,24348,24349,24350,24351,24352,24353,24354,24355,24356,24357,24358,24359,24360,24361,24362,24363,24364,24365,24366,24367,24368,24369,24370,24371,24372,24373,24374,24375,24376,24377,24378,24379,24380,24381,24382,24383,24384,24385,24386,24387,24388,24389,24390,24391,24392,24393,24394,24395,24396,24397,24398,24399,24400,24401,24402,24403,24404,24405,24406,24407,24408,24409,24410,24411,24412,24413,24414,24415,24416,24417,24418,24419,24420,24421,24422,24423,24424,24425,24426,24427,24428,24429,24430,24431,24432,24433,24434,24435,24436,24437,24438,24439,24440,24441,24442,24443,24444,24445,24446,24447,24448,24449,24450,24451,24452,24453,24454,24455,24456,24457,24458,24459,24460,24461,24462,24463,24464,24465,24466,24467,24468,24469,24470,24471,24472,24473,24474,24475,24476,24477,24478,24479,24480,24481,24482,24483,24484,24485,24486,24487,24488,24489,24490,24491,24492,24493,24494,24495,24496,24497,24498,24499,24500,24501,24502,24503,24504,24505,24506,24507,24508,24509,24510,24511,24512,24513,24514,24515,24516,24517,24518,24519,24520,24521,24522,24523,24524,24525,24526,24527,24528,24529,24530,24531,24532,24533,24534,24535,24536,24537,24538,24539,24540,24541,24542,24543,24544,24545,24546,24547,24548,24549,24550,24551,24552,24553,24554,24555,24556,24557,24558,24559,24560,24561,24562,24563,24564,24565,24566,24567,24568,24569,24570,24571,24572,24573,24574,24575,24576,24577,24578,24579,24580,24581,24582,24583,24584,24585,24586,24587,24588,24589,24590,24591,24592,24593,24594,24595,24596,24597,24598,24599,24600,24601,24602,24603,24604,24605,24606,24607,24608,24609,24610,24611,24612,24613,24614,24615,24616,24617,24618,24619,24620,24621,24622,24623,24624,24625,24626,24627,24628,24629,24630,24631,24632,24633,24634,24635,24636,24637,24638,24639,24640,24641,24642,24643,24644,24645,24646,24647,24648,24649,24650,24651,24652,24653,24654,24655,24656,24657,24658,24659,24660,24661,24662,24663,24664,24665,24666,24667,24668,24669,24670,24671,24672,24673,24674,24675,24676,24677,24678,24679,24680,24681,24682,24683,24684,24685,24686,24687,24688,24689,24690,24691,24692,24693,24694,24695,24696,24697,24698,24699,24700,24701,24702,24703,24704,24705,24706,24707,24708,24709,24710,24711,24712,24713,24714,24715,24716,24717,24718,24719,24720,24721,24722,24723,24724,24725,24726,24727,24728,24729,24730,24731,24732,24733,24734,24735,24736,24737,24738,24739,24740,24741,24742,24743,24744,24745,24746,24747,24748,24749,24750,24751,24752,24753,24754,24755,24756,24757,24758,24759,24760,24761,24762,24763,24764,24765,24766,24767,24768,24769,24770,24771,24772,24773,24774,24775,24776,24777,24778,24779,24780,24781,24782,24783,24784,24785,24786,24787,24788,24789,24790,24791,24792,24793,24794,24795,24796,24797,24798,24799,24800,24801,24802,24803,24804,24805,24806,24807,24808,24809,24810,24811,24812,24813,24814,24815,24816,24817,24818,24819,24820,24821,24822,24823,24824,24825,24826,24827,24828,24829,24830,24831,24832,24833,24834,24835,24836,24837,24838,24839,24840,24841,24842,24843,24844,24845,24846,24847,24848,24849,24850,24851,24852,24853,24854,24855,24856,24857,24858,24859,24860,24861,24862,24863,24864,24865,24866,24867,24868,24869,24870,24871,24872,24873,24874,24875,24876,24877,24878,24879,24880,24881,24882,24883,24884,24885,24886,24887,24888,24889,24890,24891,24892,24893,24894,24895,24896,24897,24898,24899,24900,24901,24902,24903,24904,24905,24906,24907,24908,24909,24910,24911,24912,24913,24914,24915,24916,24917,24918,24919,24920,24921,24922,24923,24924,24925,24926,24927,24928,24929,24930,24931,24932,24933,24934,24935,24936,24937,24938,24939,24940,24941,24942,24943,24944,24945,24946,24947,24948,24949,24950,24951,24952,24953,24954,24955,24956,24957,24958,24959,24960,24961,24962,24963,24964,24965,24966,24967,24968,24969,24970,24971,24972,24973,24974,24975,24976,24977,24978,24979,24980,24981,24982,24983,24984,24985,24986,24987,24988,24989,24990,24991,24992,24993,24994,24995,24996,24997,24998,24999,25000,25001,25002,25003,25004,25005,25006,25007,25008,25009,25010,25011,25012,25013,25014,25015,25016,25017,25018,25019,25020,25021,25022,25023,25024,25025,25026,25027,25028,25029,25030,25031,25032,25033,25034,25035,25036,25037,25038,25039,25040,25041,25042,25043,25044,25045,25046,25047,25048,25049,25050,25051,25052,25053,25054,25055,25056,25057,25058,25059,25060,25061,25062,25063,25064,25065,25066,25067,25068,25069,25070,25071,25072,25073,25074,25075,25076,25077,25078,25079,25080,25081,25082,25083,25084,25085,25086,25087,25088,25089,25090,25091,25092,25093,25094,25095,25096,25097,25098,25099,25100,25101,25102,25103,25104,25105,25106,25107,25108,25109,25110,25111,25112,25113,25114,25115,25116,25117,25118,25119,25120,25121,25122,25123,25124,25125,25126,25127,25128,25129,25130,25131,25132,25133,25134,25135,25136,25137,25138,25139,25140,25141,25142,25143,25144,25145,25146,25147,25148,25149,25150,25151,25152,25153,25154,25155,25156,25157,25158,25159,25160,25161,25162,25163,25164,25165,25166,25167,25168,25169,25170,25171,25172,25173,25174,25175,25176,25177,25178,25179,25180,25181,25182,25183,25184,25185,25186,25187,25188,25189,25190,25191,25192,25193,25194,25195,25196,25197,25198,25199,25200,25201,25202,25203,25204,25205,25206,25207,25208,25209,25210,25211,25212,25213,25214,25215,25216,25217,25218,25219,25220,25221,25222,25223,25224,25225,25226,25227,25228,25229,25230,25231,25232,25233,25234,25235,25236,25237,25238,25239,25240,25241,25242,25243,25244,25245,25246,25247,25248,25249,25250,25251,25252,25253,25254,25255,25256,25257,25258,25259,25260,25261,25262,25263,25264,25265,25266,25267,25268,25269,25270,25271,25272,25273,25274,25275,25276,25277,25278,25279,25280,25281,25282,25283,25284,25285,25286,25287,25288,25289,25290,25291,25292,25293,25294,25295,25296,25297,25298,25299,25300,25301,25302,25303,25304,25305,25306,25307,25308,25309,25310,25311,25312,25313,25314,25315,25316,25317,25318,25319,25320,25321,25322,25323,25324,25325,25326,25327,25328,25329,25330,25331,25332,25333,25334,25335,25336,25337,25338,25339,25340,25341,25342,25343,25344,25345,25346,25347,25348,25349,25350,25351,25352,25353,25354,25355,25356,25357,25358,25359,25360,25361,25362,25363,25364,25365,25366,25367,25368,25369,25370,25371,25372,25373,25374,25375,25376,25377,25378,25379,25380,25381,25382,25383,25384,25385,25386,25387,25388,25389,25390,25391,25392,25393,25394,25395,25396,25397,25398,25399,25400,25401,25402,25403,25404,25405,25406,25407,25408,25409,25410,25411,25412,25413,25414,25415,25416,25417,25418,25419,25420,25421,25422,25423,25424,25425,25426,25427,25428,25429,25430,25431,25432,25433,25434,25435,25436,25437,25438,25439,25440,25441,25442,25443,25444,25445,25446,25447,25448,25449,25450,25451,25452,25453,25454,25455,25456,25457,25458,25459,25460,25461,25462,25463,25464,25465,25466,25467,25468,25469,25470,25471,25472,25473,25474,25475,25476,25477,25478,25479,25480,25481,25482,25483,25484,25485,25486,25487,25488,25489,25490,25491,25492,25493,25494,25495,25496,25497,25498,25499,25500,25501,25502,25503,25504,25505,25506,25507,25508,25509,25510,25511,25512,25513,25514,25515,25516,25517,25518,25519,25520,25521,25522,25523,25524,25525,25526,25527,25528,25529,25530,25531,25532,25533,25534,25535,25536,25537,25538,25539,25540,25541,25542,25543,25544,25545,25546,25547,25548,25549,25550,25551,25552,25553,25554,25555,25556,25557,25558,25559,25560,25561,25562,25563,25564,25565,25566,25567,25568,25569,25570,25571,25572,25573,25574,25575,25576,25577,25578,25579,25580,25581,25582,25583,25584,25585,25586,25587,25588,25589,25590,25591,25592,25593,25594,25595,25596,25597,25598,25599,25600,25601,25602,25603,25604,25605,25606,25607,25608,25609,25610,25611,25612,25613,25614,25615,25616,25617,25618,25619,25620,25621,25622,25623,25624,25625,25626,25627,25628,25629,25630,25631,25632,25633,25634,25635,25636,25637,25638,25639,25640,25641,25642,25643,25644,25645,25646,25647,25648,25649,25650,25651,25652,25653,25654,25655,25656,25657,25658,25659,25660,25661,25662,25663,25664,25665,25666,25667,25668,25669,25670,25671,25672,25673,25674,25675,25676,25677,25678,25679,25680,25681,25682,25683,25684,25685,25686,25687,25688,25689,25690,25691,25692,25693,25694,25695,25696,25697,25698,25699,25700,25701,25702,25703,25704,25705,25706,25707,25708,25709,25710,25711,25712,25713,25714,25715,25716,25717,25718,25719,25720,25721,25722,25723,25724,25725,25726,25727,25728,25729,25730,25731,25732,25733,25734,25735,25736,25737,25738,25739,25740,25741,25742,25743,25744,25745,25746,25747,25748,25749,25750,25751,25752,25753,25754,25755,25756,25757,25758,25759,25760,25761,25762,25763,25764,25765,25766,25767,25768,25769,25770,25771,25772,25773,25774,25775,25776,25777,25778,25779,25780,25781,25782,25783,25784,25785,25786,25787,25788,25789,25790,25791,25792,25793,25794,25795,25796,25797,25798,25799,25800,25801,25802,25803,25804,25805,25806,25807,25808,25809,25810,25811,25812,25813,25814,25815,25816,25817,25818,25819,25820,25821,25822,25823,25824,25825,25826,25827,25828,25829,25830,25831,25832,25833,25834,25835,25836,25837,25838,25839,25840,25841,25842,25843,25844,25845,25846,25847,25848,25849,25850,25851,25852,25853,25854,25855,25856,25857,25858,25859,25860,25861,25862,25863,25864,25865,25866,25867,25868,25869,25870,25871,25872,25873,25874,25875,25876,25877,25878,25879,25880,25881,25882,25883,25884,25885,25886,25887,25888,25889,25890,25891,25892,25893,25894,25895,25896,25897,25898,25899,25900,25901,25902,25903,25904,25905,25906,25907,25908,25909,25910,25911,25912,25913,25914,25915,25916,25917,25918,25919,25920,25921,25922,25923,25924,25925,25926,25927,25928,25929,25930,25931,25932,25933,25934,25935,25936,25937,25938,25939,25940,25941,25942,25943,25944,25945,25946,25947,25948,25949,25950,25951,25952,25953,25954,25955,25956,25957,25958,25959,25960,25961,25962,25963,25964,25965,25966,25967,25968,25969,25970,25971,25972,25973,25974,25975,25976,25977,25978,25979,25980,25981,25982,25983,25984,25985,25986,25987,25988,25989,25990,25991,25992,25993,25994,25995,25996,25997,25998,25999,26000,26001,26002,26003,26004,26005,26006,26007,26008,26009,26010,26011,26012,26013,26014,26015,26016,26017,26018,26019,26020,26021,26022,26023,26024,26025,26026,26027,26028,26029,26030,26031,26032,26033,26034,26035,26036,26037,26038,26039,26040,26041,26042,26043,26044,26045,26046,26047,26048,26049,26050,26051,26052,26053,26054,26055,26056,26057,26058,26059,26060,26061,26062,26063,26064,26065,26066,26067,26068,26069,26070,26071,26072,26073,26074,26075,26076,26077,26078,26079,26080,26081,26082,26083,26084,26085,26086,26087,26088,26089,26090,26091,26092,26093,26094,26095,26096,26097,26098,26099,26100,26101,26102,26103,26104,26105,26106,26107,26108,26109,26110,26111,26112,26113,26114,26115,26116,26117,26118,26119,26120,26121,26122,26123,26124,26125,26126,26127,26128,26129,26130,26131,26132,26133,26134,26135,26136,26137,26138,26139,26140,26141,26142,26143,26144,26145,26146,26147,26148,26149,26150,26151,26152,26153,26154,26155,26156,26157,26158,26159,26160,26161,26162,26163,26164,26165,26166,26167,26168,26169,26170,26171,26172,26173,26174,26175,26176,26177,26178,26179,26180,26181,26182,26183,26184,26185,26186,26187,26188,26189,26190,26191,26192,26193,26194,26195,26196,26197,26198,26199,26200,26201,26202,26203,26204,26205,26206,26207,26208,26209,26210,26211,26212,26213,26214,26215,26216,26217,26218,26219,26220,26221,26222,26223,26224,26225,26226,26227,26228,26229,26230,26231,26232,26233,26234,26235,26236,26237,26238,26239,26240,26241,26242,26243,26244,26245,26246,26247,26248,26249,26250,26251,26252,26253,26254,26255,26256,26257,26258,26259,26260,26261,26262,26263,26264,26265,26266,26267,26268,26269,26270,26271,26272,26273,26274,26275,26276,26277,26278,26279,26280,26281,26282,26283,26284,26285,26286,26287,26288,26289,26290,26291,26292,26293,26294,26295,26296,26297,26298,26299,26300,26301,26302,26303,26304,26305,26306,26307,26308,26309,26310,26311,26312,26313,26314,26315,26316,26317,26318,26319,26320,26321,26322,26323,26324,26325,26326,26327,26328,26329,26330,26331,26332,26333,26334,26335,26336,26337,26338,26339,26340,26341,26342,26343,26344,26345,26346,26347,26348,26349,26350,26351,26352,26353,26354,26355,26356,26357,26358,26359,26360,26361,26362,26363,26364,26365,26366,26367,26368,26369,26370,26371,26372,26373,26374,26375,26376,26377,26378,26379,26380,26381,26382,26383,26384,26385,26386,26387,26388,26389,26390,26391,26392,26393,26394,26395,26396,26397,26398,26399,26400,26401,26402,26403,26404,26405,26406,26407,26408,26409,26410,26411,26412,26413,26414,26415,26416,26417,26418,26419,26420,26421,26422,26423,26424,26425,26426,26427,26428,26429,26430,26431,26432,26433,26434,26435,26436,26437,26438,26439,26440,26441,26442,26443,26444,26445,26446,26447,26448,26449,26450,26451,26452,26453,26454,26455,26456,26457,26458,26459,26460,26461,26462,26463,26464,26465,26466,26467,26468,26469,26470,26471,26472,26473,26474,26475,26476,26477,26478,26479,26480,26481,26482,26483,26484,26485,26486,26487,26488,26489,26490,26491,26492,26493,26494,26495,26496,26497,26498,26499,26500,26501,26502,26503,26504,26505,26506,26507,26508,26509,26510,26511,26512,26513,26514,26515,26516,26517,26518,26519,26520,26521,26522,26523,26524,26525,26526,26527,26528,26529,26530,26531,26532,26533,26534,26535,26536,26537,26538,26539,26540,26541,26542,26543,26544,26545,26546,26547,26548,26549,26550,26551,26552,26553,26554,26555,26556,26557,26558,26559,26560,26561,26562,26563,26564,26565,26566,26567,26568,26569,26570,26571,26572,26573,26574,26575,26576,26577,26578,26579,26580,26581,26582,26583,26584,26585,26586,26587,26588,26589,26590,26591,26592,26593,26594,26595,26596,26597,26598,26599,26600,26601,26602,26603,26604,26605,26606,26607,26608,26609,26610,26611,26612,26613,26614,26615,26616,26617,26618,26619,26620,26621,26622,26623,26624,26625,26626,26627,26628,26629,26630,26631,26632,26633,26634,26635,26636,26637,26638,26639,26640,26641,26642,26643,26644,26645,26646,26647,26648,26649,26650,26651,26652,26653,26654,26655,26656,26657,26658,26659,26660,26661,26662,26663,26664,26665,26666,26667,26668,26669,26670,26671,26672,26673,26674,26675,26676,26677,26678,26679,26680,26681,26682,26683,26684,26685,26686,26687,26688,26689,26690,26691,26692,26693,26694,26695,26696,26697,26698,26699,26700,26701,26702,26703,26704,26705,26706,26707,26708,26709,26710,26711,26712,26713,26714,26715,26716,26717,26718,26719,26720,26721,26722,26723,26724,26725,26726,26727,26728,26729,26730,26731,26732,26733,26734,26735,26736,26737,26738,26739,26740,26741,26742,26743,26744,26745,26746,26747,26748,26749,26750,26751,26752,26753,26754,26755,26756,26757,26758,26759,26760,26761,26762,26763,26764,26765,26766,26767,26768,26769,26770,26771,26772,26773,26774,26775,26776,26777,26778,26779,26780,26781,26782,26783,26784,26785,26786,26787,26788,26789,26790,26791,26792,26793,26794,26795,26796,26797,26798,26799,26800,26801,26802,26803,26804,26805,26806,26807,26808,26809,26810,26811,26812,26813,26814,26815,26816,26817,26818,26819,26820,26821,26822,26823,26824,26825,26826,26827,26828,26829,26830,26831,26832,26833,26834,26835,26836,26837,26838,26839,26840,26841,26842,26843,26844,26845,26846,26847,26848,26849,26850,26851,26852,26853,26854,26855,26856,26857,26858,26859,26860,26861,26862,26863,26864,26865,26866,26867,26868,26869,26870,26871,26872,26873,26874,26875,26876,26877,26878,26879,26880,26881,26882,26883,26884,26885,26886,26887,26888,26889,26890,26891,26892,26893,26894,26895,26896,26897,26898,26899,26900,26901,26902,26903,26904,26905,26906,26907,26908,26909,26910,26911,26912,26913,26914,26915,26916,26917,26918,26919,26920,26921,26922,26923,26924,26925,26926,26927,26928,26929,26930,26931,26932,26933,26934,26935,26936,26937,26938,26939,26940,26941,26942,26943,26944,26945,26946,26947,26948,26949,26950,26951,26952,26953,26954,26955,26956,26957,26958,26959,26960,26961,26962,26963,26964,26965,26966,26967,26968,26969,26970,26971,26972,26973,26974,26975,26976,26977,26978,26979,26980,26981,26982,26983,26984,26985,26986,26987,26988,26989,26990,26991,26992,26993,26994,26995,26996,26997,26998,26999,27000,27001,27002,27003,27004,27005,27006,27007,27008,27009,27010,27011,27012,27013,27014,27015,27016,27017,27018,27019,27020,27021,27022,27023,27024,27025,27026,27027,27028,27029,27030,27031,27032,27033,27034,27035,27036,27037,27038,27039,27040,27041,27042,27043,27044,27045,27046,27047,27048,27049,27050,27051,27052,27053,27054,27055,27056,27057,27058,27059,27060,27061,27062,27063,27064,27065,27066,27067,27068,27069,27070,27071,27072,27073,27074,27075,27076,27077,27078,27079,27080,27081,27082,27083,27084,27085,27086,27087,27088,27089,27090,27091,27092,27093,27094,27095,27096,27097,27098,27099,27100,27101,27102,27103,27104,27105,27106,27107,27108,27109,27110,27111,27112,27113,27114,27115,27116,27117,27118,27119,27120,27121,27122,27123,27124,27125,27126,27127,27128,27129,27130,27131,27132,27133,27134,27135,27136,27137,27138,27139,27140,27141,27142,27143,27144,27145,27146,27147,27148,27149,27150,27151,27152,27153,27154,27155,27156,27157,27158,27159,27160,27161,27162,27163,27164,27165,27166,27167,27168,27169,27170,27171,27172,27173,27174,27175,27176,27177,27178,27179,27180,27181,27182,27183,27184,27185,27186,27187,27188,27189,27190,27191,27192,27193,27194,27195,27196,27197,27198,27199,27200,27201,27202,27203,27204,27205,27206,27207,27208,27209,27210,27211,27212,27213,27214,27215,27216,27217,27218,27219,27220,27221,27222,27223,27224,27225,27226,27227,27228,27229,27230,27231,27232,27233,27234,27235,27236,27237,27238,27239,27240,27241,27242,27243,27244,27245,27246,27247,27248,27249,27250,27251,27252,27253,27254,27255,27256,27257,27258,27259,27260,27261,27262,27263,27264,27265,27266,27267,27268,27269,27270,27271,27272,27273,27274,27275,27276,27277,27278,27279,27280,27281,27282,27283,27284,27285,27286,27287,27288,27289,27290,27291,27292,27293,27294,27295,27296,27297,27298,27299,27300,27301,27302,27303,27304,27305,27306,27307,27308,27309,27310,27311,27312,27313,27314,27315,27316,27317,27318,27319,27320,27321,27322,27323,27324,27325,27326,27327,27328,27329,27330,27331,27332,27333,27334,27335,27336,27337,27338,27339,27340,27341,27342,27343,27344,27345,27346,27347,27348,27349,27350,27351,27352,27353,27354,27355,27356,27357,27358,27359,27360,27361,27362,27363,27364,27365,27366,27367,27368,27369,27370,27371,27372,27373,27374,27375,27376,27377,27378,27379,27380,27381,27382,27383,27384,27385,27386,27387,27388,27389,27390,27391,27392,27393,27394,27395,27396,27397,27398,27399,27400,27401,27402,27403,27404,27405,27406,27407,27408,27409,27410,27411,27412,27413,27414,27415,27416,27417,27418,27419,27420,27421,27422,27423,27424,27425,27426,27427,27428,27429,27430,27431,27432,27433,27434,27435,27436,27437,27438,27439,27440,27441,27442,27443,27444,27445,27446,27447,27448,27449,27450,27451,27452,27453,27454,27455,27456,27457,27458,27459,27460,27461,27462,27463,27464,27465,27466,27467,27468,27469,27470,27471,27472,27473,27474,27475,27476,27477,27478,27479,27480,27481,27482,27483,27484,27485,27486,27487,27488,27489,27490,27491,27492,27493,27494,27495,27496,27497,27498,27499,27500,27501,27502,27503,27504,27505,27506,27507,27508,27509,27510,27511,27512,27513,27514,27515,27516,27517,27518,27519,27520,27521,27522,27523,27524,27525,27526,27527,27528,27529,27530,27531,27532,27533,27534,27535,27536,27537,27538,27539,27540,27541,27542,27543,27544,27545,27546,27547,27548,27549,27550,27551,27552,27553,27554,27555,27556,27557,27558,27559,27560,27561,27562,27563,27564,27565,27566,27567,27568,27569,27570,27571,27572,27573,27574,27575,27576,27577,27578,27579,27580,27581,27582,27583,27584,27585,27586,27587,27588,27589,27590,27591,27592,27593,27594,27595,27596,27597,27598,27599,27600,27601,27602,27603,27604,27605,27606,27607,27608,27609,27610,27611,27612,27613,27614,27615,27616,27617,27618,27619,27620,27621,27622,27623,27624,27625,27626,27627,27628,27629,27630,27631,27632,27633,27634,27635,27636,27637,27638,27639,27640,27641,27642,27643,27644,27645,27646,27647,27648,27649,27650,27651,27652,27653,27654,27655,27656,27657,27658,27659,27660,27661,27662,27663,27664,27665,27666,27667,27668,27669,27670,27671,27672,27673,27674,27675,27676,27677,27678,27679,27680,27681,27682,27683,27684,27685,27686,27687,27688,27689,27690,27691,27692,27693,27694,27695,27696,27697,27698,27699,27700,27701,27702,27703,27704,27705,27706,27707,27708,27709,27710,27711,27712,27713,27714,27715,27716,27717,27718,27719,27720,27721,27722,27723,27724,27725,27726,27727,27728,27729,27730,27731,27732,27733,27734,27735,27736,27737,27738,27739,27740,27741,27742,27743,27744,27745,27746,27747,27748,27749,27750,27751,27752,27753,27754,27755,27756,27757,27758,27759,27760,27761,27762,27763,27764,27765,27766,27767,27768,27769,27770,27771,27772,27773,27774,27775,27776,27777,27778,27779,27780,27781,27782,27783,27784,27785,27786,27787,27788,27789,27790,27791,27792,27793,27794,27795,27796,27797,27798,27799,27800,27801,27802,27803,27804,27805,27806,27807,27808,27809,27810,27811,27812,27813,27814,27815,27816,27817,27818,27819,27820,27821,27822,27823,27824,27825,27826,27827,27828,27829,27830,27831,27832,27833,27834,27835,27836,27837,27838,27839,27840,27841,27842,27843,27844,27845,27846,27847,27848,27849,27850,27851,27852,27853,27854,27855,27856,27857,27858,27859,27860,27861,27862,27863,27864,27865,27866,27867,27868,27869,27870,27871,27872,27873,27874,27875,27876,27877,27878,27879,27880,27881,27882,27883,27884,27885,27886,27887,27888,27889,27890,27891,27892,27893,27894,27895,27896,27897,27898,27899,27900,27901,27902,27903,27904,27905,27906,27907,27908,27909,27910,27911,27912,27913,27914,27915,27916,27917,27918,27919,27920,27921,27922,27923,27924,27925,27926,27927,27928,27929,27930,27931,27932,27933,27934,27935,27936,27937,27938,27939,27940,27941,27942,27943,27944,27945,27946,27947,27948,27949,27950,27951,27952,27953,27954,27955,27956,27957,27958,27959,27960,27961,27962,27963,27964,27965,27966,27967,27968,27969,27970,27971,27972,27973,27974,27975,27976,27977,27978,27979,27980,27981,27982,27983,27984,27985,27986,27987,27988,27989,27990,27991,27992,27993,27994,27995,27996,27997,27998,27999,28000,28001,28002,28003,28004,28005,28006,28007,28008,28009,28010,28011,28012,28013,28014,28015,28016,28017,28018,28019,28020,28021,28022,28023,28024,28025,28026,28027,28028,28029,28030,28031,28032,28033,28034,28035,28036,28037,28038,28039,28040,28041,28042,28043,28044,28045,28046,28047,28048,28049,28050,28051,28052,28053,28054,28055,28056,28057,28058,28059,28060,28061,28062,28063,28064,28065,28066,28067,28068,28069,28070,28071,28072,28073,28074,28075,28076,28077,28078,28079,28080,28081,28082,28083,28084,28085,28086,28087,28088,28089,28090,28091,28092,28093,28094,28095,28096,28097,28098,28099,28100,28101,28102,28103,28104,28105,28106,28107,28108,28109,28110,28111,28112,28113,28114,28115,28116,28117,28118,28119,28120,28121,28122,28123,28124,28125,28126,28127,28128,28129,28130,28131,28132,28133,28134,28135,28136,28137,28138,28139,28140,28141,28142,28143,28144,28145,28146,28147,28148,28149,28150,28151,28152,28153,28154,28155,28156,28157,28158,28159,28160,28161,28162,28163,28164,28165,28166,28167,28168,28169,28170,28171,28172,28173,28174,28175,28176,28177,28178,28179,28180,28181,28182,28183,28184,28185,28186,28187,28188,28189,28190,28191,28192,28193,28194,28195,28196,28197,28198,28199,28200,28201,28202,28203,28204,28205,28206,28207,28208,28209,28210,28211,28212,28213,28214,28215,28216,28217,28218,28219,28220,28221,28222,28223,28224,28225,28226,28227,28228,28229,28230,28231,28232,28233,28234,28235,28236,28237,28238,28239,28240,28241,28242,28243,28244,28245,28246,28247,28248,28249,28250,28251,28252,28253,28254,28255,28256,28257,28258,28259,28260,28261,28262,28263,28264,28265,28266,28267,28268,28269,28270,28271,28272,28273,28274,28275,28276,28277,28278,28279,28280,28281,28282,28283,28284,28285,28286,28287,28288,28289,28290,28291,28292,28293,28294,28295,28296,28297,28298,28299,28300,28301,28302,28303,28304,28305,28306,28307,28308,28309,28310,28311,28312,28313,28314,28315,28316,28317,28318,28319,28320,28321,28322,28323,28324,28325,28326,28327,28328,28329,28330,28331,28332,28333,28334,28335,28336,28337,28338,28339,28340,28341,28342,28343,28344,28345,28346,28347,28348,28349,28350,28351,28352,28353,28354,28355,28356,28357,28358,28359,28360,28361,28362,28363,28364,28365,28366,28367,28368,28369,28370,28371,28372,28373,28374,28375,28376,28377,28378,28379,28380,28381,28382,28383,28384,28385,28386,28387,28388,28389,28390,28391,28392,28393,28394,28395,28396,28397,28398,28399,28400,28401,28402,28403,28404,28405,28406,28407,28408,28409,28410,28411,28412,28413,28414,28415,28416,28417,28418,28419,28420,28421,28422,28423,28424,28425,28426,28427,28428,28429,28430,28431,28432,28433,28434,28435,28436,28437,28438,28439,28440,28441,28442,28443,28444,28445,28446,28447,28448,28449,28450,28451,28452,28453,28454,28455,28456,28457,28458,28459,28460,28461,28462,28463,28464,28465,28466,28467,28468,28469,28470,28471,28472,28473,28474,28475,28476,28477,28478,28479,28480,28481,28482,28483,28484,28485,28486,28487,28488,28489,28490,28491,28492,28493,28494,28495,28496,28497,28498,28499,28500,28501,28502,28503,28504,28505,28506,28507,28508,28509,28510,28511,28512,28513,28514,28515,28516,28517,28518,28519,28520,28521,28522,28523,28524,28525,28526,28527,28528,28529,28530,28531,28532,28533,28534,28535,28536,28537,28538,28539,28540,28541,28542,28543,28544,28545,28546,28547,28548,28549,28550,28551,28552,28553,28554,28555,28556,28557,28558,28559,28560,28561,28562,28563,28564,28565,28566,28567,28568,28569,28570,28571,28572,28573,28574,28575,28576,28577,28578,28579,28580,28581,28582,28583,28584,28585,28586,28587,28588,28589,28590,28591,28592,28593,28594,28595,28596,28597,28598,28599,28600,28601,28602,28603,28604,28605,28606,28607,28608,28609,28610,28611,28612,28613,28614,28615,28616,28617,28618,28619,28620,28621,28622,28623,28624,28625,28626,28627,28628,28629,28630,28631,28632,28633,28634,28635,28636,28637,28638,28639,28640,28641,28642,28643,28644,28645,28646,28647,28648,28649,28650,28651,28652,28653,28654,28655,28656,28657,28658,28659,28660,28661,28662,28663,28664,28665,28666,28667,28668,28669,28670,28671,28672,28673,28674,28675,28676,28677,28678,28679,28680,28681,28682,28683,28684,28685,28686,28687,28688,28689,28690,28691,28692,28693,28694,28695,28696,28697,28698,28699,28700,28701,28702,28703,28704,28705,28706,28707,28708,28709,28710,28711,28712,28713,28714,28715,28716,28717,28718,28719,28720,28721,28722,28723,28724,28725,28726,28727,28728,28729,28730,28731,28732,28733,28734,28735,28736,28737,28738,28739,28740,28741,28742,28743,28744,28745,28746,28747,28748,28749,28750,28751,28752,28753,28754,28755,28756,28757,28758,28759,28760,28761,28762,28763,28764,28765,28766,28767,28768,28769,28770,28771,28772,28773,28774,28775,28776,28777,28778,28779,28780,28781,28782,28783,28784,28785,28786,28787,28788,28789,28790,28791,28792,28793,28794,28795,28796,28797,28798,28799,28800,28801,28802,28803,28804,28805,28806,28807,28808,28809,28810,28811,28812,28813,28814,28815,28816,28817,28818,28819,28820,28821,28822,28823,28824,28825,28826,28827,28828,28829,28830,28831,28832,28833,28834,28835,28836,28837,28838,28839,28840,28841,28842,28843,28844,28845,28846,28847,28848,28849,28850,28851,28852,28853,28854,28855,28856,28857,28858,28859,28860,28861,28862,28863,28864,28865,28866,28867,28868,28869,28870,28871,28872,28873,28874,28875,28876,28877,28878,28879,28880,28881,28882,28883,28884,28885,28886,28887,28888,28889,28890,28891,28892,28893,28894,28895,28896,28897,28898,28899,28900,28901,28902,28903,28904,28905,28906,28907,28908,28909,28910,28911,28912,28913,28914,28915,28916,28917,28918,28919,28920,28921,28922,28923,28924,28925,28926,28927,28928,28929,28930,28931,28932,28933,28934,28935,28936,28937,28938,28939,28940,28941,28942,28943,28944,28945,28946,28947,28948,28949,28950,28951,28952,28953,28954,28955,28956,28957,28958,28959,28960,28961,28962,28963,28964,28965,28966,28967,28968,28969,28970,28971,28972,28973,28974,28975,28976,28977,28978,28979,28980,28981,28982,28983,28984,28985,28986,28987,28988,28989,28990,28991,28992,28993,28994,28995,28996,28997,28998,28999,29000,29001,29002,29003,29004,29005,29006,29007,29008,29009,29010,29011,29012,29013,29014,29015,29016,29017,29018,29019,29020,29021,29022,29023,29024,29025,29026,29027,29028,29029,29030,29031,29032,29033,29034,29035,29036,29037,29038,29039,29040,29041,29042,29043,29044,29045,29046,29047,29048,29049,29050,29051,29052,29053,29054,29055,29056,29057,29058,29059,29060,29061,29062,29063,29064,29065,29066,29067,29068,29069,29070,29071,29072,29073,29074,29075,29076,29077,29078,29079,29080,29081,29082,29083,29084,29085,29086,29087,29088,29089,29090,29091,29092,29093,29094,29095,29096,29097,29098,29099,29100,29101,29102,29103,29104,29105,29106,29107,29108,29109,29110,29111,29112,29113,29114,29115,29116,29117,29118,29119,29120,29121,29122,29123,29124,29125,29126,29127,29128,29129,29130,29131,29132,29133,29134,29135,29136,29137,29138,29139,29140,29141,29142,29143,29144,29145,29146,29147,29148,29149,29150,29151,29152,29153,29154,29155,29156,29157,29158,29159,29160,29161,29162,29163,29164,29165,29166,29167,29168,29169,29170,29171,29172,29173,29174,29175,29176,29177,29178,29179,29180,29181,29182,29183,29184,29185,29186,29187,29188,29189,29190,29191,29192,29193,29194,29195,29196,29197,29198,29199,29200,29201,29202,29203,29204,29205,29206,29207,29208,29209,29210,29211,29212,29213,29214,29215,29216,29217,29218,29219,29220,29221,29222,29223,29224,29225,29226,29227,29228,29229,29230,29231,29232,29233,29234,29235,29236,29237,29238,29239,29240,29241,29242,29243,29244,29245,29246,29247,29248,29249,29250,29251,29252,29253,29254,29255,29256,29257,29258,29259,29260,29261,29262,29263,29264,29265,29266,29267,29268,29269,29270,29271,29272,29273,29274,29275,29276,29277,29278,29279,29280,29281,29282,29283,29284,29285,29286,29287,29288,29289,29290,29291,29292,29293,29294,29295,29296,29297,29298,29299,29300,29301,29302,29303,29304,29305,29306,29307,29308,29309,29310,29311,29312,29313,29314,29315,29316,29317,29318,29319,29320,29321,29322,29323,29324,29325,29326,29327,29328,29329,29330,29331,29332,29333,29334,29335,29336,29337,29338,29339,29340,29341,29342,29343,29344,29345,29346,29347,29348,29349,29350,29351,29352,29353,29354,29355,29356,29357,29358,29359,29360,29361,29362,29363,29364,29365,29366,29367,29368,29369,29370,29371,29372,29373,29374,29375,29376,29377,29378,29379,29380,29381,29382,29383,29384,29385,29386,29387,29388,29389,29390,29391,29392,29393,29394,29395,29396,29397,29398,29399,29400,29401,29402,29403,29404,29405,29406,29407,29408,29409,29410,29411,29412,29413,29414,29415,29416,29417,29418,29419,29420,29421,29422,29423,29424,29425,29426,29427,29428,29429,29430,29431,29432,29433,29434,29435,29436,29437,29438,29439,29440,29441,29442,29443,29444,29445,29446,29447,29448,29449,29450,29451,29452,29453,29454,29455,29456,29457,29458,29459,29460,29461,29462,29463,29464,29465,29466,29467,29468,29469,29470,29471,29472,29473,29474,29475,29476,29477,29478,29479,29480,29481,29482,29483,29484,29485,29486,29487,29488,29489,29490,29491,29492,29493,29494,29495,29496,29497,29498,29499,29500,29501,29502,29503,29504,29505,29506,29507,29508,29509,29510,29511,29512,29513,29514,29515,29516,29517,29518,29519,29520,29521,29522,29523,29524,29525,29526,29527,29528,29529,29530,29531,29532,29533,29534,29535,29536,29537,29538,29539,29540,29541,29542,29543,29544,29545,29546,29547,29548,29549,29550,29551,29552,29553,29554,29555,29556,29557,29558,29559,29560,29561,29562,29563,29564,29565,29566,29567,29568,29569,29570,29571,29572,29573,29574,29575,29576,29577,29578,29579,29580,29581,29582,29583,29584,29585,29586,29587,29588,29589,29590,29591,29592,29593,29594,29595,29596,29597,29598,29599,29600,29601,29602,29603,29604,29605,29606,29607,29608,29609,29610,29611,29612,29613,29614,29615,29616,29617,29618,29619,29620,29621,29622,29623,29624,29625,29626,29627,29628,29629,29630,29631,29632,29633,29634,29635,29636,29637,29638,29639,29640,29641,29642,29643,29644,29645,29646,29647,29648,29649,29650,29651,29652,29653,29654,29655,29656,29657,29658,29659,29660,29661,29662,29663,29664,29665,29666,29667,29668,29669,29670,29671,29672,29673,29674,29675,29676,29677,29678,29679,29680,29681,29682,29683,29684,29685,29686,29687,29688,29689,29690,29691,29692,29693,29694,29695,29696,29697,29698,29699,29700,29701,29702,29703,29704,29705,29706,29707,29708,29709,29710,29711,29712,29713,29714,29715,29716,29717,29718,29719,29720,29721,29722,29723,29724,29725,29726,29727,29728,29729,29730,29731,29732,29733,29734,29735,29736,29737,29738,29739,29740,29741,29742,29743,29744,29745,29746,29747,29748,29749,29750,29751,29752,29753,29754,29755,29756,29757,29758,29759,29760,29761,29762,29763,29764,29765,29766,29767,29768,29769,29770,29771,29772,29773,29774,29775,29776,29777,29778,29779,29780,29781,29782,29783,29784,29785,29786,29787,29788,29789,29790,29791,29792,29793,29794,29795,29796,29797,29798,29799,29800,29801,29802,29803,29804,29805,29806,29807,29808,29809,29810,29811,29812,29813,29814,29815,29816,29817,29818,29819,29820,29821,29822,29823,29824,29825,29826,29827,29828,29829,29830,29831,29832,29833,29834,29835,29836,29837,29838,29839,29840,29841,29842,29843,29844,29845,29846,29847,29848,29849,29850,29851,29852,29853,29854,29855,29856,29857,29858,29859,29860,29861,29862,29863,29864,29865,29866,29867,29868,29869,29870,29871,29872,29873,29874,29875,29876,29877,29878,29879,29880,29881,29882,29883,29884,29885,29886,29887,29888,29889,29890,29891,29892,29893,29894,29895,29896,29897,29898,29899,29900,29901,29902,29903,29904,29905,29906,29907,29908,29909,29910,29911,29912,29913,29914,29915,29916,29917,29918,29919,29920,29921,29922,29923,29924,29925,29926,29927,29928,29929,29930,29931,29932,29933,29934,29935,29936,29937,29938,29939,29940,29941,29942,29943,29944,29945,29946,29947,29948,29949,29950,29951,29952,29953,29954,29955,29956,29957,29958,29959,29960,29961,29962,29963,29964,29965,29966,29967,29968,29969,29970,29971,29972,29973,29974,29975,29976,29977,29978,29979,29980,29981,29982,29983,29984,29985,29986,29987,29988,29989,29990,29991,29992,29993,29994,29995,29996,29997,29998,29999,30000,30001,30002,30003,30004,30005,30006,30007,30008,30009,30010,30011,30012,30013,30014,30015,30016,30017,30018,30019,30020,30021,30022,30023,30024,30025,30026,30027,30028,30029,30030,30031,30032,30033,30034,30035,30036,30037,30038,30039,30040,30041,30042,30043,30044,30045,30046,30047,30048,30049,30050,30051,30052,30053,30054,30055,30056,30057,30058,30059,30060,30061,30062,30063,30064,30065,30066,30067,30068,30069,30070,30071,30072,30073,30074,30075,30076,30077,30078,30079,30080,30081,30082,30083,30084,30085,30086,30087,30088,30089,30090,30091,30092,30093,30094,30095,30096,30097,30098,30099,30100,30101,30102,30103,30104,30105,30106,30107,30108,30109,30110,30111,30112,30113,30114,30115,30116,30117,30118,30119,30120,30121,30122,30123,30124,30125,30126,30127,30128,30129,30130,30131,30132,30133,30134,30135,30136,30137,30138,30139,30140,30141,30142,30143,30144,30145,30146,30147,30148,30149,30150,30151,30152,30153,30154,30155,30156,30157,30158,30159,30160,30161,30162,30163,30164,30165,30166,30167,30168,30169,30170,30171,30172,30173,30174,30175,30176,30177,30178,30179,30180,30181,30182,30183,30184,30185,30186,30187,30188,30189,30190,30191,30192,30193,30194,30195,30196,30197,30198,30199,30200,30201,30202,30203,30204,30205,30206,30207,30208,30209,30210,30211,30212,30213,30214,30215,30216,30217,30218,30219,30220,30221,30222,30223,30224,30225,30226,30227,30228,30229,30230,30231,30232,30233,30234,30235,30236,30237,30238,30239,30240,30241,30242,30243,30244,30245,30246,30247,30248,30249,30250,30251,30252,30253,30254,30255,30256,30257,30258,30259,30260,30261,30262,30263,30264,30265,30266,30267,30268,30269,30270,30271,30272,30273,30274,30275,30276,30277,30278,30279,30280,30281,30282,30283,30284,30285,30286,30287,30288,30289,30290,30291,30292,30293,30294,30295,30296,30297,30298,30299,30300,30301,30302,30303,30304,30305,30306,30307,30308,30309,30310,30311,30312,30313,30314,30315,30316,30317,30318,30319,30320,30321,30322,30323,30324,30325,30326,30327,30328,30329,30330,30331,30332,30333,30334,30335,30336,30337,30338,30339,30340,30341,30342,30343,30344,30345,30346,30347,30348,30349,30350,30351,30352,30353,30354,30355,30356,30357,30358,30359,30360,30361,30362,30363,30364,30365,30366,30367,30368,30369,30370,30371,30372,30373,30374,30375,30376,30377,30378,30379,30380,30381,30382,30383,30384,30385,30386,30387,30388,30389,30390,30391,30392,30393,30394,30395,30396,30397,30398,30399,30400,30401,30402,30403,30404,30405,30406,30407,30408,30409,30410,30411,30412,30413,30414,30415,30416,30417,30418,30419,30420,30421,30422,30423,30424,30425,30426,30427,30428,30429,30430,30431,30432,30433,30434,30435,30436,30437,30438,30439,30440,30441,30442,30443,30444,30445,30446,30447,30448,30449,30450,30451,30452,30453,30454,30455,30456,30457,30458,30459,30460,30461,30462,30463,30464,30465,30466,30467,30468,30469,30470,30471,30472,30473,30474,30475,30476,30477,30478,30479,30480,30481,30482,30483,30484,30485,30486,30487,30488,30489,30490,30491,30492,30493,30494,30495,30496,30497,30498,30499,30500,30501,30502,30503,30504,30505,30506,30507,30508,30509,30510,30511,30512,30513,30514,30515,30516,30517,30518,30519,30520,30521,30522,30523,30524,30525,30526,30527,30528,30529,30530,30531,30532,30533,30534,30535,30536,30537,30538,30539,30540,30541,30542,30543,30544,30545,30546,30547,30548,30549,30550,30551,30552,30553,30554,30555,30556,30557,30558,30559,30560,30561,30562,30563,30564,30565,30566,30567,30568,30569,30570,30571,30572,30573,30574,30575,30576,30577,30578,30579,30580,30581,30582,30583,30584,30585,30586,30587,30588,30589,30590,30591,30592,30593,30594,30595,30596,30597,30598,30599,30600,30601,30602,30603,30604,30605,30606,30607,30608,30609,30610,30611,30612,30613,30614,30615,30616,30617,30618,30619,30620,30621,30622,30623,30624,30625,30626,30627,30628,30629,30630,30631,30632,30633,30634,30635,30636,30637,30638,30639,30640,30641,30642,30643,30644,30645,30646,30647,30648,30649,30650,30651,30652,30653,30654,30655,30656,30657,30658,30659,30660,30661,30662,30663,30664,30665,30666,30667,30668,30669,30670,30671,30672,30673,30674,30675,30676,30677,30678,30679,30680,30681,30682,30683,30684,30685,30686,30687,30688,30689,30690,30691,30692,30693,30694,30695,30696,30697,30698,30699,30700,30701,30702,30703,30704,30705,30706,30707,30708,30709,30710,30711,30712,30713,30714,30715,30716,30717,30718,30719,30720,30721,30722,30723,30724,30725,30726,30727,30728,30729,30730,30731,30732,30733,30734,30735,30736,30737,30738,30739,30740,30741,30742,30743,30744,30745,30746,30747,30748,30749,30750,30751,30752,30753,30754,30755,30756,30757,30758,30759,30760,30761,30762,30763,30764,30765,30766,30767,30768,30769,30770,30771,30772,30773,30774,30775,30776,30777,30778,30779,30780,30781,30782,30783,30784,30785,30786,30787,30788,30789,30790,30791,30792,30793,30794,30795,30796,30797,30798,30799,30800,30801,30802,30803,30804,30805,30806,30807,30808,30809,30810,30811,30812,30813,30814,30815,30816,30817,30818,30819,30820,30821,30822,30823,30824,30825,30826,30827,30828,30829,30830,30831,30832,30833,30834,30835,30836,30837,30838,30839,30840,30841,30842,30843,30844,30845,30846,30847,30848,30849,30850,30851,30852,30853,30854,30855,30856,30857,30858,30859,30860,30861,30862,30863,30864,30865,30866,30867,30868,30869,30870,30871,30872,30873,30874,30875,30876,30877,30878,30879,30880,30881,30882,30883,30884,30885,30886,30887,30888,30889,30890,30891,30892,30893,30894,30895,30896,30897,30898,30899,30900,30901,30902,30903,30904,30905,30906,30907,30908,30909,30910,30911,30912,30913,30914,30915,30916,30917,30918,30919,30920,30921,30922,30923,30924,30925,30926,30927,30928,30929,30930,30931,30932,30933,30934,30935,30936,30937,30938,30939,30940,30941,30942,30943,30944,30945,30946,30947,30948,30949,30950,30951,30952,30953,30954,30955,30956,30957,30958,30959,30960,30961,30962,30963,30964,30965,30966,30967,30968,30969,30970,30971,30972,30973,30974,30975,30976,30977,30978,30979,30980,30981,30982,30983,30984,30985,30986,30987,30988,30989,30990,30991,30992,30993,30994,30995,30996,30997,30998,30999,31000,31001,31002,31003,31004,31005,31006,31007,31008,31009,31010,31011,31012,31013,31014,31015,31016,31017,31018,31019,31020,31021,31022,31023,31024,31025,31026,31027,31028,31029,31030,31031,31032,31033,31034,31035,31036,31037,31038,31039,31040,31041,31042,31043,31044,31045,31046,31047,31048,31049,31050,31051,31052,31053,31054,31055,31056,31057,31058,31059,31060,31061,31062,31063,31064,31065,31066,31067,31068,31069,31070,31071,31072,31073,31074,31075,31076,31077,31078,31079,31080,31081,31082,31083,31084,31085,31086,31087,31088,31089,31090,31091,31092,31093,31094,31095,31096,31097,31098,31099,31100,31101,31102,31103,31104,31105,31106,31107,31108,31109,31110,31111,31112,31113,31114,31115,31116,31117,31118,31119,31120,31121,31122,31123,31124,31125,31126,31127,31128,31129,31130,31131,31132,31133,31134,31135,31136,31137,31138,31139,31140,31141,31142,31143,31144,31145,31146,31147,31148,31149,31150,31151,31152,31153,31154,31155,31156,31157,31158,31159,31160,31161,31162,31163,31164,31165,31166,31167,31168,31169,31170,31171,31172,31173,31174,31175,31176,31177,31178,31179,31180,31181,31182,31183,31184,31185,31186,31187,31188,31189,31190,31191,31192,31193,31194,31195,31196,31197,31198,31199,31200,31201,31202,31203,31204,31205,31206,31207,31208,31209,31210,31211,31212,31213,31214,31215,31216,31217,31218,31219,31220,31221,31222,31223,31224,31225,31226,31227,31228,31229,31230,31231,31232,31233,31234,31235,31236,31237,31238,31239,31240,31241,31242,31243,31244,31245,31246,31247,31248,31249,31250,31251,31252,31253,31254,31255,31256,31257,31258,31259,31260,31261,31262,31263,31264,31265,31266,31267,31268,31269,31270,31271,31272,31273,31274,31275,31276,31277,31278,31279,31280,31281,31282,31283,31284,31285,31286,31287,31288,31289,31290,31291,31292,31293,31294,31295,31296,31297,31298,31299,31300,31301,31302,31303,31304,31305,31306,31307,31308,31309,31310,31311,31312,31313,31314,31315,31316,31317,31318,31319,31320,31321,31322,31323,31324,31325,31326,31327,31328,31329,31330,31331,31332,31333,31334,31335,31336,31337,31338,31339,31340,31341,31342,31343,31344,31345,31346,31347,31348,31349,31350,31351,31352,31353,31354,31355,31356,31357,31358,31359,31360,31361,31362,31363,31364,31365,31366,31367,31368,31369,31370,31371,31372,31373,31374,31375,31376,31377,31378,31379,31380,31381,31382,31383,31384,31385,31386,31387,31388,31389,31390,31391,31392,31393,31394,31395,31396,31397,31398,31399,31400,31401,31402,31403,31404,31405,31406,31407,31408,31409,31410,31411,31412,31413,31414,31415,31416,31417,31418,31419,31420,31421,31422,31423,31424,31425,31426,31427,31428,31429,31430,31431,31432,31433,31434,31435,31436,31437,31438,31439,31440,31441,31442,31443,31444,31445,31446,31447,31448,31449,31450,31451,31452,31453,31454,31455,31456,31457,31458,31459,31460,31461,31462,31463,31464,31465,31466,31467,31468,31469,31470,31471,31472,31473,31474,31475,31476,31477,31478,31479,31480,31481,31482,31483,31484,31485,31486,31487,31488,31489,31490,31491,31492,31493,31494,31495,31496,31497,31498,31499,31500,31501,31502,31503,31504,31505,31506,31507,31508,31509,31510,31511,31512,31513,31514,31515,31516,31517,31518,31519,31520,31521,31522,31523,31524,31525,31526,31527,31528,31529,31530,31531,31532,31533,31534,31535,31536,31537,31538,31539,31540,31541,31542,31543,31544,31545,31546,31547,31548,31549,31550,31551,31552,31553,31554,31555,31556,31557,31558,31559,31560,31561,31562,31563,31564,31565,31566,31567,31568,31569,31570,31571,31572,31573,31574,31575,31576,31577,31578,31579,31580,31581,31582,31583,31584,31585,31586,31587,31588,31589,31590,31591,31592,31593,31594,31595,31596,31597,31598,31599,31600,31601,31602,31603,31604,31605,31606,31607,31608,31609,31610,31611,31612,31613,31614,31615,31616,31617,31618,31619,31620,31621,31622,31623,31624,31625,31626,31627,31628,31629,31630,31631,31632,31633,31634,31635,31636,31637,31638,31639,31640,31641,31642,31643,31644,31645,31646,31647,31648,31649,31650,31651,31652,31653,31654,31655,31656,31657,31658,31659,31660,31661,31662,31663,31664,31665,31666,31667,31668,31669,31670,31671,31672,31673,31674,31675,31676,31677,31678,31679,31680,31681,31682,31683,31684,31685,31686,31687,31688,31689,31690,31691,31692,31693,31694,31695,31696,31697,31698,31699,31700,31701,31702,31703,31704,31705,31706,31707,31708,31709,31710,31711,31712,31713,31714,31715,31716,31717,31718,31719,31720,31721,31722,31723,31724,31725,31726,31727,31728,31729,31730,31731,31732,31733,31734,31735,31736,31737,31738,31739,31740,31741,31742,31743,31744,31745,31746,31747,31748,31749,31750,31751,31752,31753,31754,31755,31756,31757,31758,31759,31760,31761,31762,31763,31764,31765,31766,31767,31768,31769,31770,31771,31772,31773,31774,31775,31776,31777,31778,31779,31780,31781,31782,31783,31784,31785,31786,31787,31788,31789,31790,31791,31792,31793,31794,31795,31796,31797,31798,31799,31800,31801,31802,31803,31804,31805,31806,31807,31808,31809,31810,31811,31812,31813,31814,31815,31816,31817,31818,31819,31820,31821,31822,31823,31824,31825,31826,31827,31828,31829,31830,31831,31832,31833,31834,31835,31836,31837,31838,31839,31840,31841,31842,31843,31844,31845,31846,31847,31848,31849,31850,31851,31852,31853,31854,31855,31856,31857,31858,31859,31860,31861,31862,31863,31864,31865,31866,31867,31868,31869,31870,31871,31872,31873,31874,31875,31876,31877,31878,31879,31880,31881,31882,31883,31884,31885,31886,31887,31888,31889,31890,31891,31892,31893,31894,31895,31896,31897,31898,31899,31900,31901,31902,31903,31904,31905,31906,31907,31908,31909,31910,31911,31912,31913,31914,31915,31916,31917,31918,31919,31920,31921,31922,31923,31924,31925,31926,31927,31928,31929,31930,31931,31932,31933,31934,31935,31936,31937,31938,31939,31940,31941,31942,31943,31944,31945,31946,31947,31948,31949,31950,31951,31952,31953,31954,31955,31956,31957,31958,31959,31960,31961,31962,31963,31964,31965,31966,31967,31968,31969,31970,31971,31972,31973,31974,31975,31976,31977,31978,31979,31980,31981,31982,31983,31984,31985,31986,31987,31988,31989,31990,31991,31992,31993,31994,31995,31996,31997,31998,31999,32000,32001,32002,32003,32004,32005,32006,32007,32008,32009,32010,32011,32012,32013,32014,32015,32016,32017,32018,32019,32020,32021,32022,32023,32024,32025,32026,32027,32028,32029,32030,32031,32032,32033,32034,32035,32036,32037,32038,32039,32040,32041,32042,32043,32044,32045,32046,32047,32048,32049,32050,32051,32052,32053,32054,32055,32056,32057,32058,32059,32060,32061,32062,32063,32064,32065,32066,32067,32068,32069,32070,32071,32072,32073,32074,32075,32076,32077,32078,32079,32080,32081,32082,32083,32084,32085,32086,32087,32088,32089,32090,32091,32092,32093,32094,32095,32096,32097,32098,32099,32100,32101,32102,32103,32104,32105,32106,32107,32108,32109,32110,32111,32112,32113,32114,32115,32116,32117,32118,32119,32120,32121,32122,32123,32124,32125,32126,32127,32128,32129,32130,32131,32132,32133,32134,32135,32136,32137,32138,32139,32140,32141,32142,32143,32144,32145,32146,32147,32148,32149,32150,32151,32152,32153,32154,32155,32156,32157,32158,32159,32160,32161,32162,32163,32164,32165,32166,32167,32168,32169,32170,32171,32172,32173,32174,32175,32176,32177,32178,32179,32180,32181,32182,32183,32184,32185,32186,32187,32188,32189,32190,32191,32192,32193,32194,32195,32196,32197,32198,32199,32200,32201,32202,32203,32204,32205,32206,32207,32208,32209,32210,32211,32212,32213,32214,32215,32216,32217,32218,32219,32220,32221,32222,32223,32224,32225,32226,32227,32228,32229,32230,32231,32232,32233,32234,32235,32236,32237,32238,32239,32240,32241,32242,32243,32244,32245,32246,32247,32248,32249,32250,32251,32252,32253,32254,32255,32256,32257,32258,32259,32260,32261,32262,32263,32264,32265,32266,32267,32268,32269,32270,32271,32272,32273,32274,32275,32276,32277,32278,32279,32280,32281,32282,32283,32284,32285,32286,32287,32288,32289,32290,32291,32292,32293,32294,32295,32296,32297,32298,32299,32300,32301,32302,32303,32304,32305,32306,32307,32308,32309,32310,32311,32312,32313,32314,32315,32316,32317,32318,32319,32320,32321,32322,32323,32324,32325,32326,32327,32328,32329,32330,32331,32332,32333,32334,32335,32336,32337,32338,32339,32340,32341,32342,32343,32344,32345,32346,32347,32348,32349,32350,32351,32352,32353,32354,32355,32356,32357,32358,32359,32360,32361,32362,32363,32364,32365,32366,32367,32368,32369,32370,32371,32372,32373,32374,32375,32376,32377,32378,32379,32380,32381,32382,32383,32384,32385,32386,32387,32388,32389,32390,32391,32392,32393,32394,32395,32396,32397,32398,32399,32400,32401,32402,32403,32404,32405,32406,32407,32408,32409,32410,32411,32412,32413,32414,32415,32416,32417,32418,32419,32420,32421,32422,32423,32424,32425,32426,32427,32428,32429,32430,32431,32432,32433,32434,32435,32436,32437,32438,32439,32440,32441,32442,32443,32444,32445,32446,32447,32448,32449,32450,32451,32452,32453,32454,32455,32456,32457,32458,32459,32460,32461,32462,32463,32464,32465,32466,32467,32468,32469,32470,32471,32472,32473,32474,32475,32476,32477,32478,32479,32480,32481,32482,32483,32484,32485,32486,32487,32488,32489,32490,32491,32492,32493,32494,32495,32496,32497,32498,32499,32500,32501,32502,32503,32504,32505,32506,32507,32508,32509,32510,32511,32512,32513,32514,32515,32516,32517,32518,32519,32520,32521,32522,32523,32524,32525,32526,32527,32528,32529,32530,32531,32532,32533,32534,32535,32536,32537,32538,32539,32540,32541,32542,32543,32544,32545,32546,32547,32548,32549,32550,32551,32552,32553,32554,32555,32556,32557,32558,32559,32560,32561,32562,32563,32564,32565,32566,32567,32568,32569,32570,32571,32572,32573,32574,32575,32576,32577,32578,32579,32580,32581,32582,32583,32584,32585,32586,32587,32588,32589,32590,32591,32592,32593,32594,32595,32596,32597,32598,32599,32600,32601,32602,32603,32604,32605,32606,32607,32608,32609,32610,32611,32612,32613,32614,32615,32616,32617,32618,32619,32620,32621,32622,32623,32624,32625,32626,32627,32628,32629,32630,32631,32632,32633,32634,32635,32636,32637,32638,32639,32640,32641,32642,32643,32644,32645,32646,32647,32648,32649,32650,32651,32652,32653,32654,32655,32656,32657,32658,32659,32660,32661,32662,32663,32664,32665,32666,32667,32668,32669,32670,32671,32672,32673,32674,32675,32676,32677,32678,32679,32680,32681,32682,32683,32684,32685,32686,32687,32688,32689,32690,32691,32692,32693,32694,32695,32696,32697,32698,32699,32700,32701,32702,32703,32704,32705,32706,32707,32708,32709,32710,32711,32712,32713,32714,32715,32716,32717,32718,32719,32720,32721,32722,32723,32724,32725,32726,32727,32728,32729,32730,32731,32732,32733,32734,32735,32736,32737,32738,32739,32740,32741,32742,32743,32744,32745,32746,32747,32748,32749,32750,32751,32752,32753,32754,32755,32756,32757,32758,32759,32760,32761,32762,32763,32764,32765,32766,32767,32768,32769,32770,32771,32772,32773,32774,32775,32776,32777,32778,32779,32780,32781,32782,32783,32784,32785,32786,32787,32788,32789,32790,32791,32792,32793,32794,32795,32796,32797,32798,32799,32800,32801,32802,32803,32804,32805,32806,32807,32808,32809,32810,32811,32812,32813,32814,32815,32816,32817,32818,32819,32820,32821,32822,32823,32824,32825,32826,32827,32828,32829,32830,32831,32832,32833,32834,32835,32836,32837,32838,32839,32840,32841,32842,32843,32844,32845,32846,32847,32848,32849,32850,32851,32852,32853,32854,32855,32856,32857,32858,32859,32860,32861,32862,32863,32864,32865,32866,32867,32868,32869,32870,32871,32872,32873,32874,32875,32876,32877,32878,32879,32880,32881,32882,32883,32884,32885,32886,32887,32888,32889,32890,32891,32892,32893,32894,32895,32896,32897,32898,32899,32900,32901,32902,32903,32904,32905,32906,32907,32908,32909,32910,32911,32912,32913,32914,32915,32916,32917,32918,32919,32920,32921,32922,32923,32924,32925,32926,32927,32928,32929,32930,32931,32932,32933,32934,32935,32936,32937,32938,32939,32940,32941,32942,32943,32944,32945,32946,32947,32948,32949,32950,32951,32952,32953,32954,32955,32956,32957,32958,32959,32960,32961,32962,32963,32964,32965,32966,32967,32968,32969,32970,32971,32972,32973,32974,32975,32976,32977,32978,32979,32980,32981,32982,32983,32984,32985,32986,32987,32988,32989,32990,32991,32992,32993,32994,32995,32996,32997,32998,32999,33000,33001,33002,33003,33004,33005,33006,33007,33008,33009,33010,33011,33012,33013,33014,33015,33016,33017,33018,33019,33020,33021,33022,33023,33024,33025,33026,33027,33028,33029,33030,33031,33032,33033,33034,33035,33036,33037,33038,33039,33040,33041,33042,33043,33044,33045,33046,33047,33048,33049,33050,33051,33052,33053,33054,33055,33056,33057,33058,33059,33060,33061,33062,33063,33064,33065,33066,33067,33068,33069,33070,33071,33072,33073,33074,33075,33076,33077,33078,33079,33080,33081,33082,33083,33084,33085,33086,33087,33088,33089,33090,33091,33092,33093,33094,33095,33096,33097,33098,33099,33100,33101,33102,33103,33104,33105,33106,33107,33108,33109,33110,33111,33112,33113,33114,33115,33116,33117,33118,33119,33120,33121,33122,33123,33124,33125,33126,33127,33128,33129,33130,33131,33132,33133,33134,33135,33136,33137,33138,33139,33140,33141,33142,33143,33144,33145,33146,33147,33148,33149,33150,33151,33152,33153,33154,33155,33156,33157,33158,33159,33160,33161,33162,33163,33164,33165,33166,33167,33168,33169,33170,33171,33172,33173,33174,33175,33176,33177,33178,33179,33180,33181,33182,33183,33184,33185,33186,33187,33188,33189,33190,33191,33192,33193,33194,33195,33196,33197,33198,33199,33200,33201,33202,33203,33204,33205,33206,33207,33208,33209,33210,33211,33212,33213,33214,33215,33216,33217,33218,33219,33220,33221,33222,33223,33224,33225,33226,33227,33228,33229,33230,33231,33232,33233,33234,33235,33236,33237,33238,33239,33240,33241,33242,33243,33244,33245,33246,33247,33248,33249,33250,33251,33252,33253,33254,33255,33256,33257,33258,33259,33260,33261,33262,33263,33264,33265,33266,33267,33268,33269,33270,33271,33272,33273,33274,33275,33276,33277,33278,33279,33280,33281,33282,33283,33284,33285,33286,33287,33288,33289,33290,33291,33292,33293,33294,33295,33296,33297,33298,33299,33300,33301,33302,33303,33304,33305,33306,33307,33308,33309,33310,33311,33312,33313,33314,33315,33316,33317,33318,33319,33320,33321,33322,33323,33324,33325,33326,33327,33328,33329,33330,33331,33332,33333,33334,33335,33336,33337,33338,33339,33340,33341,33342,33343,33344,33345,33346,33347,33348,33349,33350,33351,33352,33353,33354,33355,33356,33357,33358,33359,33360,33361,33362,33363,33364,33365,33366,33367,33368,33369,33370,33371,33372,33373,33374,33375,33376,33377,33378,33379,33380,33381,33382,33383,33384,33385,33386,33387,33388,33389,33390,33391,33392,33393,33394,33395,33396,33397,33398,33399,33400,33401,33402,33403,33404,33405,33406,33407,33408,33409,33410,33411,33412,33413,33414,33415,33416,33417,33418,33419,33420,33421,33422,33423,33424,33425,33426,33427,33428,33429,33430,33431,33432,33433,33434,33435,33436,33437,33438,33439,33440,33441,33442,33443,33444,33445,33446,33447,33448,33449,33450,33451,33452,33453,33454,33455,33456,33457,33458,33459,33460,33461,33462,33463,33464,33465,33466,33467,33468,33469,33470,33471,33472,33473,33474,33475,33476,33477,33478,33479,33480,33481,33482,33483,33484,33485,33486,33487,33488,33489,33490,33491,33492,33493,33494,33495,33496,33497,33498,33499,33500,33501,33502,33503,33504,33505,33506,33507,33508,33509,33510,33511,33512,33513,33514,33515,33516,33517,33518,33519,33520,33521,33522,33523,33524,33525,33526,33527,33528,33529,33530,33531,33532,33533,33534,33535,33536,33537,33538,33539,33540,33541,33542,33543,33544,33545,33546,33547,33548,33549,33550,33551,33552,33553,33554,33555,33556,33557,33558,33559,33560,33561,33562,33563,33564,33565,33566,33567,33568,33569,33570,33571,33572,33573,33574,33575,33576,33577,33578,33579,33580,33581,33582,33583,33584,33585,33586,33587,33588,33589,33590,33591,33592,33593,33594,33595,33596,33597,33598,33599,33600,33601,33602,33603,33604,33605,33606,33607,33608,33609,33610,33611,33612,33613,33614,33615,33616,33617,33618,33619,33620,33621,33622,33623,33624,33625,33626,33627,33628,33629,33630,33631,33632,33633,33634,33635,33636,33637,33638,33639,33640,33641,33642,33643,33644,33645,33646,33647,33648,33649,33650,33651,33652,33653,33654,33655,33656,33657,33658,33659,33660,33661,33662,33663,33664,33665,33666,33667,33668,33669,33670,33671,33672,33673,33674,33675,33676,33677,33678,33679,33680,33681,33682,33683,33684,33685,33686,33687,33688,33689,33690,33691,33692,33693,33694,33695,33696,33697,33698,33699,33700,33701,33702,33703,33704,33705,33706,33707,33708,33709,33710,33711,33712,33713,33714,33715,33716,33717,33718,33719,33720,33721,33722,33723,33724,33725,33726,33727,33728,33729,33730,33731,33732,33733,33734,33735,33736,33737,33738,33739,33740,33741,33742,33743,33744,33745,33746,33747,33748,33749,33750,33751,33752,33753,33754,33755,33756,33757,33758,33759,33760,33761,33762,33763,33764,33765,33766,33767,33768,33769,33770,33771,33772,33773,33774,33775,33776,33777,33778,33779,33780,33781,33782,33783,33784,33785,33786,33787,33788,33789,33790,33791,33792,33793,33794,33795,33796,33797,33798,33799,33800,33801,33802,33803,33804,33805,33806,33807,33808,33809,33810,33811,33812,33813,33814,33815,33816,33817,33818,33819,33820,33821,33822,33823,33824,33825,33826,33827,33828,33829,33830,33831,33832,33833,33834,33835,33836,33837,33838,33839,33840,33841,33842,33843,33844,33845,33846,33847,33848,33849,33850,33851,33852,33853,33854,33855,33856,33857,33858,33859,33860,33861,33862,33863,33864,33865,33866,33867,33868,33869,33870,33871,33872,33873,33874,33875,33876,33877,33878,33879,33880,33881,33882,33883,33884,33885,33886,33887,33888,33889,33890,33891,33892,33893,33894,33895,33896,33897,33898,33899,33900,33901,33902,33903,33904,33905,33906,33907,33908,33909,33910,33911,33912,33913,33914,33915,33916,33917,33918,33919,33920,33921,33922,33923,33924,33925,33926,33927,33928,33929,33930,33931,33932,33933,33934,33935,33936,33937,33938,33939,33940,33941,33942,33943,33944,33945,33946,33947,33948,33949,33950,33951,33952,33953,33954,33955,33956,33957,33958,33959,33960,33961,33962,33963,33964,33965,33966,33967,33968,33969,33970,33971,33972,33973,33974,33975,33976,33977,33978,33979,33980,33981,33982,33983,33984,33985,33986,33987,33988,33989,33990,33991,33992,33993,33994,33995,33996,33997,33998,33999,34000,34001,34002,34003,34004,34005,34006,34007,34008,34009,34010,34011,34012,34013,34014,34015,34016,34017,34018,34019,34020,34021,34022,34023,34024,34025,34026,34027,34028,34029,34030,34031,34032,34033,34034,34035,34036,34037,34038,34039,34040,34041,34042,34043,34044,34045,34046,34047,34048,34049,34050,34051,34052,34053,34054,34055,34056,34057,34058,34059,34060,34061,34062,34063,34064,34065,34066,34067,34068,34069,34070,34071,34072,34073,34074,34075,34076,34077,34078,34079,34080,34081,34082,34083,34084,34085,34086,34087,34088,34089,34090,34091,34092,34093,34094,34095,34096,34097,34098,34099,34100,34101,34102,34103,34104,34105,34106,34107,34108,34109,34110,34111,34112,34113,34114,34115,34116,34117,34118,34119,34120,34121,34122,34123,34124,34125,34126,34127,34128,34129,34130,34131,34132,34133,34134,34135,34136,34137,34138,34139,34140,34141,34142,34143,34144,34145,34146,34147,34148,34149,34150,34151,34152,34153,34154,34155,34156,34157,34158,34159,34160,34161,34162,34163,34164,34165,34166,34167,34168,34169,34170,34171,34172,34173,34174,34175,34176,34177,34178,34179,34180,34181,34182,34183,34184,34185,34186,34187,34188,34189,34190,34191,34192,34193,34194,34195,34196,34197,34198,34199,34200,34201,34202,34203,34204,34205,34206,34207,34208,34209,34210,34211,34212,34213,34214,34215,34216,34217,34218,34219,34220,34221,34222,34223,34224,34225,34226,34227,34228,34229,34230,34231,34232,34233,34234,34235,34236,34237,34238,34239,34240,34241,34242,34243,34244,34245,34246,34247,34248,34249,34250,34251,34252,34253,34254,34255,34256,34257,34258,34259,34260,34261,34262,34263,34264,34265,34266,34267,34268,34269,34270,34271,34272,34273,34274,34275,34276,34277,34278,34279,34280,34281,34282,34283,34284,34285,34286,34287,34288,34289,34290,34291,34292,34293,34294,34295,34296,34297,34298,34299,34300,34301,34302,34303,34304,34305,34306,34307,34308,34309,34310,34311,34312,34313,34314,34315,34316,34317,34318,34319,34320,34321,34322,34323,34324,34325,34326,34327,34328,34329,34330,34331,34332,34333,34334,34335,34336,34337,34338,34339,34340,34341,34342,34343,34344,34345,34346,34347,34348,34349,34350,34351,34352,34353,34354,34355,34356,34357,34358,34359,34360,34361,34362,34363,34364,34365,34366,34367,34368,34369,34370,34371,34372,34373,34374,34375,34376,34377,34378,34379,34380,34381,34382,34383,34384,34385,34386,34387,34388,34389,34390,34391,34392,34393,34394,34395,34396,34397,34398,34399,34400,34401,34402,34403,34404,34405,34406,34407,34408,34409,34410,34411,34412,34413,34414,34415,34416,34417,34418,34419,34420,34421,34422,34423,34424,34425,34426,34427,34428,34429,34430,34431,34432,34433,34434,34435,34436,34437,34438,34439,34440,34441,34442,34443,34444,34445,34446,34447,34448,34449,34450,34451,34452,34453,34454,34455,34456,34457,34458,34459,34460,34461,34462,34463,34464,34465,34466,34467,34468,34469,34470,34471,34472,34473,34474,34475,34476,34477,34478,34479,34480,34481,34482,34483,34484,34485,34486,34487,34488,34489,34490,34491,34492,34493,34494,34495,34496,34497,34498,34499,34500,34501,34502,34503,34504,34505,34506,34507,34508,34509,34510,34511,34512,34513,34514,34515,34516,34517,34518,34519,34520,34521,34522,34523,34524,34525,34526,34527,34528,34529,34530,34531,34532,34533,34534,34535,34536,34537,34538,34539,34540,34541,34542,34543,34544,34545,34546,34547,34548,34549,34550,34551,34552,34553,34554,34555,34556,34557,34558,34559,34560,34561,34562,34563,34564,34565,34566,34567,34568,34569,34570,34571,34572,34573,34574,34575,34576,34577,34578,34579,34580,34581,34582,34583,34584,34585,34586,34587,34588,34589,34590,34591,34592,34593,34594,34595,34596,34597,34598,34599,34600,34601,34602,34603,34604,34605,34606,34607,34608,34609,34610,34611,34612,34613,34614,34615,34616,34617,34618,34619,34620,34621,34622,34623,34624,34625,34626,34627,34628,34629,34630,34631,34632,34633,34634,34635,34636,34637,34638,34639,34640,34641,34642,34643,34644,34645,34646,34647,34648,34649,34650,34651,34652,34653,34654,34655,34656,34657,34658,34659,34660,34661,34662,34663,34664,34665,34666,34667,34668,34669,34670,34671,34672,34673,34674,34675,34676,34677,34678,34679,34680,34681,34682,34683,34684,34685,34686,34687,34688,34689,34690,34691,34692,34693,34694,34695,34696,34697,34698,34699,34700,34701,34702,34703,34704,34705,34706,34707,34708,34709,34710,34711,34712,34713,34714,34715,34716,34717,34718,34719,34720,34721,34722,34723,34724,34725,34726,34727,34728,34729,34730,34731,34732,34733,34734,34735,34736,34737,34738,34739,34740,34741,34742,34743,34744,34745,34746,34747,34748,34749,34750,34751,34752,34753,34754,34755,34756,34757,34758,34759,34760,34761,34762,34763,34764,34765,34766,34767,34768,34769,34770,34771,34772,34773,34774,34775,34776,34777,34778,34779,34780,34781,34782,34783,34784,34785,34786,34787,34788,34789,34790,34791,34792,34793,34794,34795,34796,34797,34798,34799,34800,34801,34802,34803,34804,34805,34806,34807,34808,34809,34810,34811,34812,34813,34814,34815,34816,34817,34818,34819,34820,34821,34822,34823,34824,34825,34826,34827,34828,34829,34830,34831,34832,34833,34834,34835,34836,34837,34838,34839,34840,34841,34842,34843,34844,34845,34846,34847,34848,34849,34850,34851,34852,34853,34854,34855,34856,34857,34858,34859,34860,34861,34862,34863,34864,34865,34866,34867,34868,34869,34870,34871,34872,34873,34874,34875,34876,34877,34878,34879,34880,34881,34882,34883,34884,34885,34886,34887,34888,34889,34890,34891,34892,34893,34894,34895,34896,34897,34898,34899,34900,34901,34902,34903,34904,34905,34906,34907,34908,34909,34910,34911,34912,34913,34914,34915,34916,34917,34918,34919,34920,34921,34922,34923,34924,34925,34926,34927,34928,34929,34930,34931,34932,34933,34934,34935,34936,34937,34938,34939,34940,34941,34942,34943,34944,34945,34946,34947,34948,34949,34950,34951,34952,34953,34954,34955,34956,34957,34958,34959,34960,34961,34962,34963,34964,34965,34966,34967,34968,34969,34970,34971,34972,34973,34974,34975,34976,34977,34978,34979,34980,34981,34982,34983,34984,34985,34986,34987,34988,34989,34990,34991,34992,34993,34994,34995,34996,34997,34998,34999,35000,35001,35002,35003,35004,35005,35006,35007,35008,35009,35010,35011,35012,35013,35014,35015,35016,35017,35018,35019,35020,35021,35022,35023,35024,35025,35026,35027,35028,35029,35030,35031,35032,35033,35034,35035,35036,35037,35038,35039,35040,35041,35042,35043,35044,35045,35046,35047,35048,35049,35050,35051,35052,35053,35054,35055,35056,35057,35058,35059,35060,35061,35062,35063,35064,35065,35066,35067,35068,35069,35070,35071,35072,35073,35074,35075,35076,35077,35078,35079,35080,35081,35082,35083,35084,35085,35086,35087,35088,35089,35090,35091,35092,35093,35094,35095,35096,35097,35098,35099,35100,35101,35102,35103,35104,35105,35106,35107,35108,35109,35110,35111,35112,35113,35114,35115,35116,35117,35118,35119,35120,35121,35122,35123,35124,35125,35126,35127,35128,35129,35130,35131,35132,35133,35134,35135,35136,35137,35138,35139,35140,35141,35142,35143,35144,35145,35146,35147,35148,35149,35150,35151,35152,35153,35154,35155,35156,35157,35158,35159,35160,35161,35162,35163,35164,35165,35166,35167,35168,35169,35170,35171,35172,35173,35174,35175,35176,35177,35178,35179,35180,35181,35182,35183,35184,35185,35186,35187,35188,35189,35190,35191,35192,35193,35194,35195,35196,35197,35198,35199,35200,35201,35202,35203,35204,35205,35206,35207,35208,35209,35210,35211,35212,35213,35214,35215,35216,35217,35218,35219,35220,35221,35222,35223,35224,35225,35226,35227,35228,35229,35230,35231,35232,35233,35234,35235,35236,35237,35238,35239,35240,35241,35242,35243,35244,35245,35246,35247,35248,35249,35250,35251,35252,35253,35254,35255,35256,35257,35258,35259,35260,35261,35262,35263,35264,35265,35266,35267,35268,35269,35270,35271,35272,35273,35274,35275,35276,35277,35278,35279,35280,35281,35282,35283,35284,35285,35286,35287,35288,35289,35290,35291,35292,35293,35294,35295,35296,35297,35298,35299,35300,35301,35302,35303,35304,35305,35306,35307,35308,35309,35310,35311,35312,35313,35314,35315,35316,35317,35318,35319,35320,35321,35322,35323,35324,35325,35326,35327,35328,35329,35330,35331,35332,35333,35334,35335,35336,35337,35338,35339,35340,35341,35342,35343,35344,35345,35346,35347,35348,35349,35350,35351,35352,35353,35354,35355,35356,35357,35358,35359,35360,35361,35362,35363,35364,35365,35366,35367,35368,35369,35370,35371,35372,35373,35374,35375,35376,35377,35378,35379,35380,35381,35382,35383,35384,35385,35386,35387,35388,35389,35390,35391,35392,35393,35394,35395,35396,35397,35398,35399,35400,35401,35402,35403,35404,35405,35406,35407,35408,35409,35410,35411,35412,35413,35414,35415,35416,35417,35418,35419,35420,35421,35422,35423,35424,35425,35426,35427,35428,35429,35430,35431,35432,35433,35434,35435,35436,35437,35438,35439,35440,35441,35442,35443,35444,35445,35446,35447,35448,35449,35450,35451,35452,35453,35454,35455,35456,35457,35458,35459,35460,35461,35462,35463,35464,35465,35466,35467,35468,35469,35470,35471,35472,35473,35474,35475,35476,35477,35478,35479,35480,35481,35482,35483,35484,35485,35486,35487,35488,35489,35490,35491,35492,35493,35494,35495,35496,35497,35498,35499,35500,35501,35502,35503,35504,35505,35506,35507,35508,35509,35510,35511,35512,35513,35514,35515,35516,35517,35518,35519,35520,35521,35522,35523,35524,35525,35526,35527,35528,35529,35530,35531,35532,35533,35534,35535,35536,35537,35538,35539,35540,35541,35542,35543,35544,35545,35546,35547,35548,35549,35550,35551,35552,35553,35554,35555,35556,35557,35558,35559,35560,35561,35562,35563,35564,35565,35566,35567,35568,35569,35570,35571,35572,35573,35574,35575,35576,35577,35578,35579,35580,35581,35582,35583,35584,35585,35586,35587,35588,35589,35590,35591,35592,35593,35594,35595,35596,35597,35598,35599,35600,35601,35602,35603,35604,35605,35606,35607,35608,35609,35610,35611,35612,35613,35614,35615,35616,35617,35618,35619,35620,35621,35622,35623,35624,35625,35626,35627,35628,35629,35630,35631,35632,35633,35634,35635,35636,35637,35638,35639,35640,35641,35642,35643,35644,35645,35646,35647,35648,35649,35650,35651,35652,35653,35654,35655,35656,35657,35658,35659,35660,35661,35662,35663,35664,35665,35666,35667,35668,35669,35670,35671,35672,35673,35674,35675,35676,35677,35678,35679,35680,35681,35682,35683,35684,35685,35686,35687,35688,35689,35690,35691,35692,35693,35694,35695,35696,35697,35698,35699,35700,35701,35702,35703,35704,35705,35706,35707,35708,35709,35710,35711,35712,35713,35714,35715,35716,35717,35718,35719,35720,35721,35722,35723,35724,35725,35726,35727,35728,35729,35730,35731,35732,35733,35734,35735,35736,35737,35738,35739,35740,35741,35742,35743,35744,35745,35746,35747,35748,35749,35750,35751,35752,35753,35754,35755,35756,35757,35758,35759,35760,35761,35762,35763,35764,35765,35766,35767,35768,35769,35770,35771,35772,35773,35774,35775,35776,35777,35778,35779,35780,35781,35782,35783,35784,35785,35786,35787,35788,35789,35790,35791,35792,35793,35794,35795,35796,35797,35798,35799,35800,35801,35802,35803,35804,35805,35806,35807,35808,35809,35810,35811,35812,35813,35814,35815,35816,35817,35818,35819,35820,35821,35822,35823,35824,35825,35826,35827,35828,35829,35830,35831,35832,35833,35834,35835,35836,35837,35838,35839,35840,35841,35842,35843,35844,35845,35846,35847,35848,35849,35850,35851,35852,35853,35854,35855,35856,35857,35858,35859,35860,35861,35862,35863,35864,35865,35866,35867,35868,35869,35870,35871,35872,35873,35874,35875,35876,35877,35878,35879,35880,35881,35882,35883,35884,35885,35886,35887,35888,35889,35890,35891,35892,35893,35894,35895,35896,35897,35898,35899,35900,35901,35902,35903,35904,35905,35906,35907,35908,35909,35910,35911,35912,35913,35914,35915,35916,35917,35918,35919,35920,35921,35922,35923,35924,35925,35926,35927,35928,35929,35930,35931,35932,35933,35934,35935,35936,35937,35938,35939,35940,35941,35942,35943,35944,35945,35946,35947,35948,35949,35950,35951,35952,35953,35954,35955,35956,35957,35958,35959,35960,35961,35962,35963,35964,35965,35966,35967,35968,35969,35970,35971,35972,35973,35974,35975,35976,35977,35978,35979,35980,35981,35982,35983,35984,35985,35986,35987,35988,35989,35990,35991,35992,35993,35994,35995,35996,35997,35998,35999,36000,36001,36002,36003,36004,36005,36006,36007,36008,36009,36010,36011,36012,36013,36014,36015,36016,36017,36018,36019,36020,36021,36022,36023,36024,36025,36026,36027,36028,36029,36030,36031,36032,36033,36034,36035,36036,36037,36038,36039,36040,36041,36042,36043,36044,36045,36046,36047,36048,36049,36050,36051,36052,36053,36054,36055,36056,36057,36058,36059,36060,36061,36062,36063,36064,36065,36066,36067,36068,36069,36070,36071,36072,36073,36074,36075,36076,36077,36078,36079,36080,36081,36082,36083,36084,36085,36086,36087,36088,36089,36090,36091,36092,36093,36094,36095,36096,36097,36098,36099,36100,36101,36102,36103,36104,36105,36106,36107,36108,36109,36110,36111,36112,36113,36114,36115,36116,36117,36118,36119,36120,36121,36122,36123,36124,36125,36126,36127,36128,36129,36130,36131,36132,36133,36134,36135,36136,36137,36138,36139,36140,36141,36142,36143,36144,36145,36146,36147,36148,36149,36150,36151,36152,36153,36154,36155,36156,36157,36158,36159,36160,36161,36162,36163,36164,36165,36166,36167,36168,36169,36170,36171,36172,36173,36174,36175,36176,36177,36178,36179,36180,36181,36182,36183,36184,36185,36186,36187,36188,36189,36190,36191,36192,36193,36194,36195,36196,36197,36198,36199,36200,36201,36202,36203,36204,36205,36206,36207,36208,36209,36210,36211,36212,36213,36214,36215,36216,36217,36218,36219,36220,36221,36222,36223,36224,36225,36226,36227,36228,36229,36230,36231,36232,36233,36234,36235,36236,36237,36238,36239,36240,36241,36242,36243,36244,36245,36246,36247,36248,36249,36250,36251,36252,36253,36254,36255,36256,36257,36258,36259,36260,36261,36262,36263,36264,36265,36266,36267,36268,36269,36270,36271,36272,36273,36274,36275,36276,36277,36278,36279,36280,36281,36282,36283,36284,36285,36286,36287,36288,36289,36290,36291,36292,36293,36294,36295,36296,36297,36298,36299,36300,36301,36302,36303,36304,36305,36306,36307,36308,36309,36310,36311,36312,36313,36314,36315,36316,36317,36318,36319,36320,36321,36322,36323,36324,36325,36326,36327,36328,36329,36330,36331,36332,36333,36334,36335,36336,36337,36338,36339,36340,36341,36342,36343,36344,36345,36346,36347,36348,36349,36350,36351,36352,36353,36354,36355,36356,36357,36358,36359,36360,36361,36362,36363,36364,36365,36366,36367,36368,36369,36370,36371,36372,36373,36374,36375,36376,36377,36378,36379,36380,36381,36382,36383,36384,36385,36386,36387,36388,36389,36390,36391,36392,36393,36394,36395,36396,36397,36398,36399,36400,36401,36402,36403,36404,36405,36406,36407,36408,36409,36410,36411,36412,36413,36414,36415,36416,36417,36418,36419,36420,36421,36422,36423,36424,36425,36426,36427,36428,36429,36430,36431,36432,36433,36434,36435,36436,36437,36438,36439,36440,36441,36442,36443,36444,36445,36446,36447,36448,36449,36450,36451,36452,36453,36454,36455,36456,36457,36458,36459,36460,36461,36462,36463,36464,36465,36466,36467,36468,36469,36470,36471,36472,36473,36474,36475,36476,36477,36478,36479,36480,36481,36482,36483,36484,36485,36486,36487,36488,36489,36490,36491,36492,36493,36494,36495,36496,36497,36498,36499,36500,36501,36502,36503,36504,36505,36506,36507,36508,36509,36510,36511,36512,36513,36514,36515,36516,36517,36518,36519,36520,36521,36522,36523,36524,36525,36526,36527,36528,36529,36530,36531,36532,36533,36534,36535,36536,36537,36538,36539,36540,36541,36542,36543,36544,36545,36546,36547,36548,36549,36550,36551,36552,36553,36554,36555,36556,36557,36558,36559,36560,36561,36562,36563,36564,36565,36566,36567,36568,36569,36570,36571,36572,36573,36574,36575,36576,36577,36578,36579,36580,36581,36582,36583,36584,36585,36586,36587,36588,36589,36590,36591,36592,36593,36594,36595,36596,36597,36598,36599,36600,36601,36602,36603,36604,36605,36606,36607,36608,36609,36610,36611,36612,36613,36614,36615,36616,36617,36618,36619,36620,36621,36622,36623,36624,36625,36626,36627,36628,36629,36630,36631,36632,36633,36634,36635,36636,36637,36638,36639,36640,36641,36642,36643,36644,36645,36646,36647,36648,36649,36650,36651,36652,36653,36654,36655,36656,36657,36658,36659,36660,36661,36662,36663,36664,36665,36666,36667,36668,36669,36670,36671,36672,36673,36674,36675,36676,36677,36678,36679,36680,36681,36682,36683,36684,36685,36686,36687,36688,36689,36690,36691,36692,36693,36694,36695,36696,36697,36698,36699,36700,36701,36702,36703,36704,36705,36706,36707,36708,36709,36710,36711,36712,36713,36714,36715,36716,36717,36718,36719,36720,36721,36722,36723,36724,36725,36726,36727,36728,36729,36730,36731,36732,36733,36734,36735,36736,36737,36738,36739,36740,36741,36742,36743,36744,36745,36746,36747,36748,36749,36750,36751,36752,36753,36754,36755,36756,36757,36758,36759,36760,36761,36762,36763,36764,36765,36766,36767,36768,36769,36770,36771,36772,36773,36774,36775,36776,36777,36778,36779,36780,36781,36782,36783,36784,36785,36786,36787,36788,36789,36790,36791,36792,36793,36794,36795,36796,36797,36798,36799,36800,36801,36802,36803,36804,36805,36806,36807,36808,36809,36810,36811,36812,36813,36814,36815,36816,36817,36818,36819,36820,36821,36822,36823,36824,36825,36826,36827,36828,36829,36830,36831,36832,36833,36834,36835,36836,36837,36838,36839,36840,36841,36842,36843,36844,36845,36846,36847,36848,36849,36850,36851,36852,36853,36854,36855,36856,36857,36858,36859,36860,36861,36862,36863,36864,36865,36866,36867,36868,36869,36870,36871,36872,36873,36874,36875,36876,36877,36878,36879,36880,36881,36882,36883,36884,36885,36886,36887,36888,36889,36890,36891,36892,36893,36894,36895,36896,36897,36898,36899,36900,36901,36902,36903,36904,36905,36906,36907,36908,36909,36910,36911,36912,36913,36914,36915,36916,36917,36918,36919,36920,36921,36922,36923,36924,36925,36926,36927,36928,36929,36930,36931,36932,36933,36934,36935,36936,36937,36938,36939,36940,36941,36942,36943,36944,36945,36946,36947,36948,36949,36950,36951,36952,36953,36954,36955,36956,36957,36958,36959,36960,36961,36962,36963,36964,36965,36966,36967,36968,36969,36970,36971,36972,36973,36974,36975,36976,36977,36978,36979,36980,36981,36982,36983,36984,36985,36986,36987,36988,36989,36990,36991,36992,36993,36994,36995,36996,36997,36998,36999,37000,37001,37002,37003,37004,37005,37006,37007,37008,37009,37010,37011,37012,37013,37014,37015,37016,37017,37018,37019,37020,37021,37022,37023,37024,37025,37026,37027,37028,37029,37030,37031,37032,37033,37034,37035,37036,37037,37038,37039,37040,37041,37042,37043,37044,37045,37046,37047,37048,37049,37050,37051,37052,37053,37054,37055,37056,37057,37058,37059,37060,37061,37062,37063,37064,37065,37066,37067,37068,37069,37070,37071,37072,37073,37074,37075,37076,37077,37078,37079,37080,37081,37082,37083,37084,37085,37086,37087,37088,37089,37090,37091,37092,37093,37094,37095,37096,37097,37098,37099,37100,37101,37102,37103,37104,37105,37106,37107,37108,37109,37110,37111,37112,37113,37114,37115,37116,37117,37118,37119,37120,37121,37122,37123,37124,37125,37126,37127,37128,37129,37130,37131,37132,37133,37134,37135,37136,37137,37138,37139,37140,37141,37142,37143,37144,37145,37146,37147,37148,37149,37150,37151,37152,37153,37154,37155,37156,37157,37158,37159,37160,37161,37162,37163,37164,37165,37166,37167,37168,37169,37170,37171,37172,37173,37174,37175,37176,37177,37178,37179,37180,37181,37182,37183,37184,37185,37186,37187,37188,37189,37190,37191,37192,37193,37194,37195,37196,37197,37198,37199,37200,37201,37202,37203,37204,37205,37206,37207,37208,37209,37210,37211,37212,37213,37214,37215,37216,37217,37218,37219,37220,37221,37222,37223,37224,37225,37226,37227,37228,37229,37230,37231,37232,37233,37234,37235,37236,37237,37238,37239,37240,37241,37242,37243,37244,37245,37246,37247,37248,37249,37250,37251,37252,37253,37254,37255,37256,37257,37258,37259,37260,37261,37262,37263,37264,37265,37266,37267,37268,37269,37270,37271,37272,37273,37274,37275,37276,37277,37278,37279,37280,37281,37282,37283,37284,37285,37286,37287,37288,37289,37290,37291,37292,37293,37294,37295,37296,37297,37298,37299,37300,37301,37302,37303,37304,37305,37306,37307,37308,37309,37310,37311,37312,37313,37314,37315,37316,37317,37318,37319,37320,37321,37322,37323,37324,37325,37326,37327,37328,37329,37330,37331,37332,37333,37334,37335,37336,37337,37338,37339,37340,37341,37342,37343,37344,37345,37346,37347,37348,37349,37350,37351,37352,37353,37354,37355,37356,37357,37358,37359,37360,37361,37362,37363,37364,37365,37366,37367,37368,37369,37370,37371,37372,37373,37374,37375,37376,37377,37378,37379,37380,37381,37382,37383,37384,37385,37386,37387,37388,37389,37390,37391,37392,37393,37394,37395,37396,37397,37398,37399,37400,37401,37402,37403,37404,37405,37406,37407,37408,37409,37410,37411,37412,37413,37414,37415,37416,37417,37418,37419,37420,37421,37422,37423,37424,37425,37426,37427,37428,37429,37430,37431,37432,37433,37434,37435,37436,37437,37438,37439,37440,37441,37442,37443,37444,37445,37446,37447,37448,37449,37450,37451,37452,37453,37454,37455,37456,37457,37458,37459,37460,37461,37462,37463,37464,37465,37466,37467,37468,37469,37470,37471,37472,37473,37474,37475,37476,37477,37478,37479,37480,37481,37482,37483,37484,37485,37486,37487,37488,37489,37490,37491,37492,37493,37494,37495,37496,37497,37498,37499,37500,37501,37502,37503,37504,37505,37506,37507,37508,37509,37510,37511,37512,37513,37514,37515,37516,37517,37518,37519,37520,37521,37522,37523,37524,37525,37526,37527,37528,37529,37530,37531,37532,37533,37534,37535,37536,37537,37538,37539,37540,37541,37542,37543,37544,37545,37546,37547,37548,37549,37550,37551,37552,37553,37554,37555,37556,37557,37558,37559,37560,37561,37562,37563,37564,37565,37566,37567,37568,37569,37570,37571,37572,37573,37574,37575,37576,37577,37578,37579,37580,37581,37582,37583,37584,37585,37586,37587,37588,37589,37590,37591,37592,37593,37594,37595,37596,37597,37598,37599,37600,37601,37602,37603,37604,37605,37606,37607,37608,37609,37610,37611,37612,37613,37614,37615,37616,37617,37618,37619,37620,37621,37622,37623,37624,37625,37626,37627,37628,37629,37630,37631,37632,37633,37634,37635,37636,37637,37638,37639,37640,37641,37642,37643,37644,37645,37646,37647,37648,37649,37650,37651,37652,37653,37654,37655,37656,37657,37658,37659,37660,37661,37662,37663,37664,37665,37666,37667,37668,37669,37670,37671,37672,37673,37674,37675,37676,37677,37678,37679,37680,37681,37682,37683,37684,37685,37686,37687,37688,37689,37690,37691,37692,37693,37694,37695,37696,37697,37698,37699,37700,37701,37702,37703,37704,37705,37706,37707,37708,37709,37710,37711,37712,37713,37714,37715,37716,37717,37718,37719,37720,37721,37722,37723,37724,37725,37726,37727,37728,37729,37730,37731,37732,37733,37734,37735,37736,37737,37738,37739,37740,37741,37742,37743,37744,37745,37746,37747,37748,37749,37750,37751,37752,37753,37754,37755,37756,37757,37758,37759,37760,37761,37762,37763,37764,37765,37766,37767,37768,37769,37770,37771,37772,37773,37774,37775,37776,37777,37778,37779,37780,37781,37782,37783,37784,37785,37786,37787,37788,37789,37790,37791,37792,37793,37794,37795,37796,37797,37798,37799,37800,37801,37802,37803,37804,37805,37806,37807,37808,37809,37810,37811,37812,37813,37814,37815,37816,37817,37818,37819,37820,37821,37822,37823,37824,37825,37826,37827,37828,37829,37830,37831,37832,37833,37834,37835,37836,37837,37838,37839,37840,37841,37842,37843,37844,37845,37846,37847,37848,37849,37850,37851,37852,37853,37854,37855,37856,37857,37858,37859,37860,37861,37862,37863,37864,37865,37866,37867,37868,37869,37870,37871,37872,37873,37874,37875,37876,37877,37878,37879,37880,37881,37882,37883,37884,37885,37886,37887,37888,37889,37890,37891,37892,37893,37894,37895,37896,37897,37898,37899,37900,37901,37902,37903,37904,37905,37906,37907,37908,37909,37910,37911,37912,37913,37914,37915,37916,37917,37918,37919,37920,37921,37922,37923,37924,37925,37926,37927,37928,37929,37930,37931,37932,37933,37934,37935,37936,37937,37938,37939,37940,37941,37942,37943,37944,37945,37946,37947,37948,37949,37950,37951,37952,37953,37954,37955,37956,37957,37958,37959,37960,37961,37962,37963,37964,37965,37966,37967,37968,37969,37970,37971,37972,37973,37974,37975,37976,37977,37978,37979,37980,37981,37982,37983,37984,37985,37986,37987,37988,37989,37990,37991,37992,37993,37994,37995,37996,37997,37998,37999,38000,38001,38002,38003,38004,38005,38006,38007,38008,38009,38010,38011,38012,38013,38014,38015,38016,38017,38018,38019,38020,38021,38022,38023,38024,38025,38026,38027,38028,38029,38030,38031,38032,38033,38034,38035,38036,38037,38038,38039,38040,38041,38042,38043,38044,38045,38046,38047,38048,38049,38050,38051,38052,38053,38054,38055,38056,38057,38058,38059,38060,38061,38062,38063,38064,38065,38066,38067,38068,38069,38070,38071,38072,38073,38074,38075,38076,38077,38078,38079,38080,38081,38082,38083,38084,38085,38086,38087,38088,38089,38090,38091,38092,38093,38094,38095,38096,38097,38098,38099,38100,38101,38102,38103,38104,38105,38106,38107,38108,38109,38110,38111,38112,38113,38114,38115,38116,38117,38118,38119,38120,38121,38122,38123,38124,38125,38126,38127,38128,38129,38130,38131,38132,38133,38134,38135,38136,38137,38138,38139,38140,38141,38142,38143,38144,38145,38146,38147,38148,38149,38150,38151,38152,38153,38154,38155,38156,38157,38158,38159,38160,38161,38162,38163,38164,38165,38166,38167,38168,38169,38170,38171,38172,38173,38174,38175,38176,38177,38178,38179,38180,38181,38182,38183,38184,38185,38186,38187,38188,38189,38190,38191,38192,38193,38194,38195,38196,38197,38198,38199,38200,38201,38202,38203,38204,38205,38206,38207,38208,38209,38210,38211,38212,38213,38214,38215,38216,38217,38218,38219,38220,38221,38222,38223,38224,38225,38226,38227,38228,38229,38230,38231,38232,38233,38234,38235,38236,38237,38238,38239,38240,38241,38242,38243,38244,38245,38246,38247,38248,38249,38250,38251,38252,38253,38254,38255,38256,38257,38258,38259,38260,38261,38262,38263,38264,38265,38266,38267,38268,38269,38270,38271,38272,38273,38274,38275,38276,38277,38278,38279,38280,38281,38282,38283,38284,38285,38286,38287,38288,38289,38290,38291,38292,38293,38294,38295,38296,38297,38298,38299,38300,38301,38302,38303,38304,38305,38306,38307,38308,38309,38310,38311,38312,38313,38314,38315,38316,38317,38318,38319,38320,38321,38322,38323,38324,38325,38326,38327,38328,38329,38330,38331,38332,38333,38334,38335,38336,38337,38338,38339,38340,38341,38342,38343,38344,38345,38346,38347,38348,38349,38350,38351,38352,38353,38354,38355,38356,38357,38358,38359,38360,38361,38362,38363,38364,38365,38366,38367,38368,38369,38370,38371,38372,38373,38374,38375,38376,38377,38378,38379,38380,38381,38382,38383,38384,38385,38386,38387,38388,38389,38390,38391,38392,38393,38394,38395,38396,38397,38398,38399,38400,38401,38402,38403,38404,38405,38406,38407,38408,38409,38410,38411,38412,38413,38414,38415,38416,38417,38418,38419,38420,38421,38422,38423,38424,38425,38426,38427,38428,38429,38430,38431,38432,38433,38434,38435,38436,38437,38438,38439,38440,38441,38442,38443,38444,38445,38446,38447,38448,38449,38450,38451,38452,38453,38454,38455,38456,38457,38458,38459,38460,38461,38462,38463,38464,38465,38466,38467,38468,38469,38470,38471,38472,38473,38474,38475,38476,38477,38478,38479,38480,38481,38482,38483,38484,38485,38486,38487,38488,38489,38490,38491,38492,38493,38494,38495,38496,38497,38498,38499,38500,38501,38502,38503,38504,38505,38506,38507,38508,38509,38510,38511,38512,38513,38514,38515,38516,38517,38518,38519,38520,38521,38522,38523,38524,38525,38526,38527,38528,38529,38530,38531,38532,38533,38534,38535,38536,38537,38538,38539,38540,38541,38542,38543,38544,38545,38546,38547,38548,38549,38550,38551,38552,38553,38554,38555,38556,38557,38558,38559,38560,38561,38562,38563,38564,38565,38566,38567,38568,38569,38570,38571,38572,38573,38574,38575,38576,38577,38578,38579,38580,38581,38582,38583,38584,38585,38586,38587,38588,38589,38590,38591,38592,38593,38594,38595,38596,38597,38598,38599,38600,38601,38602,38603,38604,38605,38606,38607,38608,38609,38610,38611,38612,38613,38614,38615,38616,38617,38618,38619,38620,38621,38622,38623,38624,38625,38626,38627,38628,38629,38630,38631,38632,38633,38634,38635,38636,38637,38638,38639,38640,38641,38642,38643,38644,38645,38646,38647,38648,38649,38650,38651,38652,38653,38654,38655,38656,38657,38658,38659,38660,38661,38662,38663,38664,38665,38666,38667,38668,38669,38670,38671,38672,38673,38674,38675,38676,38677,38678,38679,38680,38681,38682,38683,38684,38685,38686,38687,38688,38689,38690,38691,38692,38693,38694,38695,38696,38697,38698,38699,38700,38701,38702,38703,38704,38705,38706,38707,38708,38709,38710,38711,38712,38713,38714,38715,38716,38717,38718,38719,38720,38721,38722,38723,38724,38725,38726,38727,38728,38729,38730,38731,38732,38733,38734,38735,38736,38737,38738,38739,38740,38741,38742,38743,38744,38745,38746,38747,38748,38749,38750,38751,38752,38753,38754,38755,38756,38757,38758,38759,38760,38761,38762,38763,38764,38765,38766,38767,38768,38769,38770,38771,38772,38773,38774,38775,38776,38777,38778,38779,38780,38781,38782,38783,38784,38785,38786,38787,38788,38789,38790,38791,38792,38793,38794,38795,38796,38797,38798,38799,38800,38801,38802,38803,38804,38805,38806,38807,38808,38809,38810,38811,38812,38813,38814,38815,38816,38817,38818,38819,38820,38821,38822,38823,38824,38825,38826,38827,38828,38829,38830,38831,38832,38833,38834,38835,38836,38837,38838,38839,38840,38841,38842,38843,38844,38845,38846,38847,38848,38849,38850,38851,38852,38853,38854,38855,38856,38857,38858,38859,38860,38861,38862,38863,38864,38865,38866,38867,38868,38869,38870,38871,38872,38873,38874,38875,38876,38877,38878,38879,38880,38881,38882,38883,38884,38885,38886,38887,38888,38889,38890,38891,38892,38893,38894,38895,38896,38897,38898,38899,38900,38901,38902,38903,38904,38905,38906,38907,38908,38909,38910,38911,38912,38913,38914,38915,38916,38917,38918,38919,38920,38921,38922,38923,38924,38925,38926,38927,38928,38929,38930,38931,38932,38933,38934,38935,38936,38937,38938,38939,38940,38941,38942,38943,38944,38945,38946,38947,38948,38949,38950,38951,38952,38953,38954,38955,38956,38957,38958,38959,38960,38961,38962,38963,38964,38965,38966,38967,38968,38969,38970,38971,38972,38973,38974,38975,38976,38977,38978,38979,38980,38981,38982,38983,38984,38985,38986,38987,38988,38989,38990,38991,38992,38993,38994,38995,38996,38997,38998,38999,39000,39001,39002,39003,39004,39005,39006,39007,39008,39009,39010,39011,39012,39013,39014,39015,39016,39017,39018,39019,39020,39021,39022,39023,39024,39025,39026,39027,39028,39029,39030,39031,39032,39033,39034,39035,39036,39037,39038,39039,39040,39041,39042,39043,39044,39045,39046,39047,39048,39049,39050,39051,39052,39053,39054,39055,39056,39057,39058,39059,39060,39061,39062,39063,39064,39065,39066,39067,39068,39069,39070,39071,39072,39073,39074,39075,39076,39077,39078,39079,39080,39081,39082,39083,39084,39085,39086,39087,39088,39089,39090,39091,39092,39093,39094,39095,39096,39097,39098,39099,39100,39101,39102,39103,39104,39105,39106,39107,39108,39109,39110,39111,39112,39113,39114,39115,39116,39117,39118,39119,39120,39121,39122,39123,39124,39125,39126,39127,39128,39129,39130,39131,39132,39133,39134,39135,39136,39137,39138,39139,39140,39141,39142,39143,39144,39145,39146,39147,39148,39149,39150,39151,39152,39153,39154,39155,39156,39157,39158,39159,39160,39161,39162,39163,39164,39165,39166,39167,39168,39169,39170,39171,39172,39173,39174,39175,39176,39177,39178,39179,39180,39181,39182,39183,39184,39185,39186,39187,39188,39189,39190,39191,39192,39193,39194,39195,39196,39197,39198,39199,39200,39201,39202,39203,39204,39205,39206,39207,39208,39209,39210,39211,39212,39213,39214,39215,39216,39217,39218,39219,39220,39221,39222,39223,39224,39225,39226,39227,39228,39229,39230,39231,39232,39233,39234,39235,39236,39237,39238,39239,39240,39241,39242,39243,39244,39245,39246,39247,39248,39249,39250,39251,39252,39253,39254,39255,39256,39257,39258,39259,39260,39261,39262,39263,39264,39265,39266,39267,39268,39269,39270,39271,39272,39273,39274,39275,39276,39277,39278,39279,39280,39281,39282,39283,39284,39285,39286,39287,39288,39289,39290,39291,39292,39293,39294,39295,39296,39297,39298,39299,39300,39301,39302,39303,39304,39305,39306,39307,39308,39309,39310,39311,39312,39313,39314,39315,39316,39317,39318,39319,39320,39321,39322,39323,39324,39325,39326,39327,39328,39329,39330,39331,39332,39333,39334,39335,39336,39337,39338,39339,39340,39341,39342,39343,39344,39345,39346,39347,39348,39349,39350,39351,39352,39353,39354,39355,39356,39357,39358,39359,39360,39361,39362,39363,39364,39365,39366,39367,39368,39369,39370,39371,39372,39373,39374,39375,39376,39377,39378,39379,39380,39381,39382,39383,39384,39385,39386,39387,39388,39389,39390,39391,39392,39393,39394,39395,39396,39397,39398,39399,39400,39401,39402,39403,39404,39405,39406,39407,39408,39409,39410,39411,39412,39413,39414,39415,39416,39417,39418,39419,39420,39421,39422,39423,39424,39425,39426,39427,39428,39429,39430,39431,39432,39433,39434,39435,39436,39437,39438,39439,39440,39441,39442,39443,39444,39445,39446,39447,39448,39449,39450,39451,39452,39453,39454,39455,39456,39457,39458,39459,39460,39461,39462,39463,39464,39465,39466,39467,39468,39469,39470,39471,39472,39473,39474,39475,39476,39477,39478,39479,39480,39481,39482,39483,39484,39485,39486,39487,39488,39489,39490,39491,39492,39493,39494,39495,39496,39497,39498,39499,39500,39501,39502,39503,39504,39505,39506,39507,39508,39509,39510,39511,39512,39513,39514,39515,39516,39517,39518,39519,39520,39521,39522,39523,39524,39525,39526,39527,39528,39529,39530,39531,39532,39533,39534,39535,39536,39537,39538,39539,39540,39541,39542,39543,39544,39545,39546,39547,39548,39549,39550,39551,39552,39553,39554,39555,39556,39557,39558,39559,39560,39561,39562,39563,39564,39565,39566,39567,39568,39569,39570,39571,39572,39573,39574,39575,39576,39577,39578,39579,39580,39581,39582,39583,39584,39585,39586,39587,39588,39589,39590,39591,39592,39593,39594,39595,39596,39597,39598,39599,39600,39601,39602,39603,39604,39605,39606,39607,39608,39609,39610,39611,39612,39613,39614,39615,39616,39617,39618,39619,39620,39621,39622,39623,39624,39625,39626,39627,39628,39629,39630,39631,39632,39633,39634,39635,39636,39637,39638,39639,39640,39641,39642,39643,39644,39645,39646,39647,39648,39649,39650,39651,39652,39653,39654,39655,39656,39657,39658,39659,39660,39661,39662,39663,39664,39665,39666,39667,39668,39669,39670,39671,39672,39673,39674,39675,39676,39677,39678,39679,39680,39681,39682,39683,39684,39685,39686,39687,39688,39689,39690,39691,39692,39693,39694,39695,39696,39697,39698,39699,39700,39701,39702,39703,39704,39705,39706,39707,39708,39709,39710,39711,39712,39713,39714,39715,39716,39717,39718,39719,39720,39721,39722,39723,39724,39725,39726,39727,39728,39729,39730,39731,39732,39733,39734,39735,39736,39737,39738,39739,39740,39741,39742,39743,39744,39745,39746,39747,39748,39749,39750,39751,39752,39753,39754,39755,39756,39757,39758,39759,39760,39761,39762,39763,39764,39765,39766,39767,39768,39769,39770,39771,39772,39773,39774,39775,39776,39777,39778,39779,39780,39781,39782,39783,39784,39785,39786,39787,39788,39789,39790,39791,39792,39793,39794,39795,39796,39797,39798,39799,39800,39801,39802,39803,39804,39805,39806,39807,39808,39809,39810,39811,39812,39813,39814,39815,39816,39817,39818,39819,39820,39821,39822,39823,39824,39825,39826,39827,39828,39829,39830,39831,39832,39833,39834,39835,39836,39837,39838,39839,39840,39841,39842,39843,39844,39845,39846,39847,39848,39849,39850,39851,39852,39853,39854,39855,39856,39857,39858,39859,39860,39861,39862,39863,39864,39865,39866,39867,39868,39869,39870,39871,39872,39873,39874,39875,39876,39877,39878,39879,39880,39881,39882,39883,39884,39885,39886,39887,39888,39889,39890,39891,39892,39893,39894,39895,39896,39897,39898,39899,39900,39901,39902,39903,39904,39905,39906,39907,39908,39909,39910,39911,39912,39913,39914,39915,39916,39917,39918,39919,39920,39921,39922,39923,39924,39925,39926,39927,39928,39929,39930,39931,39932,39933,39934,39935,39936,39937,39938,39939,39940,39941,39942,39943,39944,39945,39946,39947,39948,39949,39950,39951,39952,39953,39954,39955,39956,39957,39958,39959,39960,39961,39962,39963,39964,39965,39966,39967,39968,39969,39970,39971,39972,39973,39974,39975,39976,39977,39978,39979,39980,39981,39982,39983,39984,39985,39986,39987,39988,39989,39990,39991,39992,39993,39994,39995,39996,39997,39998,39999,40000,40001,40002,40003,40004,40005,40006,40007,40008,40009,40010,40011,40012,40013,40014,40015,40016,40017,40018,40019,40020,40021,40022,40023,40024,40025,40026,40027,40028,40029,40030,40031,40032,40033,40034,40035,40036,40037,40038,40039,40040,40041,40042,40043,40044,40045,40046,40047,40048,40049,40050,40051,40052,40053,40054,40055,40056,40057,40058,40059,40060,40061,40062,40063,40064,40065,40066,40067,40068,40069,40070,40071,40072,40073,40074,40075,40076,40077,40078,40079,40080,40081,40082,40083,40084,40085,40086,40087,40088,40089,40090,40091,40092,40093,40094,40095,40096,40097,40098,40099,40100,40101,40102,40103,40104,40105,40106,40107,40108,40109,40110,40111,40112,40113,40114,40115,40116,40117,40118,40119,40120,40121,40122,40123,40124,40125,40126,40127,40128,40129,40130,40131,40132,40133,40134,40135,40136,40137,40138,40139,40140,40141,40142,40143,40144,40145,40146,40147,40148,40149,40150,40151,40152,40153,40154,40155,40156,40157,40158,40159,40160,40161,40162,40163,40164,40165,40166,40167,40168,40169,40170,40171,40172,40173,40174,40175,40176,40177,40178,40179,40180,40181,40182,40183,40184,40185,40186,40187,40188,40189,40190,40191,40192,40193,40194,40195,40196,40197,40198,40199,40200,40201,40202,40203,40204,40205,40206,40207,40208,40209,40210,40211,40212,40213,40214,40215,40216,40217,40218,40219,40220,40221,40222,40223,40224,40225,40226,40227,40228,40229,40230,40231,40232,40233,40234,40235,40236,40237,40238,40239,40240,40241,40242,40243,40244,40245,40246,40247,40248,40249,40250,40251,40252,40253,40254,40255,40256,40257,40258,40259,40260,40261,40262,40263,40264,40265,40266,40267,40268,40269,40270,40271,40272,40273,40274,40275,40276,40277,40278,40279,40280,40281,40282,40283,40284,40285,40286,40287,40288,40289,40290,40291,40292,40293,40294,40295,40296,40297,40298,40299,40300,40301,40302,40303,40304,40305,40306,40307,40308,40309,40310,40311,40312,40313,40314,40315,40316,40317,40318,40319,40320,40321,40322,40323,40324,40325,40326,40327,40328,40329,40330,40331,40332,40333,40334,40335,40336,40337,40338,40339,40340,40341,40342,40343,40344,40345,40346,40347,40348,40349,40350,40351,40352,40353,40354,40355,40356,40357,40358,40359,40360,40361,40362,40363,40364,40365,40366,40367,40368,40369,40370,40371,40372,40373,40374,40375,40376,40377,40378,40379,40380,40381,40382,40383,40384,40385,40386,40387,40388,40389,40390,40391,40392,40393,40394,40395,40396,40397,40398,40399,40400,40401,40402,40403,40404,40405,40406,40407,40408,40409,40410,40411,40412,40413,40414,40415,40416,40417,40418,40419,40420,40421,40422,40423,40424,40425,40426,40427,40428,40429,40430,40431,40432,40433,40434,40435,40436,40437,40438,40439,40440,40441,40442,40443,40444,40445,40446,40447,40448,40449,40450,40451,40452,40453,40454,40455,40456,40457,40458,40459,40460,40461,40462,40463,40464,40465,40466,40467,40468,40469,40470,40471,40472,40473,40474,40475,40476,40477,40478,40479,40480,40481,40482,40483,40484,40485,40486,40487,40488,40489,40490,40491,40492,40493,40494,40495,40496,40497,40498,40499,40500,40501,40502,40503,40504,40505,40506,40507,40508,40509,40510,40511,40512,40513,40514,40515,40516,40517,40518,40519,40520,40521,40522,40523,40524,40525,40526,40527,40528,40529,40530,40531,40532,40533,40534,40535,40536,40537,40538,40539,40540,40541,40542,40543,40544,40545,40546,40547,40548,40549,40550,40551,40552,40553,40554,40555,40556,40557,40558,40559,40560,40561,40562,40563,40564,40565,40566,40567,40568,40569,40570,40571,40572,40573,40574,40575,40576,40577,40578,40579,40580,40581,40582,40583,40584,40585,40586,40587,40588,40589,40590,40591,40592,40593,40594,40595,40596,40597,40598,40599,40600,40601,40602,40603,40604,40605,40606,40607,40608,40609,40610,40611,40612,40613,40614,40615,40616,40617,40618,40619,40620,40621,40622,40623,40624,40625,40626,40627,40628,40629,40630,40631,40632,40633,40634,40635,40636,40637,40638,40639,40640,40641,40642,40643,40644,40645,40646,40647,40648,40649,40650,40651,40652,40653,40654,40655,40656,40657,40658,40659,40660,40661,40662,40663,40664,40665,40666,40667,40668,40669,40670,40671,40672,40673,40674,40675,40676,40677,40678,40679,40680,40681,40682,40683,40684,40685,40686,40687,40688,40689,40690,40691,40692,40693,40694,40695,40696,40697,40698,40699,40700,40701,40702,40703,40704,40705,40706,40707,40708,40709,40710,40711,40712,40713,40714,40715,40716,40717,40718,40719,40720,40721,40722,40723,40724,40725,40726,40727,40728,40729,40730,40731,40732,40733,40734,40735,40736,40737,40738,40739,40740,40741,40742,40743,40744,40745,40746,40747,40748,40749,40750,40751,40752,40753,40754,40755,40756,40757,40758,40759,40760,40761,40762,40763,40764,40765,40766,40767,40768,40769,40770,40771,40772,40773,40774,40775,40776,40777,40778,40779,40780,40781,40782,40783,40784,40785,40786,40787,40788,40789,40790,40791,40792,40793,40794,40795,40796,40797,40798,40799,40800,40801,40802,40803,40804,40805,40806,40807,40808,40809,40810,40811,40812,40813,40814,40815,40816,40817,40818,40819,40820,40821,40822,40823,40824,40825,40826,40827,40828,40829,40830,40831,40832,40833,40834,40835,40836,40837,40838,40839,40840,40841,40842,40843,40844,40845,40846,40847,40848,40849,40850,40851,40852,40853,40854,40855,40856,40857,40858,40859,40860,40861,40862,40863,40864,40865,40866,40867,40868,40869,40870,40871,40872,40873,40874,40875,40876,40877,40878,40879,40880,40881,40882,40883,40884,40885,40886,40887,40888,40889,40890,40891,40892,40893,40894,40895,40896,40897,40898,40899,40900,40901,40902,40903,40904,40905,40906,40907,40908,40960,40961,40962,40963,40964,40965,40966,40967,40968,40969,40970,40971,40972,40973,40974,40975,40976,40977,40978,40979,40980,40981,40982,40983,40984,40985,40986,40987,40988,40989,40990,40991,40992,40993,40994,40995,40996,40997,40998,40999,41000,41001,41002,41003,41004,41005,41006,41007,41008,41009,41010,41011,41012,41013,41014,41015,41016,41017,41018,41019,41020,41021,41022,41023,41024,41025,41026,41027,41028,41029,41030,41031,41032,41033,41034,41035,41036,41037,41038,41039,41040,41041,41042,41043,41044,41045,41046,41047,41048,41049,41050,41051,41052,41053,41054,41055,41056,41057,41058,41059,41060,41061,41062,41063,41064,41065,41066,41067,41068,41069,41070,41071,41072,41073,41074,41075,41076,41077,41078,41079,41080,41081,41082,41083,41084,41085,41086,41087,41088,41089,41090,41091,41092,41093,41094,41095,41096,41097,41098,41099,41100,41101,41102,41103,41104,41105,41106,41107,41108,41109,41110,41111,41112,41113,41114,41115,41116,41117,41118,41119,41120,41121,41122,41123,41124,41125,41126,41127,41128,41129,41130,41131,41132,41133,41134,41135,41136,41137,41138,41139,41140,41141,41142,41143,41144,41145,41146,41147,41148,41149,41150,41151,41152,41153,41154,41155,41156,41157,41158,41159,41160,41161,41162,41163,41164,41165,41166,41167,41168,41169,41170,41171,41172,41173,41174,41175,41176,41177,41178,41179,41180,41181,41182,41183,41184,41185,41186,41187,41188,41189,41190,41191,41192,41193,41194,41195,41196,41197,41198,41199,41200,41201,41202,41203,41204,41205,41206,41207,41208,41209,41210,41211,41212,41213,41214,41215,41216,41217,41218,41219,41220,41221,41222,41223,41224,41225,41226,41227,41228,41229,41230,41231,41232,41233,41234,41235,41236,41237,41238,41239,41240,41241,41242,41243,41244,41245,41246,41247,41248,41249,41250,41251,41252,41253,41254,41255,41256,41257,41258,41259,41260,41261,41262,41263,41264,41265,41266,41267,41268,41269,41270,41271,41272,41273,41274,41275,41276,41277,41278,41279,41280,41281,41282,41283,41284,41285,41286,41287,41288,41289,41290,41291,41292,41293,41294,41295,41296,41297,41298,41299,41300,41301,41302,41303,41304,41305,41306,41307,41308,41309,41310,41311,41312,41313,41314,41315,41316,41317,41318,41319,41320,41321,41322,41323,41324,41325,41326,41327,41328,41329,41330,41331,41332,41333,41334,41335,41336,41337,41338,41339,41340,41341,41342,41343,41344,41345,41346,41347,41348,41349,41350,41351,41352,41353,41354,41355,41356,41357,41358,41359,41360,41361,41362,41363,41364,41365,41366,41367,41368,41369,41370,41371,41372,41373,41374,41375,41376,41377,41378,41379,41380,41381,41382,41383,41384,41385,41386,41387,41388,41389,41390,41391,41392,41393,41394,41395,41396,41397,41398,41399,41400,41401,41402,41403,41404,41405,41406,41407,41408,41409,41410,41411,41412,41413,41414,41415,41416,41417,41418,41419,41420,41421,41422,41423,41424,41425,41426,41427,41428,41429,41430,41431,41432,41433,41434,41435,41436,41437,41438,41439,41440,41441,41442,41443,41444,41445,41446,41447,41448,41449,41450,41451,41452,41453,41454,41455,41456,41457,41458,41459,41460,41461,41462,41463,41464,41465,41466,41467,41468,41469,41470,41471,41472,41473,41474,41475,41476,41477,41478,41479,41480,41481,41482,41483,41484,41485,41486,41487,41488,41489,41490,41491,41492,41493,41494,41495,41496,41497,41498,41499,41500,41501,41502,41503,41504,41505,41506,41507,41508,41509,41510,41511,41512,41513,41514,41515,41516,41517,41518,41519,41520,41521,41522,41523,41524,41525,41526,41527,41528,41529,41530,41531,41532,41533,41534,41535,41536,41537,41538,41539,41540,41541,41542,41543,41544,41545,41546,41547,41548,41549,41550,41551,41552,41553,41554,41555,41556,41557,41558,41559,41560,41561,41562,41563,41564,41565,41566,41567,41568,41569,41570,41571,41572,41573,41574,41575,41576,41577,41578,41579,41580,41581,41582,41583,41584,41585,41586,41587,41588,41589,41590,41591,41592,41593,41594,41595,41596,41597,41598,41599,41600,41601,41602,41603,41604,41605,41606,41607,41608,41609,41610,41611,41612,41613,41614,41615,41616,41617,41618,41619,41620,41621,41622,41623,41624,41625,41626,41627,41628,41629,41630,41631,41632,41633,41634,41635,41636,41637,41638,41639,41640,41641,41642,41643,41644,41645,41646,41647,41648,41649,41650,41651,41652,41653,41654,41655,41656,41657,41658,41659,41660,41661,41662,41663,41664,41665,41666,41667,41668,41669,41670,41671,41672,41673,41674,41675,41676,41677,41678,41679,41680,41681,41682,41683,41684,41685,41686,41687,41688,41689,41690,41691,41692,41693,41694,41695,41696,41697,41698,41699,41700,41701,41702,41703,41704,41705,41706,41707,41708,41709,41710,41711,41712,41713,41714,41715,41716,41717,41718,41719,41720,41721,41722,41723,41724,41725,41726,41727,41728,41729,41730,41731,41732,41733,41734,41735,41736,41737,41738,41739,41740,41741,41742,41743,41744,41745,41746,41747,41748,41749,41750,41751,41752,41753,41754,41755,41756,41757,41758,41759,41760,41761,41762,41763,41764,41765,41766,41767,41768,41769,41770,41771,41772,41773,41774,41775,41776,41777,41778,41779,41780,41781,41782,41783,41784,41785,41786,41787,41788,41789,41790,41791,41792,41793,41794,41795,41796,41797,41798,41799,41800,41801,41802,41803,41804,41805,41806,41807,41808,41809,41810,41811,41812,41813,41814,41815,41816,41817,41818,41819,41820,41821,41822,41823,41824,41825,41826,41827,41828,41829,41830,41831,41832,41833,41834,41835,41836,41837,41838,41839,41840,41841,41842,41843,41844,41845,41846,41847,41848,41849,41850,41851,41852,41853,41854,41855,41856,41857,41858,41859,41860,41861,41862,41863,41864,41865,41866,41867,41868,41869,41870,41871,41872,41873,41874,41875,41876,41877,41878,41879,41880,41881,41882,41883,41884,41885,41886,41887,41888,41889,41890,41891,41892,41893,41894,41895,41896,41897,41898,41899,41900,41901,41902,41903,41904,41905,41906,41907,41908,41909,41910,41911,41912,41913,41914,41915,41916,41917,41918,41919,41920,41921,41922,41923,41924,41925,41926,41927,41928,41929,41930,41931,41932,41933,41934,41935,41936,41937,41938,41939,41940,41941,41942,41943,41944,41945,41946,41947,41948,41949,41950,41951,41952,41953,41954,41955,41956,41957,41958,41959,41960,41961,41962,41963,41964,41965,41966,41967,41968,41969,41970,41971,41972,41973,41974,41975,41976,41977,41978,41979,41980,41981,41982,41983,41984,41985,41986,41987,41988,41989,41990,41991,41992,41993,41994,41995,41996,41997,41998,41999,42000,42001,42002,42003,42004,42005,42006,42007,42008,42009,42010,42011,42012,42013,42014,42015,42016,42017,42018,42019,42020,42021,42022,42023,42024,42025,42026,42027,42028,42029,42030,42031,42032,42033,42034,42035,42036,42037,42038,42039,42040,42041,42042,42043,42044,42045,42046,42047,42048,42049,42050,42051,42052,42053,42054,42055,42056,42057,42058,42059,42060,42061,42062,42063,42064,42065,42066,42067,42068,42069,42070,42071,42072,42073,42074,42075,42076,42077,42078,42079,42080,42081,42082,42083,42084,42085,42086,42087,42088,42089,42090,42091,42092,42093,42094,42095,42096,42097,42098,42099,42100,42101,42102,42103,42104,42105,42106,42107,42108,42109,42110,42111,42112,42113,42114,42115,42116,42117,42118,42119,42120,42121,42122,42123,42124,42192,42193,42194,42195,42196,42197,42198,42199,42200,42201,42202,42203,42204,42205,42206,42207,42208,42209,42210,42211,42212,42213,42214,42215,42216,42217,42218,42219,42220,42221,42222,42223,42224,42225,42226,42227,42228,42229,42230,42231,42232,42233,42234,42235,42236,42237,42240,42241,42242,42243,42244,42245,42246,42247,42248,42249,42250,42251,42252,42253,42254,42255,42256,42257,42258,42259,42260,42261,42262,42263,42264,42265,42266,42267,42268,42269,42270,42271,42272,42273,42274,42275,42276,42277,42278,42279,42280,42281,42282,42283,42284,42285,42286,42287,42288,42289,42290,42291,42292,42293,42294,42295,42296,42297,42298,42299,42300,42301,42302,42303,42304,42305,42306,42307,42308,42309,42310,42311,42312,42313,42314,42315,42316,42317,42318,42319,42320,42321,42322,42323,42324,42325,42326,42327,42328,42329,42330,42331,42332,42333,42334,42335,42336,42337,42338,42339,42340,42341,42342,42343,42344,42345,42346,42347,42348,42349,42350,42351,42352,42353,42354,42355,42356,42357,42358,42359,42360,42361,42362,42363,42364,42365,42366,42367,42368,42369,42370,42371,42372,42373,42374,42375,42376,42377,42378,42379,42380,42381,42382,42383,42384,42385,42386,42387,42388,42389,42390,42391,42392,42393,42394,42395,42396,42397,42398,42399,42400,42401,42402,42403,42404,42405,42406,42407,42408,42409,42410,42411,42412,42413,42414,42415,42416,42417,42418,42419,42420,42421,42422,42423,42424,42425,42426,42427,42428,42429,42430,42431,42432,42433,42434,42435,42436,42437,42438,42439,42440,42441,42442,42443,42444,42445,42446,42447,42448,42449,42450,42451,42452,42453,42454,42455,42456,42457,42458,42459,42460,42461,42462,42463,42464,42465,42466,42467,42468,42469,42470,42471,42472,42473,42474,42475,42476,42477,42478,42479,42480,42481,42482,42483,42484,42485,42486,42487,42488,42489,42490,42491,42492,42493,42494,42495,42496,42497,42498,42499,42500,42501,42502,42503,42504,42505,42506,42507,42508,42512,42513,42514,42515,42516,42517,42518,42519,42520,42521,42522,42523,42524,42525,42526,42527,42538,42539,42560,42561,42562,42563,42564,42565,42566,42567,42568,42569,42570,42571,42572,42573,42574,42575,42576,42577,42578,42579,42580,42581,42582,42583,42584,42585,42586,42587,42588,42589,42590,42591,42592,42593,42594,42595,42596,42597,42598,42599,42600,42601,42602,42603,42604,42605,42606,42623,42624,42625,42626,42627,42628,42629,42630,42631,42632,42633,42634,42635,42636,42637,42638,42639,42640,42641,42642,42643,42644,42645,42646,42647,42656,42657,42658,42659,42660,42661,42662,42663,42664,42665,42666,42667,42668,42669,42670,42671,42672,42673,42674,42675,42676,42677,42678,42679,42680,42681,42682,42683,42684,42685,42686,42687,42688,42689,42690,42691,42692,42693,42694,42695,42696,42697,42698,42699,42700,42701,42702,42703,42704,42705,42706,42707,42708,42709,42710,42711,42712,42713,42714,42715,42716,42717,42718,42719,42720,42721,42722,42723,42724,42725,42726,42727,42728,42729,42730,42731,42732,42733,42734,42735,42775,42776,42777,42778,42779,42780,42781,42782,42783,42786,42787,42788,42789,42790,42791,42792,42793,42794,42795,42796,42797,42798,42799,42800,42801,42802,42803,42804,42805,42806,42807,42808,42809,42810,42811,42812,42813,42814,42815,42816,42817,42818,42819,42820,42821,42822,42823,42824,42825,42826,42827,42828,42829,42830,42831,42832,42833,42834,42835,42836,42837,42838,42839,42840,42841,42842,42843,42844,42845,42846,42847,42848,42849,42850,42851,42852,42853,42854,42855,42856,42857,42858,42859,42860,42861,42862,42863,42864,42865,42866,42867,42868,42869,42870,42871,42872,42873,42874,42875,42876,42877,42878,42879,42880,42881,42882,42883,42884,42885,42886,42887,42888,42891,42892,42893,42894,42896,42897,42898,42899,42912,42913,42914,42915,42916,42917,42918,42919,42920,42921,42922,43000,43001,43002,43003,43004,43005,43006,43007,43008,43009,43011,43012,43013,43015,43016,43017,43018,43020,43021,43022,43023,43024,43025,43026,43027,43028,43029,43030,43031,43032,43033,43034,43035,43036,43037,43038,43039,43040,43041,43042,43072,43073,43074,43075,43076,43077,43078,43079,43080,43081,43082,43083,43084,43085,43086,43087,43088,43089,43090,43091,43092,43093,43094,43095,43096,43097,43098,43099,43100,43101,43102,43103,43104,43105,43106,43107,43108,43109,43110,43111,43112,43113,43114,43115,43116,43117,43118,43119,43120,43121,43122,43123,43138,43139,43140,43141,43142,43143,43144,43145,43146,43147,43148,43149,43150,43151,43152,43153,43154,43155,43156,43157,43158,43159,43160,43161,43162,43163,43164,43165,43166,43167,43168,43169,43170,43171,43172,43173,43174,43175,43176,43177,43178,43179,43180,43181,43182,43183,43184,43185,43186,43187,43250,43251,43252,43253,43254,43255,43259,43274,43275,43276,43277,43278,43279,43280,43281,43282,43283,43284,43285,43286,43287,43288,43289,43290,43291,43292,43293,43294,43295,43296,43297,43298,43299,43300,43301,43312,43313,43314,43315,43316,43317,43318,43319,43320,43321,43322,43323,43324,43325,43326,43327,43328,43329,43330,43331,43332,43333,43334,43360,43361,43362,43363,43364,43365,43366,43367,43368,43369,43370,43371,43372,43373,43374,43375,43376,43377,43378,43379,43380,43381,43382,43383,43384,43385,43386,43387,43388,43396,43397,43398,43399,43400,43401,43402,43403,43404,43405,43406,43407,43408,43409,43410,43411,43412,43413,43414,43415,43416,43417,43418,43419,43420,43421,43422,43423,43424,43425,43426,43427,43428,43429,43430,43431,43432,43433,43434,43435,43436,43437,43438,43439,43440,43441,43442,43471,43520,43521,43522,43523,43524,43525,43526,43527,43528,43529,43530,43531,43532,43533,43534,43535,43536,43537,43538,43539,43540,43541,43542,43543,43544,43545,43546,43547,43548,43549,43550,43551,43552,43553,43554,43555,43556,43557,43558,43559,43560,43584,43585,43586,43588,43589,43590,43591,43592,43593,43594,43595,43616,43617,43618,43619,43620,43621,43622,43623,43624,43625,43626,43627,43628,43629,43630,43631,43632,43633,43634,43635,43636,43637,43638,43642,43648,43649,43650,43651,43652,43653,43654,43655,43656,43657,43658,43659,43660,43661,43662,43663,43664,43665,43666,43667,43668,43669,43670,43671,43672,43673,43674,43675,43676,43677,43678,43679,43680,43681,43682,43683,43684,43685,43686,43687,43688,43689,43690,43691,43692,43693,43694,43695,43697,43701,43702,43705,43706,43707,43708,43709,43712,43714,43739,43740,43741,43744,43745,43746,43747,43748,43749,43750,43751,43752,43753,43754,43762,43763,43764,43777,43778,43779,43780,43781,43782,43785,43786,43787,43788,43789,43790,43793,43794,43795,43796,43797,43798,43808,43809,43810,43811,43812,43813,43814,43816,43817,43818,43819,43820,43821,43822,43968,43969,43970,43971,43972,43973,43974,43975,43976,43977,43978,43979,43980,43981,43982,43983,43984,43985,43986,43987,43988,43989,43990,43991,43992,43993,43994,43995,43996,43997,43998,43999,44000,44001,44002,44032,44033,44034,44035,44036,44037,44038,44039,44040,44041,44042,44043,44044,44045,44046,44047,44048,44049,44050,44051,44052,44053,44054,44055,44056,44057,44058,44059,44060,44061,44062,44063,44064,44065,44066,44067,44068,44069,44070,44071,44072,44073,44074,44075,44076,44077,44078,44079,44080,44081,44082,44083,44084,44085,44086,44087,44088,44089,44090,44091,44092,44093,44094,44095,44096,44097,44098,44099,44100,44101,44102,44103,44104,44105,44106,44107,44108,44109,44110,44111,44112,44113,44114,44115,44116,44117,44118,44119,44120,44121,44122,44123,44124,44125,44126,44127,44128,44129,44130,44131,44132,44133,44134,44135,44136,44137,44138,44139,44140,44141,44142,44143,44144,44145,44146,44147,44148,44149,44150,44151,44152,44153,44154,44155,44156,44157,44158,44159,44160,44161,44162,44163,44164,44165,44166,44167,44168,44169,44170,44171,44172,44173,44174,44175,44176,44177,44178,44179,44180,44181,44182,44183,44184,44185,44186,44187,44188,44189,44190,44191,44192,44193,44194,44195,44196,44197,44198,44199,44200,44201,44202,44203,44204,44205,44206,44207,44208,44209,44210,44211,44212,44213,44214,44215,44216,44217,44218,44219,44220,44221,44222,44223,44224,44225,44226,44227,44228,44229,44230,44231,44232,44233,44234,44235,44236,44237,44238,44239,44240,44241,44242,44243,44244,44245,44246,44247,44248,44249,44250,44251,44252,44253,44254,44255,44256,44257,44258,44259,44260,44261,44262,44263,44264,44265,44266,44267,44268,44269,44270,44271,44272,44273,44274,44275,44276,44277,44278,44279,44280,44281,44282,44283,44284,44285,44286,44287,44288,44289,44290,44291,44292,44293,44294,44295,44296,44297,44298,44299,44300,44301,44302,44303,44304,44305,44306,44307,44308,44309,44310,44311,44312,44313,44314,44315,44316,44317,44318,44319,44320,44321,44322,44323,44324,44325,44326,44327,44328,44329,44330,44331,44332,44333,44334,44335,44336,44337,44338,44339,44340,44341,44342,44343,44344,44345,44346,44347,44348,44349,44350,44351,44352,44353,44354,44355,44356,44357,44358,44359,44360,44361,44362,44363,44364,44365,44366,44367,44368,44369,44370,44371,44372,44373,44374,44375,44376,44377,44378,44379,44380,44381,44382,44383,44384,44385,44386,44387,44388,44389,44390,44391,44392,44393,44394,44395,44396,44397,44398,44399,44400,44401,44402,44403,44404,44405,44406,44407,44408,44409,44410,44411,44412,44413,44414,44415,44416,44417,44418,44419,44420,44421,44422,44423,44424,44425,44426,44427,44428,44429,44430,44431,44432,44433,44434,44435,44436,44437,44438,44439,44440,44441,44442,44443,44444,44445,44446,44447,44448,44449,44450,44451,44452,44453,44454,44455,44456,44457,44458,44459,44460,44461,44462,44463,44464,44465,44466,44467,44468,44469,44470,44471,44472,44473,44474,44475,44476,44477,44478,44479,44480,44481,44482,44483,44484,44485,44486,44487,44488,44489,44490,44491,44492,44493,44494,44495,44496,44497,44498,44499,44500,44501,44502,44503,44504,44505,44506,44507,44508,44509,44510,44511,44512,44513,44514,44515,44516,44517,44518,44519,44520,44521,44522,44523,44524,44525,44526,44527,44528,44529,44530,44531,44532,44533,44534,44535,44536,44537,44538,44539,44540,44541,44542,44543,44544,44545,44546,44547,44548,44549,44550,44551,44552,44553,44554,44555,44556,44557,44558,44559,44560,44561,44562,44563,44564,44565,44566,44567,44568,44569,44570,44571,44572,44573,44574,44575,44576,44577,44578,44579,44580,44581,44582,44583,44584,44585,44586,44587,44588,44589,44590,44591,44592,44593,44594,44595,44596,44597,44598,44599,44600,44601,44602,44603,44604,44605,44606,44607,44608,44609,44610,44611,44612,44613,44614,44615,44616,44617,44618,44619,44620,44621,44622,44623,44624,44625,44626,44627,44628,44629,44630,44631,44632,44633,44634,44635,44636,44637,44638,44639,44640,44641,44642,44643,44644,44645,44646,44647,44648,44649,44650,44651,44652,44653,44654,44655,44656,44657,44658,44659,44660,44661,44662,44663,44664,44665,44666,44667,44668,44669,44670,44671,44672,44673,44674,44675,44676,44677,44678,44679,44680,44681,44682,44683,44684,44685,44686,44687,44688,44689,44690,44691,44692,44693,44694,44695,44696,44697,44698,44699,44700,44701,44702,44703,44704,44705,44706,44707,44708,44709,44710,44711,44712,44713,44714,44715,44716,44717,44718,44719,44720,44721,44722,44723,44724,44725,44726,44727,44728,44729,44730,44731,44732,44733,44734,44735,44736,44737,44738,44739,44740,44741,44742,44743,44744,44745,44746,44747,44748,44749,44750,44751,44752,44753,44754,44755,44756,44757,44758,44759,44760,44761,44762,44763,44764,44765,44766,44767,44768,44769,44770,44771,44772,44773,44774,44775,44776,44777,44778,44779,44780,44781,44782,44783,44784,44785,44786,44787,44788,44789,44790,44791,44792,44793,44794,44795,44796,44797,44798,44799,44800,44801,44802,44803,44804,44805,44806,44807,44808,44809,44810,44811,44812,44813,44814,44815,44816,44817,44818,44819,44820,44821,44822,44823,44824,44825,44826,44827,44828,44829,44830,44831,44832,44833,44834,44835,44836,44837,44838,44839,44840,44841,44842,44843,44844,44845,44846,44847,44848,44849,44850,44851,44852,44853,44854,44855,44856,44857,44858,44859,44860,44861,44862,44863,44864,44865,44866,44867,44868,44869,44870,44871,44872,44873,44874,44875,44876,44877,44878,44879,44880,44881,44882,44883,44884,44885,44886,44887,44888,44889,44890,44891,44892,44893,44894,44895,44896,44897,44898,44899,44900,44901,44902,44903,44904,44905,44906,44907,44908,44909,44910,44911,44912,44913,44914,44915,44916,44917,44918,44919,44920,44921,44922,44923,44924,44925,44926,44927,44928,44929,44930,44931,44932,44933,44934,44935,44936,44937,44938,44939,44940,44941,44942,44943,44944,44945,44946,44947,44948,44949,44950,44951,44952,44953,44954,44955,44956,44957,44958,44959,44960,44961,44962,44963,44964,44965,44966,44967,44968,44969,44970,44971,44972,44973,44974,44975,44976,44977,44978,44979,44980,44981,44982,44983,44984,44985,44986,44987,44988,44989,44990,44991,44992,44993,44994,44995,44996,44997,44998,44999,45000,45001,45002,45003,45004,45005,45006,45007,45008,45009,45010,45011,45012,45013,45014,45015,45016,45017,45018,45019,45020,45021,45022,45023,45024,45025,45026,45027,45028,45029,45030,45031,45032,45033,45034,45035,45036,45037,45038,45039,45040,45041,45042,45043,45044,45045,45046,45047,45048,45049,45050,45051,45052,45053,45054,45055,45056,45057,45058,45059,45060,45061,45062,45063,45064,45065,45066,45067,45068,45069,45070,45071,45072,45073,45074,45075,45076,45077,45078,45079,45080,45081,45082,45083,45084,45085,45086,45087,45088,45089,45090,45091,45092,45093,45094,45095,45096,45097,45098,45099,45100,45101,45102,45103,45104,45105,45106,45107,45108,45109,45110,45111,45112,45113,45114,45115,45116,45117,45118,45119,45120,45121,45122,45123,45124,45125,45126,45127,45128,45129,45130,45131,45132,45133,45134,45135,45136,45137,45138,45139,45140,45141,45142,45143,45144,45145,45146,45147,45148,45149,45150,45151,45152,45153,45154,45155,45156,45157,45158,45159,45160,45161,45162,45163,45164,45165,45166,45167,45168,45169,45170,45171,45172,45173,45174,45175,45176,45177,45178,45179,45180,45181,45182,45183,45184,45185,45186,45187,45188,45189,45190,45191,45192,45193,45194,45195,45196,45197,45198,45199,45200,45201,45202,45203,45204,45205,45206,45207,45208,45209,45210,45211,45212,45213,45214,45215,45216,45217,45218,45219,45220,45221,45222,45223,45224,45225,45226,45227,45228,45229,45230,45231,45232,45233,45234,45235,45236,45237,45238,45239,45240,45241,45242,45243,45244,45245,45246,45247,45248,45249,45250,45251,45252,45253,45254,45255,45256,45257,45258,45259,45260,45261,45262,45263,45264,45265,45266,45267,45268,45269,45270,45271,45272,45273,45274,45275,45276,45277,45278,45279,45280,45281,45282,45283,45284,45285,45286,45287,45288,45289,45290,45291,45292,45293,45294,45295,45296,45297,45298,45299,45300,45301,45302,45303,45304,45305,45306,45307,45308,45309,45310,45311,45312,45313,45314,45315,45316,45317,45318,45319,45320,45321,45322,45323,45324,45325,45326,45327,45328,45329,45330,45331,45332,45333,45334,45335,45336,45337,45338,45339,45340,45341,45342,45343,45344,45345,45346,45347,45348,45349,45350,45351,45352,45353,45354,45355,45356,45357,45358,45359,45360,45361,45362,45363,45364,45365,45366,45367,45368,45369,45370,45371,45372,45373,45374,45375,45376,45377,45378,45379,45380,45381,45382,45383,45384,45385,45386,45387,45388,45389,45390,45391,45392,45393,45394,45395,45396,45397,45398,45399,45400,45401,45402,45403,45404,45405,45406,45407,45408,45409,45410,45411,45412,45413,45414,45415,45416,45417,45418,45419,45420,45421,45422,45423,45424,45425,45426,45427,45428,45429,45430,45431,45432,45433,45434,45435,45436,45437,45438,45439,45440,45441,45442,45443,45444,45445,45446,45447,45448,45449,45450,45451,45452,45453,45454,45455,45456,45457,45458,45459,45460,45461,45462,45463,45464,45465,45466,45467,45468,45469,45470,45471,45472,45473,45474,45475,45476,45477,45478,45479,45480,45481,45482,45483,45484,45485,45486,45487,45488,45489,45490,45491,45492,45493,45494,45495,45496,45497,45498,45499,45500,45501,45502,45503,45504,45505,45506,45507,45508,45509,45510,45511,45512,45513,45514,45515,45516,45517,45518,45519,45520,45521,45522,45523,45524,45525,45526,45527,45528,45529,45530,45531,45532,45533,45534,45535,45536,45537,45538,45539,45540,45541,45542,45543,45544,45545,45546,45547,45548,45549,45550,45551,45552,45553,45554,45555,45556,45557,45558,45559,45560,45561,45562,45563,45564,45565,45566,45567,45568,45569,45570,45571,45572,45573,45574,45575,45576,45577,45578,45579,45580,45581,45582,45583,45584,45585,45586,45587,45588,45589,45590,45591,45592,45593,45594,45595,45596,45597,45598,45599,45600,45601,45602,45603,45604,45605,45606,45607,45608,45609,45610,45611,45612,45613,45614,45615,45616,45617,45618,45619,45620,45621,45622,45623,45624,45625,45626,45627,45628,45629,45630,45631,45632,45633,45634,45635,45636,45637,45638,45639,45640,45641,45642,45643,45644,45645,45646,45647,45648,45649,45650,45651,45652,45653,45654,45655,45656,45657,45658,45659,45660,45661,45662,45663,45664,45665,45666,45667,45668,45669,45670,45671,45672,45673,45674,45675,45676,45677,45678,45679,45680,45681,45682,45683,45684,45685,45686,45687,45688,45689,45690,45691,45692,45693,45694,45695,45696,45697,45698,45699,45700,45701,45702,45703,45704,45705,45706,45707,45708,45709,45710,45711,45712,45713,45714,45715,45716,45717,45718,45719,45720,45721,45722,45723,45724,45725,45726,45727,45728,45729,45730,45731,45732,45733,45734,45735,45736,45737,45738,45739,45740,45741,45742,45743,45744,45745,45746,45747,45748,45749,45750,45751,45752,45753,45754,45755,45756,45757,45758,45759,45760,45761,45762,45763,45764,45765,45766,45767,45768,45769,45770,45771,45772,45773,45774,45775,45776,45777,45778,45779,45780,45781,45782,45783,45784,45785,45786,45787,45788,45789,45790,45791,45792,45793,45794,45795,45796,45797,45798,45799,45800,45801,45802,45803,45804,45805,45806,45807,45808,45809,45810,45811,45812,45813,45814,45815,45816,45817,45818,45819,45820,45821,45822,45823,45824,45825,45826,45827,45828,45829,45830,45831,45832,45833,45834,45835,45836,45837,45838,45839,45840,45841,45842,45843,45844,45845,45846,45847,45848,45849,45850,45851,45852,45853,45854,45855,45856,45857,45858,45859,45860,45861,45862,45863,45864,45865,45866,45867,45868,45869,45870,45871,45872,45873,45874,45875,45876,45877,45878,45879,45880,45881,45882,45883,45884,45885,45886,45887,45888,45889,45890,45891,45892,45893,45894,45895,45896,45897,45898,45899,45900,45901,45902,45903,45904,45905,45906,45907,45908,45909,45910,45911,45912,45913,45914,45915,45916,45917,45918,45919,45920,45921,45922,45923,45924,45925,45926,45927,45928,45929,45930,45931,45932,45933,45934,45935,45936,45937,45938,45939,45940,45941,45942,45943,45944,45945,45946,45947,45948,45949,45950,45951,45952,45953,45954,45955,45956,45957,45958,45959,45960,45961,45962,45963,45964,45965,45966,45967,45968,45969,45970,45971,45972,45973,45974,45975,45976,45977,45978,45979,45980,45981,45982,45983,45984,45985,45986,45987,45988,45989,45990,45991,45992,45993,45994,45995,45996,45997,45998,45999,46000,46001,46002,46003,46004,46005,46006,46007,46008,46009,46010,46011,46012,46013,46014,46015,46016,46017,46018,46019,46020,46021,46022,46023,46024,46025,46026,46027,46028,46029,46030,46031,46032,46033,46034,46035,46036,46037,46038,46039,46040,46041,46042,46043,46044,46045,46046,46047,46048,46049,46050,46051,46052,46053,46054,46055,46056,46057,46058,46059,46060,46061,46062,46063,46064,46065,46066,46067,46068,46069,46070,46071,46072,46073,46074,46075,46076,46077,46078,46079,46080,46081,46082,46083,46084,46085,46086,46087,46088,46089,46090,46091,46092,46093,46094,46095,46096,46097,46098,46099,46100,46101,46102,46103,46104,46105,46106,46107,46108,46109,46110,46111,46112,46113,46114,46115,46116,46117,46118,46119,46120,46121,46122,46123,46124,46125,46126,46127,46128,46129,46130,46131,46132,46133,46134,46135,46136,46137,46138,46139,46140,46141,46142,46143,46144,46145,46146,46147,46148,46149,46150,46151,46152,46153,46154,46155,46156,46157,46158,46159,46160,46161,46162,46163,46164,46165,46166,46167,46168,46169,46170,46171,46172,46173,46174,46175,46176,46177,46178,46179,46180,46181,46182,46183,46184,46185,46186,46187,46188,46189,46190,46191,46192,46193,46194,46195,46196,46197,46198,46199,46200,46201,46202,46203,46204,46205,46206,46207,46208,46209,46210,46211,46212,46213,46214,46215,46216,46217,46218,46219,46220,46221,46222,46223,46224,46225,46226,46227,46228,46229,46230,46231,46232,46233,46234,46235,46236,46237,46238,46239,46240,46241,46242,46243,46244,46245,46246,46247,46248,46249,46250,46251,46252,46253,46254,46255,46256,46257,46258,46259,46260,46261,46262,46263,46264,46265,46266,46267,46268,46269,46270,46271,46272,46273,46274,46275,46276,46277,46278,46279,46280,46281,46282,46283,46284,46285,46286,46287,46288,46289,46290,46291,46292,46293,46294,46295,46296,46297,46298,46299,46300,46301,46302,46303,46304,46305,46306,46307,46308,46309,46310,46311,46312,46313,46314,46315,46316,46317,46318,46319,46320,46321,46322,46323,46324,46325,46326,46327,46328,46329,46330,46331,46332,46333,46334,46335,46336,46337,46338,46339,46340,46341,46342,46343,46344,46345,46346,46347,46348,46349,46350,46351,46352,46353,46354,46355,46356,46357,46358,46359,46360,46361,46362,46363,46364,46365,46366,46367,46368,46369,46370,46371,46372,46373,46374,46375,46376,46377,46378,46379,46380,46381,46382,46383,46384,46385,46386,46387,46388,46389,46390,46391,46392,46393,46394,46395,46396,46397,46398,46399,46400,46401,46402,46403,46404,46405,46406,46407,46408,46409,46410,46411,46412,46413,46414,46415,46416,46417,46418,46419,46420,46421,46422,46423,46424,46425,46426,46427,46428,46429,46430,46431,46432,46433,46434,46435,46436,46437,46438,46439,46440,46441,46442,46443,46444,46445,46446,46447,46448,46449,46450,46451,46452,46453,46454,46455,46456,46457,46458,46459,46460,46461,46462,46463,46464,46465,46466,46467,46468,46469,46470,46471,46472,46473,46474,46475,46476,46477,46478,46479,46480,46481,46482,46483,46484,46485,46486,46487,46488,46489,46490,46491,46492,46493,46494,46495,46496,46497,46498,46499,46500,46501,46502,46503,46504,46505,46506,46507,46508,46509,46510,46511,46512,46513,46514,46515,46516,46517,46518,46519,46520,46521,46522,46523,46524,46525,46526,46527,46528,46529,46530,46531,46532,46533,46534,46535,46536,46537,46538,46539,46540,46541,46542,46543,46544,46545,46546,46547,46548,46549,46550,46551,46552,46553,46554,46555,46556,46557,46558,46559,46560,46561,46562,46563,46564,46565,46566,46567,46568,46569,46570,46571,46572,46573,46574,46575,46576,46577,46578,46579,46580,46581,46582,46583,46584,46585,46586,46587,46588,46589,46590,46591,46592,46593,46594,46595,46596,46597,46598,46599,46600,46601,46602,46603,46604,46605,46606,46607,46608,46609,46610,46611,46612,46613,46614,46615,46616,46617,46618,46619,46620,46621,46622,46623,46624,46625,46626,46627,46628,46629,46630,46631,46632,46633,46634,46635,46636,46637,46638,46639,46640,46641,46642,46643,46644,46645,46646,46647,46648,46649,46650,46651,46652,46653,46654,46655,46656,46657,46658,46659,46660,46661,46662,46663,46664,46665,46666,46667,46668,46669,46670,46671,46672,46673,46674,46675,46676,46677,46678,46679,46680,46681,46682,46683,46684,46685,46686,46687,46688,46689,46690,46691,46692,46693,46694,46695,46696,46697,46698,46699,46700,46701,46702,46703,46704,46705,46706,46707,46708,46709,46710,46711,46712,46713,46714,46715,46716,46717,46718,46719,46720,46721,46722,46723,46724,46725,46726,46727,46728,46729,46730,46731,46732,46733,46734,46735,46736,46737,46738,46739,46740,46741,46742,46743,46744,46745,46746,46747,46748,46749,46750,46751,46752,46753,46754,46755,46756,46757,46758,46759,46760,46761,46762,46763,46764,46765,46766,46767,46768,46769,46770,46771,46772,46773,46774,46775,46776,46777,46778,46779,46780,46781,46782,46783,46784,46785,46786,46787,46788,46789,46790,46791,46792,46793,46794,46795,46796,46797,46798,46799,46800,46801,46802,46803,46804,46805,46806,46807,46808,46809,46810,46811,46812,46813,46814,46815,46816,46817,46818,46819,46820,46821,46822,46823,46824,46825,46826,46827,46828,46829,46830,46831,46832,46833,46834,46835,46836,46837,46838,46839,46840,46841,46842,46843,46844,46845,46846,46847,46848,46849,46850,46851,46852,46853,46854,46855,46856,46857,46858,46859,46860,46861,46862,46863,46864,46865,46866,46867,46868,46869,46870,46871,46872,46873,46874,46875,46876,46877,46878,46879,46880,46881,46882,46883,46884,46885,46886,46887,46888,46889,46890,46891,46892,46893,46894,46895,46896,46897,46898,46899,46900,46901,46902,46903,46904,46905,46906,46907,46908,46909,46910,46911,46912,46913,46914,46915,46916,46917,46918,46919,46920,46921,46922,46923,46924,46925,46926,46927,46928,46929,46930,46931,46932,46933,46934,46935,46936,46937,46938,46939,46940,46941,46942,46943,46944,46945,46946,46947,46948,46949,46950,46951,46952,46953,46954,46955,46956,46957,46958,46959,46960,46961,46962,46963,46964,46965,46966,46967,46968,46969,46970,46971,46972,46973,46974,46975,46976,46977,46978,46979,46980,46981,46982,46983,46984,46985,46986,46987,46988,46989,46990,46991,46992,46993,46994,46995,46996,46997,46998,46999,47000,47001,47002,47003,47004,47005,47006,47007,47008,47009,47010,47011,47012,47013,47014,47015,47016,47017,47018,47019,47020,47021,47022,47023,47024,47025,47026,47027,47028,47029,47030,47031,47032,47033,47034,47035,47036,47037,47038,47039,47040,47041,47042,47043,47044,47045,47046,47047,47048,47049,47050,47051,47052,47053,47054,47055,47056,47057,47058,47059,47060,47061,47062,47063,47064,47065,47066,47067,47068,47069,47070,47071,47072,47073,47074,47075,47076,47077,47078,47079,47080,47081,47082,47083,47084,47085,47086,47087,47088,47089,47090,47091,47092,47093,47094,47095,47096,47097,47098,47099,47100,47101,47102,47103,47104,47105,47106,47107,47108,47109,47110,47111,47112,47113,47114,47115,47116,47117,47118,47119,47120,47121,47122,47123,47124,47125,47126,47127,47128,47129,47130,47131,47132,47133,47134,47135,47136,47137,47138,47139,47140,47141,47142,47143,47144,47145,47146,47147,47148,47149,47150,47151,47152,47153,47154,47155,47156,47157,47158,47159,47160,47161,47162,47163,47164,47165,47166,47167,47168,47169,47170,47171,47172,47173,47174,47175,47176,47177,47178,47179,47180,47181,47182,47183,47184,47185,47186,47187,47188,47189,47190,47191,47192,47193,47194,47195,47196,47197,47198,47199,47200,47201,47202,47203,47204,47205,47206,47207,47208,47209,47210,47211,47212,47213,47214,47215,47216,47217,47218,47219,47220,47221,47222,47223,47224,47225,47226,47227,47228,47229,47230,47231,47232,47233,47234,47235,47236,47237,47238,47239,47240,47241,47242,47243,47244,47245,47246,47247,47248,47249,47250,47251,47252,47253,47254,47255,47256,47257,47258,47259,47260,47261,47262,47263,47264,47265,47266,47267,47268,47269,47270,47271,47272,47273,47274,47275,47276,47277,47278,47279,47280,47281,47282,47283,47284,47285,47286,47287,47288,47289,47290,47291,47292,47293,47294,47295,47296,47297,47298,47299,47300,47301,47302,47303,47304,47305,47306,47307,47308,47309,47310,47311,47312,47313,47314,47315,47316,47317,47318,47319,47320,47321,47322,47323,47324,47325,47326,47327,47328,47329,47330,47331,47332,47333,47334,47335,47336,47337,47338,47339,47340,47341,47342,47343,47344,47345,47346,47347,47348,47349,47350,47351,47352,47353,47354,47355,47356,47357,47358,47359,47360,47361,47362,47363,47364,47365,47366,47367,47368,47369,47370,47371,47372,47373,47374,47375,47376,47377,47378,47379,47380,47381,47382,47383,47384,47385,47386,47387,47388,47389,47390,47391,47392,47393,47394,47395,47396,47397,47398,47399,47400,47401,47402,47403,47404,47405,47406,47407,47408,47409,47410,47411,47412,47413,47414,47415,47416,47417,47418,47419,47420,47421,47422,47423,47424,47425,47426,47427,47428,47429,47430,47431,47432,47433,47434,47435,47436,47437,47438,47439,47440,47441,47442,47443,47444,47445,47446,47447,47448,47449,47450,47451,47452,47453,47454,47455,47456,47457,47458,47459,47460,47461,47462,47463,47464,47465,47466,47467,47468,47469,47470,47471,47472,47473,47474,47475,47476,47477,47478,47479,47480,47481,47482,47483,47484,47485,47486,47487,47488,47489,47490,47491,47492,47493,47494,47495,47496,47497,47498,47499,47500,47501,47502,47503,47504,47505,47506,47507,47508,47509,47510,47511,47512,47513,47514,47515,47516,47517,47518,47519,47520,47521,47522,47523,47524,47525,47526,47527,47528,47529,47530,47531,47532,47533,47534,47535,47536,47537,47538,47539,47540,47541,47542,47543,47544,47545,47546,47547,47548,47549,47550,47551,47552,47553,47554,47555,47556,47557,47558,47559,47560,47561,47562,47563,47564,47565,47566,47567,47568,47569,47570,47571,47572,47573,47574,47575,47576,47577,47578,47579,47580,47581,47582,47583,47584,47585,47586,47587,47588,47589,47590,47591,47592,47593,47594,47595,47596,47597,47598,47599,47600,47601,47602,47603,47604,47605,47606,47607,47608,47609,47610,47611,47612,47613,47614,47615,47616,47617,47618,47619,47620,47621,47622,47623,47624,47625,47626,47627,47628,47629,47630,47631,47632,47633,47634,47635,47636,47637,47638,47639,47640,47641,47642,47643,47644,47645,47646,47647,47648,47649,47650,47651,47652,47653,47654,47655,47656,47657,47658,47659,47660,47661,47662,47663,47664,47665,47666,47667,47668,47669,47670,47671,47672,47673,47674,47675,47676,47677,47678,47679,47680,47681,47682,47683,47684,47685,47686,47687,47688,47689,47690,47691,47692,47693,47694,47695,47696,47697,47698,47699,47700,47701,47702,47703,47704,47705,47706,47707,47708,47709,47710,47711,47712,47713,47714,47715,47716,47717,47718,47719,47720,47721,47722,47723,47724,47725,47726,47727,47728,47729,47730,47731,47732,47733,47734,47735,47736,47737,47738,47739,47740,47741,47742,47743,47744,47745,47746,47747,47748,47749,47750,47751,47752,47753,47754,47755,47756,47757,47758,47759,47760,47761,47762,47763,47764,47765,47766,47767,47768,47769,47770,47771,47772,47773,47774,47775,47776,47777,47778,47779,47780,47781,47782,47783,47784,47785,47786,47787,47788,47789,47790,47791,47792,47793,47794,47795,47796,47797,47798,47799,47800,47801,47802,47803,47804,47805,47806,47807,47808,47809,47810,47811,47812,47813,47814,47815,47816,47817,47818,47819,47820,47821,47822,47823,47824,47825,47826,47827,47828,47829,47830,47831,47832,47833,47834,47835,47836,47837,47838,47839,47840,47841,47842,47843,47844,47845,47846,47847,47848,47849,47850,47851,47852,47853,47854,47855,47856,47857,47858,47859,47860,47861,47862,47863,47864,47865,47866,47867,47868,47869,47870,47871,47872,47873,47874,47875,47876,47877,47878,47879,47880,47881,47882,47883,47884,47885,47886,47887,47888,47889,47890,47891,47892,47893,47894,47895,47896,47897,47898,47899,47900,47901,47902,47903,47904,47905,47906,47907,47908,47909,47910,47911,47912,47913,47914,47915,47916,47917,47918,47919,47920,47921,47922,47923,47924,47925,47926,47927,47928,47929,47930,47931,47932,47933,47934,47935,47936,47937,47938,47939,47940,47941,47942,47943,47944,47945,47946,47947,47948,47949,47950,47951,47952,47953,47954,47955,47956,47957,47958,47959,47960,47961,47962,47963,47964,47965,47966,47967,47968,47969,47970,47971,47972,47973,47974,47975,47976,47977,47978,47979,47980,47981,47982,47983,47984,47985,47986,47987,47988,47989,47990,47991,47992,47993,47994,47995,47996,47997,47998,47999,48000,48001,48002,48003,48004,48005,48006,48007,48008,48009,48010,48011,48012,48013,48014,48015,48016,48017,48018,48019,48020,48021,48022,48023,48024,48025,48026,48027,48028,48029,48030,48031,48032,48033,48034,48035,48036,48037,48038,48039,48040,48041,48042,48043,48044,48045,48046,48047,48048,48049,48050,48051,48052,48053,48054,48055,48056,48057,48058,48059,48060,48061,48062,48063,48064,48065,48066,48067,48068,48069,48070,48071,48072,48073,48074,48075,48076,48077,48078,48079,48080,48081,48082,48083,48084,48085,48086,48087,48088,48089,48090,48091,48092,48093,48094,48095,48096,48097,48098,48099,48100,48101,48102,48103,48104,48105,48106,48107,48108,48109,48110,48111,48112,48113,48114,48115,48116,48117,48118,48119,48120,48121,48122,48123,48124,48125,48126,48127,48128,48129,48130,48131,48132,48133,48134,48135,48136,48137,48138,48139,48140,48141,48142,48143,48144,48145,48146,48147,48148,48149,48150,48151,48152,48153,48154,48155,48156,48157,48158,48159,48160,48161,48162,48163,48164,48165,48166,48167,48168,48169,48170,48171,48172,48173,48174,48175,48176,48177,48178,48179,48180,48181,48182,48183,48184,48185,48186,48187,48188,48189,48190,48191,48192,48193,48194,48195,48196,48197,48198,48199,48200,48201,48202,48203,48204,48205,48206,48207,48208,48209,48210,48211,48212,48213,48214,48215,48216,48217,48218,48219,48220,48221,48222,48223,48224,48225,48226,48227,48228,48229,48230,48231,48232,48233,48234,48235,48236,48237,48238,48239,48240,48241,48242,48243,48244,48245,48246,48247,48248,48249,48250,48251,48252,48253,48254,48255,48256,48257,48258,48259,48260,48261,48262,48263,48264,48265,48266,48267,48268,48269,48270,48271,48272,48273,48274,48275,48276,48277,48278,48279,48280,48281,48282,48283,48284,48285,48286,48287,48288,48289,48290,48291,48292,48293,48294,48295,48296,48297,48298,48299,48300,48301,48302,48303,48304,48305,48306,48307,48308,48309,48310,48311,48312,48313,48314,48315,48316,48317,48318,48319,48320,48321,48322,48323,48324,48325,48326,48327,48328,48329,48330,48331,48332,48333,48334,48335,48336,48337,48338,48339,48340,48341,48342,48343,48344,48345,48346,48347,48348,48349,48350,48351,48352,48353,48354,48355,48356,48357,48358,48359,48360,48361,48362,48363,48364,48365,48366,48367,48368,48369,48370,48371,48372,48373,48374,48375,48376,48377,48378,48379,48380,48381,48382,48383,48384,48385,48386,48387,48388,48389,48390,48391,48392,48393,48394,48395,48396,48397,48398,48399,48400,48401,48402,48403,48404,48405,48406,48407,48408,48409,48410,48411,48412,48413,48414,48415,48416,48417,48418,48419,48420,48421,48422,48423,48424,48425,48426,48427,48428,48429,48430,48431,48432,48433,48434,48435,48436,48437,48438,48439,48440,48441,48442,48443,48444,48445,48446,48447,48448,48449,48450,48451,48452,48453,48454,48455,48456,48457,48458,48459,48460,48461,48462,48463,48464,48465,48466,48467,48468,48469,48470,48471,48472,48473,48474,48475,48476,48477,48478,48479,48480,48481,48482,48483,48484,48485,48486,48487,48488,48489,48490,48491,48492,48493,48494,48495,48496,48497,48498,48499,48500,48501,48502,48503,48504,48505,48506,48507,48508,48509,48510,48511,48512,48513,48514,48515,48516,48517,48518,48519,48520,48521,48522,48523,48524,48525,48526,48527,48528,48529,48530,48531,48532,48533,48534,48535,48536,48537,48538,48539,48540,48541,48542,48543,48544,48545,48546,48547,48548,48549,48550,48551,48552,48553,48554,48555,48556,48557,48558,48559,48560,48561,48562,48563,48564,48565,48566,48567,48568,48569,48570,48571,48572,48573,48574,48575,48576,48577,48578,48579,48580,48581,48582,48583,48584,48585,48586,48587,48588,48589,48590,48591,48592,48593,48594,48595,48596,48597,48598,48599,48600,48601,48602,48603,48604,48605,48606,48607,48608,48609,48610,48611,48612,48613,48614,48615,48616,48617,48618,48619,48620,48621,48622,48623,48624,48625,48626,48627,48628,48629,48630,48631,48632,48633,48634,48635,48636,48637,48638,48639,48640,48641,48642,48643,48644,48645,48646,48647,48648,48649,48650,48651,48652,48653,48654,48655,48656,48657,48658,48659,48660,48661,48662,48663,48664,48665,48666,48667,48668,48669,48670,48671,48672,48673,48674,48675,48676,48677,48678,48679,48680,48681,48682,48683,48684,48685,48686,48687,48688,48689,48690,48691,48692,48693,48694,48695,48696,48697,48698,48699,48700,48701,48702,48703,48704,48705,48706,48707,48708,48709,48710,48711,48712,48713,48714,48715,48716,48717,48718,48719,48720,48721,48722,48723,48724,48725,48726,48727,48728,48729,48730,48731,48732,48733,48734,48735,48736,48737,48738,48739,48740,48741,48742,48743,48744,48745,48746,48747,48748,48749,48750,48751,48752,48753,48754,48755,48756,48757,48758,48759,48760,48761,48762,48763,48764,48765,48766,48767,48768,48769,48770,48771,48772,48773,48774,48775,48776,48777,48778,48779,48780,48781,48782,48783,48784,48785,48786,48787,48788,48789,48790,48791,48792,48793,48794,48795,48796,48797,48798,48799,48800,48801,48802,48803,48804,48805,48806,48807,48808,48809,48810,48811,48812,48813,48814,48815,48816,48817,48818,48819,48820,48821,48822,48823,48824,48825,48826,48827,48828,48829,48830,48831,48832,48833,48834,48835,48836,48837,48838,48839,48840,48841,48842,48843,48844,48845,48846,48847,48848,48849,48850,48851,48852,48853,48854,48855,48856,48857,48858,48859,48860,48861,48862,48863,48864,48865,48866,48867,48868,48869,48870,48871,48872,48873,48874,48875,48876,48877,48878,48879,48880,48881,48882,48883,48884,48885,48886,48887,48888,48889,48890,48891,48892,48893,48894,48895,48896,48897,48898,48899,48900,48901,48902,48903,48904,48905,48906,48907,48908,48909,48910,48911,48912,48913,48914,48915,48916,48917,48918,48919,48920,48921,48922,48923,48924,48925,48926,48927,48928,48929,48930,48931,48932,48933,48934,48935,48936,48937,48938,48939,48940,48941,48942,48943,48944,48945,48946,48947,48948,48949,48950,48951,48952,48953,48954,48955,48956,48957,48958,48959,48960,48961,48962,48963,48964,48965,48966,48967,48968,48969,48970,48971,48972,48973,48974,48975,48976,48977,48978,48979,48980,48981,48982,48983,48984,48985,48986,48987,48988,48989,48990,48991,48992,48993,48994,48995,48996,48997,48998,48999,49000,49001,49002,49003,49004,49005,49006,49007,49008,49009,49010,49011,49012,49013,49014,49015,49016,49017,49018,49019,49020,49021,49022,49023,49024,49025,49026,49027,49028,49029,49030,49031,49032,49033,49034,49035,49036,49037,49038,49039,49040,49041,49042,49043,49044,49045,49046,49047,49048,49049,49050,49051,49052,49053,49054,49055,49056,49057,49058,49059,49060,49061,49062,49063,49064,49065,49066,49067,49068,49069,49070,49071,49072,49073,49074,49075,49076,49077,49078,49079,49080,49081,49082,49083,49084,49085,49086,49087,49088,49089,49090,49091,49092,49093,49094,49095,49096,49097,49098,49099,49100,49101,49102,49103,49104,49105,49106,49107,49108,49109,49110,49111,49112,49113,49114,49115,49116,49117,49118,49119,49120,49121,49122,49123,49124,49125,49126,49127,49128,49129,49130,49131,49132,49133,49134,49135,49136,49137,49138,49139,49140,49141,49142,49143,49144,49145,49146,49147,49148,49149,49150,49151,49152,49153,49154,49155,49156,49157,49158,49159,49160,49161,49162,49163,49164,49165,49166,49167,49168,49169,49170,49171,49172,49173,49174,49175,49176,49177,49178,49179,49180,49181,49182,49183,49184,49185,49186,49187,49188,49189,49190,49191,49192,49193,49194,49195,49196,49197,49198,49199,49200,49201,49202,49203,49204,49205,49206,49207,49208,49209,49210,49211,49212,49213,49214,49215,49216,49217,49218,49219,49220,49221,49222,49223,49224,49225,49226,49227,49228,49229,49230,49231,49232,49233,49234,49235,49236,49237,49238,49239,49240,49241,49242,49243,49244,49245,49246,49247,49248,49249,49250,49251,49252,49253,49254,49255,49256,49257,49258,49259,49260,49261,49262,49263,49264,49265,49266,49267,49268,49269,49270,49271,49272,49273,49274,49275,49276,49277,49278,49279,49280,49281,49282,49283,49284,49285,49286,49287,49288,49289,49290,49291,49292,49293,49294,49295,49296,49297,49298,49299,49300,49301,49302,49303,49304,49305,49306,49307,49308,49309,49310,49311,49312,49313,49314,49315,49316,49317,49318,49319,49320,49321,49322,49323,49324,49325,49326,49327,49328,49329,49330,49331,49332,49333,49334,49335,49336,49337,49338,49339,49340,49341,49342,49343,49344,49345,49346,49347,49348,49349,49350,49351,49352,49353,49354,49355,49356,49357,49358,49359,49360,49361,49362,49363,49364,49365,49366,49367,49368,49369,49370,49371,49372,49373,49374,49375,49376,49377,49378,49379,49380,49381,49382,49383,49384,49385,49386,49387,49388,49389,49390,49391,49392,49393,49394,49395,49396,49397,49398,49399,49400,49401,49402,49403,49404,49405,49406,49407,49408,49409,49410,49411,49412,49413,49414,49415,49416,49417,49418,49419,49420,49421,49422,49423,49424,49425,49426,49427,49428,49429,49430,49431,49432,49433,49434,49435,49436,49437,49438,49439,49440,49441,49442,49443,49444,49445,49446,49447,49448,49449,49450,49451,49452,49453,49454,49455,49456,49457,49458,49459,49460,49461,49462,49463,49464,49465,49466,49467,49468,49469,49470,49471,49472,49473,49474,49475,49476,49477,49478,49479,49480,49481,49482,49483,49484,49485,49486,49487,49488,49489,49490,49491,49492,49493,49494,49495,49496,49497,49498,49499,49500,49501,49502,49503,49504,49505,49506,49507,49508,49509,49510,49511,49512,49513,49514,49515,49516,49517,49518,49519,49520,49521,49522,49523,49524,49525,49526,49527,49528,49529,49530,49531,49532,49533,49534,49535,49536,49537,49538,49539,49540,49541,49542,49543,49544,49545,49546,49547,49548,49549,49550,49551,49552,49553,49554,49555,49556,49557,49558,49559,49560,49561,49562,49563,49564,49565,49566,49567,49568,49569,49570,49571,49572,49573,49574,49575,49576,49577,49578,49579,49580,49581,49582,49583,49584,49585,49586,49587,49588,49589,49590,49591,49592,49593,49594,49595,49596,49597,49598,49599,49600,49601,49602,49603,49604,49605,49606,49607,49608,49609,49610,49611,49612,49613,49614,49615,49616,49617,49618,49619,49620,49621,49622,49623,49624,49625,49626,49627,49628,49629,49630,49631,49632,49633,49634,49635,49636,49637,49638,49639,49640,49641,49642,49643,49644,49645,49646,49647,49648,49649,49650,49651,49652,49653,49654,49655,49656,49657,49658,49659,49660,49661,49662,49663,49664,49665,49666,49667,49668,49669,49670,49671,49672,49673,49674,49675,49676,49677,49678,49679,49680,49681,49682,49683,49684,49685,49686,49687,49688,49689,49690,49691,49692,49693,49694,49695,49696,49697,49698,49699,49700,49701,49702,49703,49704,49705,49706,49707,49708,49709,49710,49711,49712,49713,49714,49715,49716,49717,49718,49719,49720,49721,49722,49723,49724,49725,49726,49727,49728,49729,49730,49731,49732,49733,49734,49735,49736,49737,49738,49739,49740,49741,49742,49743,49744,49745,49746,49747,49748,49749,49750,49751,49752,49753,49754,49755,49756,49757,49758,49759,49760,49761,49762,49763,49764,49765,49766,49767,49768,49769,49770,49771,49772,49773,49774,49775,49776,49777,49778,49779,49780,49781,49782,49783,49784,49785,49786,49787,49788,49789,49790,49791,49792,49793,49794,49795,49796,49797,49798,49799,49800,49801,49802,49803,49804,49805,49806,49807,49808,49809,49810,49811,49812,49813,49814,49815,49816,49817,49818,49819,49820,49821,49822,49823,49824,49825,49826,49827,49828,49829,49830,49831,49832,49833,49834,49835,49836,49837,49838,49839,49840,49841,49842,49843,49844,49845,49846,49847,49848,49849,49850,49851,49852,49853,49854,49855,49856,49857,49858,49859,49860,49861,49862,49863,49864,49865,49866,49867,49868,49869,49870,49871,49872,49873,49874,49875,49876,49877,49878,49879,49880,49881,49882,49883,49884,49885,49886,49887,49888,49889,49890,49891,49892,49893,49894,49895,49896,49897,49898,49899,49900,49901,49902,49903,49904,49905,49906,49907,49908,49909,49910,49911,49912,49913,49914,49915,49916,49917,49918,49919,49920,49921,49922,49923,49924,49925,49926,49927,49928,49929,49930,49931,49932,49933,49934,49935,49936,49937,49938,49939,49940,49941,49942,49943,49944,49945,49946,49947,49948,49949,49950,49951,49952,49953,49954,49955,49956,49957,49958,49959,49960,49961,49962,49963,49964,49965,49966,49967,49968,49969,49970,49971,49972,49973,49974,49975,49976,49977,49978,49979,49980,49981,49982,49983,49984,49985,49986,49987,49988,49989,49990,49991,49992,49993,49994,49995,49996,49997,49998,49999,50000,50001,50002,50003,50004,50005,50006,50007,50008,50009,50010,50011,50012,50013,50014,50015,50016,50017,50018,50019,50020,50021,50022,50023,50024,50025,50026,50027,50028,50029,50030,50031,50032,50033,50034,50035,50036,50037,50038,50039,50040,50041,50042,50043,50044,50045,50046,50047,50048,50049,50050,50051,50052,50053,50054,50055,50056,50057,50058,50059,50060,50061,50062,50063,50064,50065,50066,50067,50068,50069,50070,50071,50072,50073,50074,50075,50076,50077,50078,50079,50080,50081,50082,50083,50084,50085,50086,50087,50088,50089,50090,50091,50092,50093,50094,50095,50096,50097,50098,50099,50100,50101,50102,50103,50104,50105,50106,50107,50108,50109,50110,50111,50112,50113,50114,50115,50116,50117,50118,50119,50120,50121,50122,50123,50124,50125,50126,50127,50128,50129,50130,50131,50132,50133,50134,50135,50136,50137,50138,50139,50140,50141,50142,50143,50144,50145,50146,50147,50148,50149,50150,50151,50152,50153,50154,50155,50156,50157,50158,50159,50160,50161,50162,50163,50164,50165,50166,50167,50168,50169,50170,50171,50172,50173,50174,50175,50176,50177,50178,50179,50180,50181,50182,50183,50184,50185,50186,50187,50188,50189,50190,50191,50192,50193,50194,50195,50196,50197,50198,50199,50200,50201,50202,50203,50204,50205,50206,50207,50208,50209,50210,50211,50212,50213,50214,50215,50216,50217,50218,50219,50220,50221,50222,50223,50224,50225,50226,50227,50228,50229,50230,50231,50232,50233,50234,50235,50236,50237,50238,50239,50240,50241,50242,50243,50244,50245,50246,50247,50248,50249,50250,50251,50252,50253,50254,50255,50256,50257,50258,50259,50260,50261,50262,50263,50264,50265,50266,50267,50268,50269,50270,50271,50272,50273,50274,50275,50276,50277,50278,50279,50280,50281,50282,50283,50284,50285,50286,50287,50288,50289,50290,50291,50292,50293,50294,50295,50296,50297,50298,50299,50300,50301,50302,50303,50304,50305,50306,50307,50308,50309,50310,50311,50312,50313,50314,50315,50316,50317,50318,50319,50320,50321,50322,50323,50324,50325,50326,50327,50328,50329,50330,50331,50332,50333,50334,50335,50336,50337,50338,50339,50340,50341,50342,50343,50344,50345,50346,50347,50348,50349,50350,50351,50352,50353,50354,50355,50356,50357,50358,50359,50360,50361,50362,50363,50364,50365,50366,50367,50368,50369,50370,50371,50372,50373,50374,50375,50376,50377,50378,50379,50380,50381,50382,50383,50384,50385,50386,50387,50388,50389,50390,50391,50392,50393,50394,50395,50396,50397,50398,50399,50400,50401,50402,50403,50404,50405,50406,50407,50408,50409,50410,50411,50412,50413,50414,50415,50416,50417,50418,50419,50420,50421,50422,50423,50424,50425,50426,50427,50428,50429,50430,50431,50432,50433,50434,50435,50436,50437,50438,50439,50440,50441,50442,50443,50444,50445,50446,50447,50448,50449,50450,50451,50452,50453,50454,50455,50456,50457,50458,50459,50460,50461,50462,50463,50464,50465,50466,50467,50468,50469,50470,50471,50472,50473,50474,50475,50476,50477,50478,50479,50480,50481,50482,50483,50484,50485,50486,50487,50488,50489,50490,50491,50492,50493,50494,50495,50496,50497,50498,50499,50500,50501,50502,50503,50504,50505,50506,50507,50508,50509,50510,50511,50512,50513,50514,50515,50516,50517,50518,50519,50520,50521,50522,50523,50524,50525,50526,50527,50528,50529,50530,50531,50532,50533,50534,50535,50536,50537,50538,50539,50540,50541,50542,50543,50544,50545,50546,50547,50548,50549,50550,50551,50552,50553,50554,50555,50556,50557,50558,50559,50560,50561,50562,50563,50564,50565,50566,50567,50568,50569,50570,50571,50572,50573,50574,50575,50576,50577,50578,50579,50580,50581,50582,50583,50584,50585,50586,50587,50588,50589,50590,50591,50592,50593,50594,50595,50596,50597,50598,50599,50600,50601,50602,50603,50604,50605,50606,50607,50608,50609,50610,50611,50612,50613,50614,50615,50616,50617,50618,50619,50620,50621,50622,50623,50624,50625,50626,50627,50628,50629,50630,50631,50632,50633,50634,50635,50636,50637,50638,50639,50640,50641,50642,50643,50644,50645,50646,50647,50648,50649,50650,50651,50652,50653,50654,50655,50656,50657,50658,50659,50660,50661,50662,50663,50664,50665,50666,50667,50668,50669,50670,50671,50672,50673,50674,50675,50676,50677,50678,50679,50680,50681,50682,50683,50684,50685,50686,50687,50688,50689,50690,50691,50692,50693,50694,50695,50696,50697,50698,50699,50700,50701,50702,50703,50704,50705,50706,50707,50708,50709,50710,50711,50712,50713,50714,50715,50716,50717,50718,50719,50720,50721,50722,50723,50724,50725,50726,50727,50728,50729,50730,50731,50732,50733,50734,50735,50736,50737,50738,50739,50740,50741,50742,50743,50744,50745,50746,50747,50748,50749,50750,50751,50752,50753,50754,50755,50756,50757,50758,50759,50760,50761,50762,50763,50764,50765,50766,50767,50768,50769,50770,50771,50772,50773,50774,50775,50776,50777,50778,50779,50780,50781,50782,50783,50784,50785,50786,50787,50788,50789,50790,50791,50792,50793,50794,50795,50796,50797,50798,50799,50800,50801,50802,50803,50804,50805,50806,50807,50808,50809,50810,50811,50812,50813,50814,50815,50816,50817,50818,50819,50820,50821,50822,50823,50824,50825,50826,50827,50828,50829,50830,50831,50832,50833,50834,50835,50836,50837,50838,50839,50840,50841,50842,50843,50844,50845,50846,50847,50848,50849,50850,50851,50852,50853,50854,50855,50856,50857,50858,50859,50860,50861,50862,50863,50864,50865,50866,50867,50868,50869,50870,50871,50872,50873,50874,50875,50876,50877,50878,50879,50880,50881,50882,50883,50884,50885,50886,50887,50888,50889,50890,50891,50892,50893,50894,50895,50896,50897,50898,50899,50900,50901,50902,50903,50904,50905,50906,50907,50908,50909,50910,50911,50912,50913,50914,50915,50916,50917,50918,50919,50920,50921,50922,50923,50924,50925,50926,50927,50928,50929,50930,50931,50932,50933,50934,50935,50936,50937,50938,50939,50940,50941,50942,50943,50944,50945,50946,50947,50948,50949,50950,50951,50952,50953,50954,50955,50956,50957,50958,50959,50960,50961,50962,50963,50964,50965,50966,50967,50968,50969,50970,50971,50972,50973,50974,50975,50976,50977,50978,50979,50980,50981,50982,50983,50984,50985,50986,50987,50988,50989,50990,50991,50992,50993,50994,50995,50996,50997,50998,50999,51000,51001,51002,51003,51004,51005,51006,51007,51008,51009,51010,51011,51012,51013,51014,51015,51016,51017,51018,51019,51020,51021,51022,51023,51024,51025,51026,51027,51028,51029,51030,51031,51032,51033,51034,51035,51036,51037,51038,51039,51040,51041,51042,51043,51044,51045,51046,51047,51048,51049,51050,51051,51052,51053,51054,51055,51056,51057,51058,51059,51060,51061,51062,51063,51064,51065,51066,51067,51068,51069,51070,51071,51072,51073,51074,51075,51076,51077,51078,51079,51080,51081,51082,51083,51084,51085,51086,51087,51088,51089,51090,51091,51092,51093,51094,51095,51096,51097,51098,51099,51100,51101,51102,51103,51104,51105,51106,51107,51108,51109,51110,51111,51112,51113,51114,51115,51116,51117,51118,51119,51120,51121,51122,51123,51124,51125,51126,51127,51128,51129,51130,51131,51132,51133,51134,51135,51136,51137,51138,51139,51140,51141,51142,51143,51144,51145,51146,51147,51148,51149,51150,51151,51152,51153,51154,51155,51156,51157,51158,51159,51160,51161,51162,51163,51164,51165,51166,51167,51168,51169,51170,51171,51172,51173,51174,51175,51176,51177,51178,51179,51180,51181,51182,51183,51184,51185,51186,51187,51188,51189,51190,51191,51192,51193,51194,51195,51196,51197,51198,51199,51200,51201,51202,51203,51204,51205,51206,51207,51208,51209,51210,51211,51212,51213,51214,51215,51216,51217,51218,51219,51220,51221,51222,51223,51224,51225,51226,51227,51228,51229,51230,51231,51232,51233,51234,51235,51236,51237,51238,51239,51240,51241,51242,51243,51244,51245,51246,51247,51248,51249,51250,51251,51252,51253,51254,51255,51256,51257,51258,51259,51260,51261,51262,51263,51264,51265,51266,51267,51268,51269,51270,51271,51272,51273,51274,51275,51276,51277,51278,51279,51280,51281,51282,51283,51284,51285,51286,51287,51288,51289,51290,51291,51292,51293,51294,51295,51296,51297,51298,51299,51300,51301,51302,51303,51304,51305,51306,51307,51308,51309,51310,51311,51312,51313,51314,51315,51316,51317,51318,51319,51320,51321,51322,51323,51324,51325,51326,51327,51328,51329,51330,51331,51332,51333,51334,51335,51336,51337,51338,51339,51340,51341,51342,51343,51344,51345,51346,51347,51348,51349,51350,51351,51352,51353,51354,51355,51356,51357,51358,51359,51360,51361,51362,51363,51364,51365,51366,51367,51368,51369,51370,51371,51372,51373,51374,51375,51376,51377,51378,51379,51380,51381,51382,51383,51384,51385,51386,51387,51388,51389,51390,51391,51392,51393,51394,51395,51396,51397,51398,51399,51400,51401,51402,51403,51404,51405,51406,51407,51408,51409,51410,51411,51412,51413,51414,51415,51416,51417,51418,51419,51420,51421,51422,51423,51424,51425,51426,51427,51428,51429,51430,51431,51432,51433,51434,51435,51436,51437,51438,51439,51440,51441,51442,51443,51444,51445,51446,51447,51448,51449,51450,51451,51452,51453,51454,51455,51456,51457,51458,51459,51460,51461,51462,51463,51464,51465,51466,51467,51468,51469,51470,51471,51472,51473,51474,51475,51476,51477,51478,51479,51480,51481,51482,51483,51484,51485,51486,51487,51488,51489,51490,51491,51492,51493,51494,51495,51496,51497,51498,51499,51500,51501,51502,51503,51504,51505,51506,51507,51508,51509,51510,51511,51512,51513,51514,51515,51516,51517,51518,51519,51520,51521,51522,51523,51524,51525,51526,51527,51528,51529,51530,51531,51532,51533,51534,51535,51536,51537,51538,51539,51540,51541,51542,51543,51544,51545,51546,51547,51548,51549,51550,51551,51552,51553,51554,51555,51556,51557,51558,51559,51560,51561,51562,51563,51564,51565,51566,51567,51568,51569,51570,51571,51572,51573,51574,51575,51576,51577,51578,51579,51580,51581,51582,51583,51584,51585,51586,51587,51588,51589,51590,51591,51592,51593,51594,51595,51596,51597,51598,51599,51600,51601,51602,51603,51604,51605,51606,51607,51608,51609,51610,51611,51612,51613,51614,51615,51616,51617,51618,51619,51620,51621,51622,51623,51624,51625,51626,51627,51628,51629,51630,51631,51632,51633,51634,51635,51636,51637,51638,51639,51640,51641,51642,51643,51644,51645,51646,51647,51648,51649,51650,51651,51652,51653,51654,51655,51656,51657,51658,51659,51660,51661,51662,51663,51664,51665,51666,51667,51668,51669,51670,51671,51672,51673,51674,51675,51676,51677,51678,51679,51680,51681,51682,51683,51684,51685,51686,51687,51688,51689,51690,51691,51692,51693,51694,51695,51696,51697,51698,51699,51700,51701,51702,51703,51704,51705,51706,51707,51708,51709,51710,51711,51712,51713,51714,51715,51716,51717,51718,51719,51720,51721,51722,51723,51724,51725,51726,51727,51728,51729,51730,51731,51732,51733,51734,51735,51736,51737,51738,51739,51740,51741,51742,51743,51744,51745,51746,51747,51748,51749,51750,51751,51752,51753,51754,51755,51756,51757,51758,51759,51760,51761,51762,51763,51764,51765,51766,51767,51768,51769,51770,51771,51772,51773,51774,51775,51776,51777,51778,51779,51780,51781,51782,51783,51784,51785,51786,51787,51788,51789,51790,51791,51792,51793,51794,51795,51796,51797,51798,51799,51800,51801,51802,51803,51804,51805,51806,51807,51808,51809,51810,51811,51812,51813,51814,51815,51816,51817,51818,51819,51820,51821,51822,51823,51824,51825,51826,51827,51828,51829,51830,51831,51832,51833,51834,51835,51836,51837,51838,51839,51840,51841,51842,51843,51844,51845,51846,51847,51848,51849,51850,51851,51852,51853,51854,51855,51856,51857,51858,51859,51860,51861,51862,51863,51864,51865,51866,51867,51868,51869,51870,51871,51872,51873,51874,51875,51876,51877,51878,51879,51880,51881,51882,51883,51884,51885,51886,51887,51888,51889,51890,51891,51892,51893,51894,51895,51896,51897,51898,51899,51900,51901,51902,51903,51904,51905,51906,51907,51908,51909,51910,51911,51912,51913,51914,51915,51916,51917,51918,51919,51920,51921,51922,51923,51924,51925,51926,51927,51928,51929,51930,51931,51932,51933,51934,51935,51936,51937,51938,51939,51940,51941,51942,51943,51944,51945,51946,51947,51948,51949,51950,51951,51952,51953,51954,51955,51956,51957,51958,51959,51960,51961,51962,51963,51964,51965,51966,51967,51968,51969,51970,51971,51972,51973,51974,51975,51976,51977,51978,51979,51980,51981,51982,51983,51984,51985,51986,51987,51988,51989,51990,51991,51992,51993,51994,51995,51996,51997,51998,51999,52000,52001,52002,52003,52004,52005,52006,52007,52008,52009,52010,52011,52012,52013,52014,52015,52016,52017,52018,52019,52020,52021,52022,52023,52024,52025,52026,52027,52028,52029,52030,52031,52032,52033,52034,52035,52036,52037,52038,52039,52040,52041,52042,52043,52044,52045,52046,52047,52048,52049,52050,52051,52052,52053,52054,52055,52056,52057,52058,52059,52060,52061,52062,52063,52064,52065,52066,52067,52068,52069,52070,52071,52072,52073,52074,52075,52076,52077,52078,52079,52080,52081,52082,52083,52084,52085,52086,52087,52088,52089,52090,52091,52092,52093,52094,52095,52096,52097,52098,52099,52100,52101,52102,52103,52104,52105,52106,52107,52108,52109,52110,52111,52112,52113,52114,52115,52116,52117,52118,52119,52120,52121,52122,52123,52124,52125,52126,52127,52128,52129,52130,52131,52132,52133,52134,52135,52136,52137,52138,52139,52140,52141,52142,52143,52144,52145,52146,52147,52148,52149,52150,52151,52152,52153,52154,52155,52156,52157,52158,52159,52160,52161,52162,52163,52164,52165,52166,52167,52168,52169,52170,52171,52172,52173,52174,52175,52176,52177,52178,52179,52180,52181,52182,52183,52184,52185,52186,52187,52188,52189,52190,52191,52192,52193,52194,52195,52196,52197,52198,52199,52200,52201,52202,52203,52204,52205,52206,52207,52208,52209,52210,52211,52212,52213,52214,52215,52216,52217,52218,52219,52220,52221,52222,52223,52224,52225,52226,52227,52228,52229,52230,52231,52232,52233,52234,52235,52236,52237,52238,52239,52240,52241,52242,52243,52244,52245,52246,52247,52248,52249,52250,52251,52252,52253,52254,52255,52256,52257,52258,52259,52260,52261,52262,52263,52264,52265,52266,52267,52268,52269,52270,52271,52272,52273,52274,52275,52276,52277,52278,52279,52280,52281,52282,52283,52284,52285,52286,52287,52288,52289,52290,52291,52292,52293,52294,52295,52296,52297,52298,52299,52300,52301,52302,52303,52304,52305,52306,52307,52308,52309,52310,52311,52312,52313,52314,52315,52316,52317,52318,52319,52320,52321,52322,52323,52324,52325,52326,52327,52328,52329,52330,52331,52332,52333,52334,52335,52336,52337,52338,52339,52340,52341,52342,52343,52344,52345,52346,52347,52348,52349,52350,52351,52352,52353,52354,52355,52356,52357,52358,52359,52360,52361,52362,52363,52364,52365,52366,52367,52368,52369,52370,52371,52372,52373,52374,52375,52376,52377,52378,52379,52380,52381,52382,52383,52384,52385,52386,52387,52388,52389,52390,52391,52392,52393,52394,52395,52396,52397,52398,52399,52400,52401,52402,52403,52404,52405,52406,52407,52408,52409,52410,52411,52412,52413,52414,52415,52416,52417,52418,52419,52420,52421,52422,52423,52424,52425,52426,52427,52428,52429,52430,52431,52432,52433,52434,52435,52436,52437,52438,52439,52440,52441,52442,52443,52444,52445,52446,52447,52448,52449,52450,52451,52452,52453,52454,52455,52456,52457,52458,52459,52460,52461,52462,52463,52464,52465,52466,52467,52468,52469,52470,52471,52472,52473,52474,52475,52476,52477,52478,52479,52480,52481,52482,52483,52484,52485,52486,52487,52488,52489,52490,52491,52492,52493,52494,52495,52496,52497,52498,52499,52500,52501,52502,52503,52504,52505,52506,52507,52508,52509,52510,52511,52512,52513,52514,52515,52516,52517,52518,52519,52520,52521,52522,52523,52524,52525,52526,52527,52528,52529,52530,52531,52532,52533,52534,52535,52536,52537,52538,52539,52540,52541,52542,52543,52544,52545,52546,52547,52548,52549,52550,52551,52552,52553,52554,52555,52556,52557,52558,52559,52560,52561,52562,52563,52564,52565,52566,52567,52568,52569,52570,52571,52572,52573,52574,52575,52576,52577,52578,52579,52580,52581,52582,52583,52584,52585,52586,52587,52588,52589,52590,52591,52592,52593,52594,52595,52596,52597,52598,52599,52600,52601,52602,52603,52604,52605,52606,52607,52608,52609,52610,52611,52612,52613,52614,52615,52616,52617,52618,52619,52620,52621,52622,52623,52624,52625,52626,52627,52628,52629,52630,52631,52632,52633,52634,52635,52636,52637,52638,52639,52640,52641,52642,52643,52644,52645,52646,52647,52648,52649,52650,52651,52652,52653,52654,52655,52656,52657,52658,52659,52660,52661,52662,52663,52664,52665,52666,52667,52668,52669,52670,52671,52672,52673,52674,52675,52676,52677,52678,52679,52680,52681,52682,52683,52684,52685,52686,52687,52688,52689,52690,52691,52692,52693,52694,52695,52696,52697,52698,52699,52700,52701,52702,52703,52704,52705,52706,52707,52708,52709,52710,52711,52712,52713,52714,52715,52716,52717,52718,52719,52720,52721,52722,52723,52724,52725,52726,52727,52728,52729,52730,52731,52732,52733,52734,52735,52736,52737,52738,52739,52740,52741,52742,52743,52744,52745,52746,52747,52748,52749,52750,52751,52752,52753,52754,52755,52756,52757,52758,52759,52760,52761,52762,52763,52764,52765,52766,52767,52768,52769,52770,52771,52772,52773,52774,52775,52776,52777,52778,52779,52780,52781,52782,52783,52784,52785,52786,52787,52788,52789,52790,52791,52792,52793,52794,52795,52796,52797,52798,52799,52800,52801,52802,52803,52804,52805,52806,52807,52808,52809,52810,52811,52812,52813,52814,52815,52816,52817,52818,52819,52820,52821,52822,52823,52824,52825,52826,52827,52828,52829,52830,52831,52832,52833,52834,52835,52836,52837,52838,52839,52840,52841,52842,52843,52844,52845,52846,52847,52848,52849,52850,52851,52852,52853,52854,52855,52856,52857,52858,52859,52860,52861,52862,52863,52864,52865,52866,52867,52868,52869,52870,52871,52872,52873,52874,52875,52876,52877,52878,52879,52880,52881,52882,52883,52884,52885,52886,52887,52888,52889,52890,52891,52892,52893,52894,52895,52896,52897,52898,52899,52900,52901,52902,52903,52904,52905,52906,52907,52908,52909,52910,52911,52912,52913,52914,52915,52916,52917,52918,52919,52920,52921,52922,52923,52924,52925,52926,52927,52928,52929,52930,52931,52932,52933,52934,52935,52936,52937,52938,52939,52940,52941,52942,52943,52944,52945,52946,52947,52948,52949,52950,52951,52952,52953,52954,52955,52956,52957,52958,52959,52960,52961,52962,52963,52964,52965,52966,52967,52968,52969,52970,52971,52972,52973,52974,52975,52976,52977,52978,52979,52980,52981,52982,52983,52984,52985,52986,52987,52988,52989,52990,52991,52992,52993,52994,52995,52996,52997,52998,52999,53000,53001,53002,53003,53004,53005,53006,53007,53008,53009,53010,53011,53012,53013,53014,53015,53016,53017,53018,53019,53020,53021,53022,53023,53024,53025,53026,53027,53028,53029,53030,53031,53032,53033,53034,53035,53036,53037,53038,53039,53040,53041,53042,53043,53044,53045,53046,53047,53048,53049,53050,53051,53052,53053,53054,53055,53056,53057,53058,53059,53060,53061,53062,53063,53064,53065,53066,53067,53068,53069,53070,53071,53072,53073,53074,53075,53076,53077,53078,53079,53080,53081,53082,53083,53084,53085,53086,53087,53088,53089,53090,53091,53092,53093,53094,53095,53096,53097,53098,53099,53100,53101,53102,53103,53104,53105,53106,53107,53108,53109,53110,53111,53112,53113,53114,53115,53116,53117,53118,53119,53120,53121,53122,53123,53124,53125,53126,53127,53128,53129,53130,53131,53132,53133,53134,53135,53136,53137,53138,53139,53140,53141,53142,53143,53144,53145,53146,53147,53148,53149,53150,53151,53152,53153,53154,53155,53156,53157,53158,53159,53160,53161,53162,53163,53164,53165,53166,53167,53168,53169,53170,53171,53172,53173,53174,53175,53176,53177,53178,53179,53180,53181,53182,53183,53184,53185,53186,53187,53188,53189,53190,53191,53192,53193,53194,53195,53196,53197,53198,53199,53200,53201,53202,53203,53204,53205,53206,53207,53208,53209,53210,53211,53212,53213,53214,53215,53216,53217,53218,53219,53220,53221,53222,53223,53224,53225,53226,53227,53228,53229,53230,53231,53232,53233,53234,53235,53236,53237,53238,53239,53240,53241,53242,53243,53244,53245,53246,53247,53248,53249,53250,53251,53252,53253,53254,53255,53256,53257,53258,53259,53260,53261,53262,53263,53264,53265,53266,53267,53268,53269,53270,53271,53272,53273,53274,53275,53276,53277,53278,53279,53280,53281,53282,53283,53284,53285,53286,53287,53288,53289,53290,53291,53292,53293,53294,53295,53296,53297,53298,53299,53300,53301,53302,53303,53304,53305,53306,53307,53308,53309,53310,53311,53312,53313,53314,53315,53316,53317,53318,53319,53320,53321,53322,53323,53324,53325,53326,53327,53328,53329,53330,53331,53332,53333,53334,53335,53336,53337,53338,53339,53340,53341,53342,53343,53344,53345,53346,53347,53348,53349,53350,53351,53352,53353,53354,53355,53356,53357,53358,53359,53360,53361,53362,53363,53364,53365,53366,53367,53368,53369,53370,53371,53372,53373,53374,53375,53376,53377,53378,53379,53380,53381,53382,53383,53384,53385,53386,53387,53388,53389,53390,53391,53392,53393,53394,53395,53396,53397,53398,53399,53400,53401,53402,53403,53404,53405,53406,53407,53408,53409,53410,53411,53412,53413,53414,53415,53416,53417,53418,53419,53420,53421,53422,53423,53424,53425,53426,53427,53428,53429,53430,53431,53432,53433,53434,53435,53436,53437,53438,53439,53440,53441,53442,53443,53444,53445,53446,53447,53448,53449,53450,53451,53452,53453,53454,53455,53456,53457,53458,53459,53460,53461,53462,53463,53464,53465,53466,53467,53468,53469,53470,53471,53472,53473,53474,53475,53476,53477,53478,53479,53480,53481,53482,53483,53484,53485,53486,53487,53488,53489,53490,53491,53492,53493,53494,53495,53496,53497,53498,53499,53500,53501,53502,53503,53504,53505,53506,53507,53508,53509,53510,53511,53512,53513,53514,53515,53516,53517,53518,53519,53520,53521,53522,53523,53524,53525,53526,53527,53528,53529,53530,53531,53532,53533,53534,53535,53536,53537,53538,53539,53540,53541,53542,53543,53544,53545,53546,53547,53548,53549,53550,53551,53552,53553,53554,53555,53556,53557,53558,53559,53560,53561,53562,53563,53564,53565,53566,53567,53568,53569,53570,53571,53572,53573,53574,53575,53576,53577,53578,53579,53580,53581,53582,53583,53584,53585,53586,53587,53588,53589,53590,53591,53592,53593,53594,53595,53596,53597,53598,53599,53600,53601,53602,53603,53604,53605,53606,53607,53608,53609,53610,53611,53612,53613,53614,53615,53616,53617,53618,53619,53620,53621,53622,53623,53624,53625,53626,53627,53628,53629,53630,53631,53632,53633,53634,53635,53636,53637,53638,53639,53640,53641,53642,53643,53644,53645,53646,53647,53648,53649,53650,53651,53652,53653,53654,53655,53656,53657,53658,53659,53660,53661,53662,53663,53664,53665,53666,53667,53668,53669,53670,53671,53672,53673,53674,53675,53676,53677,53678,53679,53680,53681,53682,53683,53684,53685,53686,53687,53688,53689,53690,53691,53692,53693,53694,53695,53696,53697,53698,53699,53700,53701,53702,53703,53704,53705,53706,53707,53708,53709,53710,53711,53712,53713,53714,53715,53716,53717,53718,53719,53720,53721,53722,53723,53724,53725,53726,53727,53728,53729,53730,53731,53732,53733,53734,53735,53736,53737,53738,53739,53740,53741,53742,53743,53744,53745,53746,53747,53748,53749,53750,53751,53752,53753,53754,53755,53756,53757,53758,53759,53760,53761,53762,53763,53764,53765,53766,53767,53768,53769,53770,53771,53772,53773,53774,53775,53776,53777,53778,53779,53780,53781,53782,53783,53784,53785,53786,53787,53788,53789,53790,53791,53792,53793,53794,53795,53796,53797,53798,53799,53800,53801,53802,53803,53804,53805,53806,53807,53808,53809,53810,53811,53812,53813,53814,53815,53816,53817,53818,53819,53820,53821,53822,53823,53824,53825,53826,53827,53828,53829,53830,53831,53832,53833,53834,53835,53836,53837,53838,53839,53840,53841,53842,53843,53844,53845,53846,53847,53848,53849,53850,53851,53852,53853,53854,53855,53856,53857,53858,53859,53860,53861,53862,53863,53864,53865,53866,53867,53868,53869,53870,53871,53872,53873,53874,53875,53876,53877,53878,53879,53880,53881,53882,53883,53884,53885,53886,53887,53888,53889,53890,53891,53892,53893,53894,53895,53896,53897,53898,53899,53900,53901,53902,53903,53904,53905,53906,53907,53908,53909,53910,53911,53912,53913,53914,53915,53916,53917,53918,53919,53920,53921,53922,53923,53924,53925,53926,53927,53928,53929,53930,53931,53932,53933,53934,53935,53936,53937,53938,53939,53940,53941,53942,53943,53944,53945,53946,53947,53948,53949,53950,53951,53952,53953,53954,53955,53956,53957,53958,53959,53960,53961,53962,53963,53964,53965,53966,53967,53968,53969,53970,53971,53972,53973,53974,53975,53976,53977,53978,53979,53980,53981,53982,53983,53984,53985,53986,53987,53988,53989,53990,53991,53992,53993,53994,53995,53996,53997,53998,53999,54000,54001,54002,54003,54004,54005,54006,54007,54008,54009,54010,54011,54012,54013,54014,54015,54016,54017,54018,54019,54020,54021,54022,54023,54024,54025,54026,54027,54028,54029,54030,54031,54032,54033,54034,54035,54036,54037,54038,54039,54040,54041,54042,54043,54044,54045,54046,54047,54048,54049,54050,54051,54052,54053,54054,54055,54056,54057,54058,54059,54060,54061,54062,54063,54064,54065,54066,54067,54068,54069,54070,54071,54072,54073,54074,54075,54076,54077,54078,54079,54080,54081,54082,54083,54084,54085,54086,54087,54088,54089,54090,54091,54092,54093,54094,54095,54096,54097,54098,54099,54100,54101,54102,54103,54104,54105,54106,54107,54108,54109,54110,54111,54112,54113,54114,54115,54116,54117,54118,54119,54120,54121,54122,54123,54124,54125,54126,54127,54128,54129,54130,54131,54132,54133,54134,54135,54136,54137,54138,54139,54140,54141,54142,54143,54144,54145,54146,54147,54148,54149,54150,54151,54152,54153,54154,54155,54156,54157,54158,54159,54160,54161,54162,54163,54164,54165,54166,54167,54168,54169,54170,54171,54172,54173,54174,54175,54176,54177,54178,54179,54180,54181,54182,54183,54184,54185,54186,54187,54188,54189,54190,54191,54192,54193,54194,54195,54196,54197,54198,54199,54200,54201,54202,54203,54204,54205,54206,54207,54208,54209,54210,54211,54212,54213,54214,54215,54216,54217,54218,54219,54220,54221,54222,54223,54224,54225,54226,54227,54228,54229,54230,54231,54232,54233,54234,54235,54236,54237,54238,54239,54240,54241,54242,54243,54244,54245,54246,54247,54248,54249,54250,54251,54252,54253,54254,54255,54256,54257,54258,54259,54260,54261,54262,54263,54264,54265,54266,54267,54268,54269,54270,54271,54272,54273,54274,54275,54276,54277,54278,54279,54280,54281,54282,54283,54284,54285,54286,54287,54288,54289,54290,54291,54292,54293,54294,54295,54296,54297,54298,54299,54300,54301,54302,54303,54304,54305,54306,54307,54308,54309,54310,54311,54312,54313,54314,54315,54316,54317,54318,54319,54320,54321,54322,54323,54324,54325,54326,54327,54328,54329,54330,54331,54332,54333,54334,54335,54336,54337,54338,54339,54340,54341,54342,54343,54344,54345,54346,54347,54348,54349,54350,54351,54352,54353,54354,54355,54356,54357,54358,54359,54360,54361,54362,54363,54364,54365,54366,54367,54368,54369,54370,54371,54372,54373,54374,54375,54376,54377,54378,54379,54380,54381,54382,54383,54384,54385,54386,54387,54388,54389,54390,54391,54392,54393,54394,54395,54396,54397,54398,54399,54400,54401,54402,54403,54404,54405,54406,54407,54408,54409,54410,54411,54412,54413,54414,54415,54416,54417,54418,54419,54420,54421,54422,54423,54424,54425,54426,54427,54428,54429,54430,54431,54432,54433,54434,54435,54436,54437,54438,54439,54440,54441,54442,54443,54444,54445,54446,54447,54448,54449,54450,54451,54452,54453,54454,54455,54456,54457,54458,54459,54460,54461,54462,54463,54464,54465,54466,54467,54468,54469,54470,54471,54472,54473,54474,54475,54476,54477,54478,54479,54480,54481,54482,54483,54484,54485,54486,54487,54488,54489,54490,54491,54492,54493,54494,54495,54496,54497,54498,54499,54500,54501,54502,54503,54504,54505,54506,54507,54508,54509,54510,54511,54512,54513,54514,54515,54516,54517,54518,54519,54520,54521,54522,54523,54524,54525,54526,54527,54528,54529,54530,54531,54532,54533,54534,54535,54536,54537,54538,54539,54540,54541,54542,54543,54544,54545,54546,54547,54548,54549,54550,54551,54552,54553,54554,54555,54556,54557,54558,54559,54560,54561,54562,54563,54564,54565,54566,54567,54568,54569,54570,54571,54572,54573,54574,54575,54576,54577,54578,54579,54580,54581,54582,54583,54584,54585,54586,54587,54588,54589,54590,54591,54592,54593,54594,54595,54596,54597,54598,54599,54600,54601,54602,54603,54604,54605,54606,54607,54608,54609,54610,54611,54612,54613,54614,54615,54616,54617,54618,54619,54620,54621,54622,54623,54624,54625,54626,54627,54628,54629,54630,54631,54632,54633,54634,54635,54636,54637,54638,54639,54640,54641,54642,54643,54644,54645,54646,54647,54648,54649,54650,54651,54652,54653,54654,54655,54656,54657,54658,54659,54660,54661,54662,54663,54664,54665,54666,54667,54668,54669,54670,54671,54672,54673,54674,54675,54676,54677,54678,54679,54680,54681,54682,54683,54684,54685,54686,54687,54688,54689,54690,54691,54692,54693,54694,54695,54696,54697,54698,54699,54700,54701,54702,54703,54704,54705,54706,54707,54708,54709,54710,54711,54712,54713,54714,54715,54716,54717,54718,54719,54720,54721,54722,54723,54724,54725,54726,54727,54728,54729,54730,54731,54732,54733,54734,54735,54736,54737,54738,54739,54740,54741,54742,54743,54744,54745,54746,54747,54748,54749,54750,54751,54752,54753,54754,54755,54756,54757,54758,54759,54760,54761,54762,54763,54764,54765,54766,54767,54768,54769,54770,54771,54772,54773,54774,54775,54776,54777,54778,54779,54780,54781,54782,54783,54784,54785,54786,54787,54788,54789,54790,54791,54792,54793,54794,54795,54796,54797,54798,54799,54800,54801,54802,54803,54804,54805,54806,54807,54808,54809,54810,54811,54812,54813,54814,54815,54816,54817,54818,54819,54820,54821,54822,54823,54824,54825,54826,54827,54828,54829,54830,54831,54832,54833,54834,54835,54836,54837,54838,54839,54840,54841,54842,54843,54844,54845,54846,54847,54848,54849,54850,54851,54852,54853,54854,54855,54856,54857,54858,54859,54860,54861,54862,54863,54864,54865,54866,54867,54868,54869,54870,54871,54872,54873,54874,54875,54876,54877,54878,54879,54880,54881,54882,54883,54884,54885,54886,54887,54888,54889,54890,54891,54892,54893,54894,54895,54896,54897,54898,54899,54900,54901,54902,54903,54904,54905,54906,54907,54908,54909,54910,54911,54912,54913,54914,54915,54916,54917,54918,54919,54920,54921,54922,54923,54924,54925,54926,54927,54928,54929,54930,54931,54932,54933,54934,54935,54936,54937,54938,54939,54940,54941,54942,54943,54944,54945,54946,54947,54948,54949,54950,54951,54952,54953,54954,54955,54956,54957,54958,54959,54960,54961,54962,54963,54964,54965,54966,54967,54968,54969,54970,54971,54972,54973,54974,54975,54976,54977,54978,54979,54980,54981,54982,54983,54984,54985,54986,54987,54988,54989,54990,54991,54992,54993,54994,54995,54996,54997,54998,54999,55000,55001,55002,55003,55004,55005,55006,55007,55008,55009,55010,55011,55012,55013,55014,55015,55016,55017,55018,55019,55020,55021,55022,55023,55024,55025,55026,55027,55028,55029,55030,55031,55032,55033,55034,55035,55036,55037,55038,55039,55040,55041,55042,55043,55044,55045,55046,55047,55048,55049,55050,55051,55052,55053,55054,55055,55056,55057,55058,55059,55060,55061,55062,55063,55064,55065,55066,55067,55068,55069,55070,55071,55072,55073,55074,55075,55076,55077,55078,55079,55080,55081,55082,55083,55084,55085,55086,55087,55088,55089,55090,55091,55092,55093,55094,55095,55096,55097,55098,55099,55100,55101,55102,55103,55104,55105,55106,55107,55108,55109,55110,55111,55112,55113,55114,55115,55116,55117,55118,55119,55120,55121,55122,55123,55124,55125,55126,55127,55128,55129,55130,55131,55132,55133,55134,55135,55136,55137,55138,55139,55140,55141,55142,55143,55144,55145,55146,55147,55148,55149,55150,55151,55152,55153,55154,55155,55156,55157,55158,55159,55160,55161,55162,55163,55164,55165,55166,55167,55168,55169,55170,55171,55172,55173,55174,55175,55176,55177,55178,55179,55180,55181,55182,55183,55184,55185,55186,55187,55188,55189,55190,55191,55192,55193,55194,55195,55196,55197,55198,55199,55200,55201,55202,55203,55216,55217,55218,55219,55220,55221,55222,55223,55224,55225,55226,55227,55228,55229,55230,55231,55232,55233,55234,55235,55236,55237,55238,55243,55244,55245,55246,55247,55248,55249,55250,55251,55252,55253,55254,55255,55256,55257,55258,55259,55260,55261,55262,55263,55264,55265,55266,55267,55268,55269,55270,55271,55272,55273,55274,55275,55276,55277,55278,55279,55280,55281,55282,55283,55284,55285,55286,55287,55288,55289,55290,55291,63744,63745,63746,63747,63748,63749,63750,63751,63752,63753,63754,63755,63756,63757,63758,63759,63760,63761,63762,63763,63764,63765,63766,63767,63768,63769,63770,63771,63772,63773,63774,63775,63776,63777,63778,63779,63780,63781,63782,63783,63784,63785,63786,63787,63788,63789,63790,63791,63792,63793,63794,63795,63796,63797,63798,63799,63800,63801,63802,63803,63804,63805,63806,63807,63808,63809,63810,63811,63812,63813,63814,63815,63816,63817,63818,63819,63820,63821,63822,63823,63824,63825,63826,63827,63828,63829,63830,63831,63832,63833,63834,63835,63836,63837,63838,63839,63840,63841,63842,63843,63844,63845,63846,63847,63848,63849,63850,63851,63852,63853,63854,63855,63856,63857,63858,63859,63860,63861,63862,63863,63864,63865,63866,63867,63868,63869,63870,63871,63872,63873,63874,63875,63876,63877,63878,63879,63880,63881,63882,63883,63884,63885,63886,63887,63888,63889,63890,63891,63892,63893,63894,63895,63896,63897,63898,63899,63900,63901,63902,63903,63904,63905,63906,63907,63908,63909,63910,63911,63912,63913,63914,63915,63916,63917,63918,63919,63920,63921,63922,63923,63924,63925,63926,63927,63928,63929,63930,63931,63932,63933,63934,63935,63936,63937,63938,63939,63940,63941,63942,63943,63944,63945,63946,63947,63948,63949,63950,63951,63952,63953,63954,63955,63956,63957,63958,63959,63960,63961,63962,63963,63964,63965,63966,63967,63968,63969,63970,63971,63972,63973,63974,63975,63976,63977,63978,63979,63980,63981,63982,63983,63984,63985,63986,63987,63988,63989,63990,63991,63992,63993,63994,63995,63996,63997,63998,63999,64000,64001,64002,64003,64004,64005,64006,64007,64008,64009,64010,64011,64012,64013,64014,64015,64016,64017,64018,64019,64020,64021,64022,64023,64024,64025,64026,64027,64028,64029,64030,64031,64032,64033,64034,64035,64036,64037,64038,64039,64040,64041,64042,64043,64044,64045,64046,64047,64048,64049,64050,64051,64052,64053,64054,64055,64056,64057,64058,64059,64060,64061,64062,64063,64064,64065,64066,64067,64068,64069,64070,64071,64072,64073,64074,64075,64076,64077,64078,64079,64080,64081,64082,64083,64084,64085,64086,64087,64088,64089,64090,64091,64092,64093,64094,64095,64096,64097,64098,64099,64100,64101,64102,64103,64104,64105,64106,64107,64108,64109,64112,64113,64114,64115,64116,64117,64118,64119,64120,64121,64122,64123,64124,64125,64126,64127,64128,64129,64130,64131,64132,64133,64134,64135,64136,64137,64138,64139,64140,64141,64142,64143,64144,64145,64146,64147,64148,64149,64150,64151,64152,64153,64154,64155,64156,64157,64158,64159,64160,64161,64162,64163,64164,64165,64166,64167,64168,64169,64170,64171,64172,64173,64174,64175,64176,64177,64178,64179,64180,64181,64182,64183,64184,64185,64186,64187,64188,64189,64190,64191,64192,64193,64194,64195,64196,64197,64198,64199,64200,64201,64202,64203,64204,64205,64206,64207,64208,64209,64210,64211,64212,64213,64214,64215,64216,64217,64256,64257,64258,64259,64260,64261,64262,64275,64276,64277,64278,64279,64285,64287,64288,64289,64290,64291,64292,64293,64294,64295,64296,64298,64299,64300,64301,64302,64303,64304,64305,64306,64307,64308,64309,64310,64312,64313,64314,64315,64316,64318,64320,64321,64323,64324,64326,64327,64328,64329,64330,64331,64332,64333,64334,64335,64336,64337,64338,64339,64340,64341,64342,64343,64344,64345,64346,64347,64348,64349,64350,64351,64352,64353,64354,64355,64356,64357,64358,64359,64360,64361,64362,64363,64364,64365,64366,64367,64368,64369,64370,64371,64372,64373,64374,64375,64376,64377,64378,64379,64380,64381,64382,64383,64384,64385,64386,64387,64388,64389,64390,64391,64392,64393,64394,64395,64396,64397,64398,64399,64400,64401,64402,64403,64404,64405,64406,64407,64408,64409,64410,64411,64412,64413,64414,64415,64416,64417,64418,64419,64420,64421,64422,64423,64424,64425,64426,64427,64428,64429,64430,64431,64432,64433,64467,64468,64469,64470,64471,64472,64473,64474,64475,64476,64477,64478,64479,64480,64481,64482,64483,64484,64485,64486,64487,64488,64489,64490,64491,64492,64493,64494,64495,64496,64497,64498,64499,64500,64501,64502,64503,64504,64505,64506,64507,64508,64509,64510,64511,64512,64513,64514,64515,64516,64517,64518,64519,64520,64521,64522,64523,64524,64525,64526,64527,64528,64529,64530,64531,64532,64533,64534,64535,64536,64537,64538,64539,64540,64541,64542,64543,64544,64545,64546,64547,64548,64549,64550,64551,64552,64553,64554,64555,64556,64557,64558,64559,64560,64561,64562,64563,64564,64565,64566,64567,64568,64569,64570,64571,64572,64573,64574,64575,64576,64577,64578,64579,64580,64581,64582,64583,64584,64585,64586,64587,64588,64589,64590,64591,64592,64593,64594,64595,64596,64597,64598,64599,64600,64601,64602,64603,64604,64605,64606,64607,64608,64609,64610,64611,64612,64613,64614,64615,64616,64617,64618,64619,64620,64621,64622,64623,64624,64625,64626,64627,64628,64629,64630,64631,64632,64633,64634,64635,64636,64637,64638,64639,64640,64641,64642,64643,64644,64645,64646,64647,64648,64649,64650,64651,64652,64653,64654,64655,64656,64657,64658,64659,64660,64661,64662,64663,64664,64665,64666,64667,64668,64669,64670,64671,64672,64673,64674,64675,64676,64677,64678,64679,64680,64681,64682,64683,64684,64685,64686,64687,64688,64689,64690,64691,64692,64693,64694,64695,64696,64697,64698,64699,64700,64701,64702,64703,64704,64705,64706,64707,64708,64709,64710,64711,64712,64713,64714,64715,64716,64717,64718,64719,64720,64721,64722,64723,64724,64725,64726,64727,64728,64729,64730,64731,64732,64733,64734,64735,64736,64737,64738,64739,64740,64741,64742,64743,64744,64745,64746,64747,64748,64749,64750,64751,64752,64753,64754,64755,64756,64757,64758,64759,64760,64761,64762,64763,64764,64765,64766,64767,64768,64769,64770,64771,64772,64773,64774,64775,64776,64777,64778,64779,64780,64781,64782,64783,64784,64785,64786,64787,64788,64789,64790,64791,64792,64793,64794,64795,64796,64797,64798,64799,64800,64801,64802,64803,64804,64805,64806,64807,64808,64809,64810,64811,64812,64813,64814,64815,64816,64817,64818,64819,64820,64821,64822,64823,64824,64825,64826,64827,64828,64829,64848,64849,64850,64851,64852,64853,64854,64855,64856,64857,64858,64859,64860,64861,64862,64863,64864,64865,64866,64867,64868,64869,64870,64871,64872,64873,64874,64875,64876,64877,64878,64879,64880,64881,64882,64883,64884,64885,64886,64887,64888,64889,64890,64891,64892,64893,64894,64895,64896,64897,64898,64899,64900,64901,64902,64903,64904,64905,64906,64907,64908,64909,64910,64911,64914,64915,64916,64917,64918,64919,64920,64921,64922,64923,64924,64925,64926,64927,64928,64929,64930,64931,64932,64933,64934,64935,64936,64937,64938,64939,64940,64941,64942,64943,64944,64945,64946,64947,64948,64949,64950,64951,64952,64953,64954,64955,64956,64957,64958,64959,64960,64961,64962,64963,64964,64965,64966,64967,65008,65009,65010,65011,65012,65013,65014,65015,65016,65017,65018,65019,65136,65137,65138,65139,65140,65142,65143,65144,65145,65146,65147,65148,65149,65150,65151,65152,65153,65154,65155,65156,65157,65158,65159,65160,65161,65162,65163,65164,65165,65166,65167,65168,65169,65170,65171,65172,65173,65174,65175,65176,65177,65178,65179,65180,65181,65182,65183,65184,65185,65186,65187,65188,65189,65190,65191,65192,65193,65194,65195,65196,65197,65198,65199,65200,65201,65202,65203,65204,65205,65206,65207,65208,65209,65210,65211,65212,65213,65214,65215,65216,65217,65218,65219,65220,65221,65222,65223,65224,65225,65226,65227,65228,65229,65230,65231,65232,65233,65234,65235,65236,65237,65238,65239,65240,65241,65242,65243,65244,65245,65246,65247,65248,65249,65250,65251,65252,65253,65254,65255,65256,65257,65258,65259,65260,65261,65262,65263,65264,65265,65266,65267,65268,65269,65270,65271,65272,65273,65274,65275,65276,65313,65314,65315,65316,65317,65318,65319,65320,65321,65322,65323,65324,65325,65326,65327,65328,65329,65330,65331,65332,65333,65334,65335,65336,65337,65338,65345,65346,65347,65348,65349,65350,65351,65352,65353,65354,65355,65356,65357,65358,65359,65360,65361,65362,65363,65364,65365,65366,65367,65368,65369,65370,65382,65383,65384,65385,65386,65387,65388,65389,65390,65391,65392,65393,65394,65395,65396,65397,65398,65399,65400,65401,65402,65403,65404,65405,65406,65407,65408,65409,65410,65411,65412,65413,65414,65415,65416,65417,65418,65419,65420,65421,65422,65423,65424,65425,65426,65427,65428,65429,65430,65431,65432,65433,65434,65435,65436,65437,65438,65439,65440,65441,65442,65443,65444,65445,65446,65447,65448,65449,65450,65451,65452,65453,65454,65455,65456,65457,65458,65459,65460,65461,65462,65463,65464,65465,65466,65467,65468,65469,65470,65474,65475,65476,65477,65478,65479,65482,65483,65484,65485,65486,65487,65490,65491,65492,65493,65494,65495,65498,65499,65500';
    38 var arr = str.split(',').map(function(code) {
    39   return parseInt(code, 10);
    40 });
    41 module.exports = arr;
    42 },{}],4:[function(require,module,exports){
    43 // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
    44 //
    45 // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
    46 //
    47 // Originally from narwhal.js (http://narwhaljs.org)
    48 // Copyright (c) 2009 Thomas Robinson <280north.com>
    49 //
    50 // Permission is hereby granted, free of charge, to any person obtaining a copy
    51 // of this software and associated documentation files (the 'Software'), to
    52 // deal in the Software without restriction, including without limitation the
    53 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
    54 // sell copies of the Software, and to permit persons to whom the Software is
    55 // furnished to do so, subject to the following conditions:
    56 //
    57 // The above copyright notice and this permission notice shall be included in
    58 // all copies or substantial portions of the Software.
    59 //
    60 // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    61 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    62 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    63 // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
    64 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    65 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    66 
    67 // when used in node, this will actually load the util module we depend on
    68 // versus loading the builtin util module as happens otherwise
    69 // this is a bug in node module loading as far as I am concerned
    70 var util = require('util/');
    71 
    72 var pSlice = Array.prototype.slice;
    73 var hasOwn = Object.prototype.hasOwnProperty;
    74 
    75 // 1. The assert module provides functions that throw
    76 // AssertionError's when particular conditions are not met. The
    77 // assert module must conform to the following interface.
    78 
    79 var assert = module.exports = ok;
    80 
    81 // 2. The AssertionError is defined in assert.
    82 // new assert.AssertionError({ message: message,
    83 //                             actual: actual,
    84 //                             expected: expected })
    85 
    86 assert.AssertionError = function AssertionError(options) {
    87   this.name = 'AssertionError';
    88   this.actual = options.actual;
    89   this.expected = options.expected;
    90   this.operator = options.operator;
    91   if (options.message) {
    92     this.message = options.message;
    93     this.generatedMessage = false;
    94   } else {
    95     this.message = getMessage(this);
    96     this.generatedMessage = true;
    97   }
    98   var stackStartFunction = options.stackStartFunction || fail;
    99 
    100   if (Error.captureStackTrace) {
    101     Error.captureStackTrace(this, stackStartFunction);
    102   }
    103   else {
    104     // non v8 browsers so we can have a stacktrace
    105     var err = new Error();
    106     if (err.stack) {
    107       var out = err.stack;
    108 
    109       // try to strip useless frames
    110       var fn_name = stackStartFunction.name;
    111       var idx = out.indexOf('\n' + fn_name);
    112       if (idx >= 0) {
    113         // once we have located the function frame
    114         // we need to strip out everything before it (and its line)
    115         var next_line = out.indexOf('\n', idx + 1);
    116         out = out.substring(next_line + 1);
    117       }
    118 
    119       this.stack = out;
    120     }
    121   }
     6735window.JSHINT = function( text ){
     6736        fakeJSHINT.parse( text );
    1226737};
    123 
    124 // assert.AssertionError instanceof Error
    125 util.inherits(assert.AssertionError, Error);
    126 
    127 function replacer(key, value) {
    128   if (util.isUndefined(value)) {
    129     return '' + value;
    130   }
    131   if (util.isNumber(value) && !isFinite(value)) {
    132     return value.toString();
    133   }
    134   if (util.isFunction(value) || util.isRegExp(value)) {
    135     return value.toString();
    136   }
    137   return value;
    138 }
    139 
    140 function truncate(s, n) {
    141   if (util.isString(s)) {
    142     return s.length < n ? s : s.slice(0, n);
    143   } else {
    144     return s;
    145   }
    146 }
    147 
    148 function getMessage(self) {
    149   return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
    150          self.operator + ' ' +
    151          truncate(JSON.stringify(self.expected, replacer), 128);
    152 }
    153 
    154 // At present only the three keys mentioned above are used and
    155 // understood by the spec. Implementations or sub modules can pass
    156 // other keys to the AssertionError's constructor - they will be
    157 // ignored.
    158 
    159 // 3. All of the following functions must throw an AssertionError
    160 // when a corresponding condition is not met, with a message that
    161 // may be undefined if not provided.  All assertion methods provide
    162 // both the actual and expected values to the assertion error for
    163 // display purposes.
    164 
    165 function fail(actual, expected, message, operator, stackStartFunction) {
    166   throw new assert.AssertionError({
    167     message: message,
    168     actual: actual,
    169     expected: expected,
    170     operator: operator,
    171     stackStartFunction: stackStartFunction
    172   });
    173 }
    174 
    175 // EXTENSION! allows for well behaved errors defined elsewhere.
    176 assert.fail = fail;
    177 
    178 // 4. Pure assertion tests whether a value is truthy, as determined
    179 // by !!guard.
    180 // assert.ok(guard, message_opt);
    181 // This statement is equivalent to assert.equal(true, !!guard,
    182 // message_opt);. To test strictly for the value true, use
    183 // assert.strictEqual(true, guard, message_opt);.
    184 
    185 function ok(value, message) {
    186   if (!value) fail(value, true, message, '==', assert.ok);
    187 }
    188 assert.ok = ok;
    189 
    190 // 5. The equality assertion tests shallow, coercive equality with
    191 // ==.
    192 // assert.equal(actual, expected, message_opt);
    193 
    194 assert.equal = function equal(actual, expected, message) {
    195   if (actual != expected) fail(actual, expected, message, '==', assert.equal);
    196 };
    197 
    198 // 6. The non-equality assertion tests for whether two objects are not equal
    199 // with != assert.notEqual(actual, expected, message_opt);
    200 
    201 assert.notEqual = function notEqual(actual, expected, message) {
    202   if (actual == expected) {
    203     fail(actual, expected, message, '!=', assert.notEqual);
    204   }
    205 };
    206 
    207 // 7. The equivalence assertion tests a deep equality relation.
    208 // assert.deepEqual(actual, expected, message_opt);
    209 
    210 assert.deepEqual = function deepEqual(actual, expected, message) {
    211   if (!_deepEqual(actual, expected)) {
    212     fail(actual, expected, message, 'deepEqual', assert.deepEqual);
    213   }
    214 };
    215 
    216 function _deepEqual(actual, expected) {
    217   // 7.1. All identical values are equivalent, as determined by ===.
    218   if (actual === expected) {
    219     return true;
    220 
    221   } else if (util.isBuffer(actual) && util.isBuffer(expected)) {
    222     if (actual.length != expected.length) return false;
    223 
    224     for (var i = 0; i < actual.length; i++) {
    225       if (actual[i] !== expected[i]) return false;
    226     }
    227 
    228     return true;
    229 
    230   // 7.2. If the expected value is a Date object, the actual value is
    231   // equivalent if it is also a Date object that refers to the same time.
    232   } else if (util.isDate(actual) && util.isDate(expected)) {
    233     return actual.getTime() === expected.getTime();
    234 
    235   // 7.3 If the expected value is a RegExp object, the actual value is
    236   // equivalent if it is also a RegExp object with the same source and
    237   // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
    238   } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
    239     return actual.source === expected.source &&
    240            actual.global === expected.global &&
    241            actual.multiline === expected.multiline &&
    242            actual.lastIndex === expected.lastIndex &&
    243            actual.ignoreCase === expected.ignoreCase;
    244 
    245   // 7.4. Other pairs that do not both pass typeof value == 'object',
    246   // equivalence is determined by ==.
    247   } else if (!util.isObject(actual) && !util.isObject(expected)) {
    248     return actual == expected;
    249 
    250   // 7.5 For all other Object pairs, including Array objects, equivalence is
    251   // determined by having the same number of owned properties (as verified
    252   // with Object.prototype.hasOwnProperty.call), the same set of keys
    253   // (although not necessarily the same order), equivalent values for every
    254   // corresponding key, and an identical 'prototype' property. Note: this
    255   // accounts for both named and indexed properties on Arrays.
    256   } else {
    257     return objEquiv(actual, expected);
    258   }
    259 }
    260 
    261 function isArguments(object) {
    262   return Object.prototype.toString.call(object) == '[object Arguments]';
    263 }
    264 
    265 function objEquiv(a, b) {
    266   if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
    267     return false;
    268   // an identical 'prototype' property.
    269   if (a.prototype !== b.prototype) return false;
    270   // if one is a primitive, the other must be same
    271   if (util.isPrimitive(a) || util.isPrimitive(b)) {
    272     return a === b;
    273   }
    274   var aIsArgs = isArguments(a),
    275       bIsArgs = isArguments(b);
    276   if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
    277     return false;
    278   if (aIsArgs) {
    279     a = pSlice.call(a);
    280     b = pSlice.call(b);
    281     return _deepEqual(a, b);
    282   }
    283   var ka = objectKeys(a),
    284       kb = objectKeys(b),
    285       key, i;
    286   // having the same number of owned properties (keys incorporates
    287   // hasOwnProperty)
    288   if (ka.length != kb.length)
    289     return false;
    290   //the same set of keys (although not necessarily the same order),
    291   ka.sort();
    292   kb.sort();
    293   //~~~cheap key test
    294   for (i = ka.length - 1; i >= 0; i--) {
    295     if (ka[i] != kb[i])
    296       return false;
    297   }
    298   //equivalent values for every corresponding key, and
    299   //~~~possibly expensive deep test
    300   for (i = ka.length - 1; i >= 0; i--) {
    301     key = ka[i];
    302     if (!_deepEqual(a[key], b[key])) return false;
    303   }
    304   return true;
    305 }
    306 
    307 // 8. The non-equivalence assertion tests for any deep inequality.
    308 // assert.notDeepEqual(actual, expected, message_opt);
    309 
    310 assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
    311   if (_deepEqual(actual, expected)) {
    312     fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
    313   }
    314 };
    315 
    316 // 9. The strict equality assertion tests strict equality, as determined by ===.
    317 // assert.strictEqual(actual, expected, message_opt);
    318 
    319 assert.strictEqual = function strictEqual(actual, expected, message) {
    320   if (actual !== expected) {
    321     fail(actual, expected, message, '===', assert.strictEqual);
    322   }
    323 };
    324 
    325 // 10. The strict non-equality assertion tests for strict inequality, as
    326 // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
    327 
    328 assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
    329   if (actual === expected) {
    330     fail(actual, expected, message, '!==', assert.notStrictEqual);
    331   }
    332 };
    333 
    334 function expectedException(actual, expected) {
    335   if (!actual || !expected) {
    336     return false;
    337   }
    338 
    339   if (Object.prototype.toString.call(expected) == '[object RegExp]') {
    340     return expected.test(actual);
    341   } else if (actual instanceof expected) {
    342     return true;
    343   } else if (expected.call({}, actual) === true) {
    344     return true;
    345   }
    346 
    347   return false;
    348 }
    349 
    350 function _throws(shouldThrow, block, expected, message) {
    351   var actual;
    352 
    353   if (util.isString(expected)) {
    354     message = expected;
    355     expected = null;
    356   }
    357 
    358   try {
    359     block();
    360   } catch (e) {
    361     actual = e;
    362   }
    363 
    364   message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
    365             (message ? ' ' + message : '.');
    366 
    367   if (shouldThrow && !actual) {
    368     fail(actual, expected, 'Missing expected exception' + message);
    369   }
    370 
    371   if (!shouldThrow && expectedException(actual, expected)) {
    372     fail(actual, expected, 'Got unwanted exception' + message);
    373   }
    374 
    375   if ((shouldThrow && actual && expected &&
    376       !expectedException(actual, expected)) || (!shouldThrow && actual)) {
    377     throw actual;
    378   }
    379 }
    380 
    381 // 11. Expected to throw an error:
    382 // assert.throws(block, Error_opt, message_opt);
    383 
    384 assert.throws = function(block, /*optional*/error, /*optional*/message) {
    385   _throws.apply(this, [true].concat(pSlice.call(arguments)));
    386 };
    387 
    388 // EXTENSION! This is annoying to write outside this module.
    389 assert.doesNotThrow = function(block, /*optional*/message) {
    390   _throws.apply(this, [false].concat(pSlice.call(arguments)));
    391 };
    392 
    393 assert.ifError = function(err) { if (err) {throw err;}};
    394 
    395 var objectKeys = Object.keys || function (obj) {
    396   var keys = [];
    397   for (var key in obj) {
    398     if (hasOwn.call(obj, key)) keys.push(key);
    399   }
    400   return keys;
    401 };
    402 
    403 },{"util/":9}],5:[function(require,module,exports){
    404 // Copyright Joyent, Inc. and other Node contributors.
    405 //
    406 // Permission is hereby granted, free of charge, to any person obtaining a
    407 // copy of this software and associated documentation files (the
    408 // "Software"), to deal in the Software without restriction, including
    409 // without limitation the rights to use, copy, modify, merge, publish,
    410 // distribute, sublicense, and/or sell copies of the Software, and to permit
    411 // persons to whom the Software is furnished to do so, subject to the
    412 // following conditions:
    413 //
    414 // The above copyright notice and this permission notice shall be included
    415 // in all copies or substantial portions of the Software.
    416 //
    417 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    418 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    419 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
    420 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
    421 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
    422 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
    423 // USE OR OTHER DEALINGS IN THE SOFTWARE.
    424 
    425 function EventEmitter() {
    426   this._events = this._events || {};
    427   this._maxListeners = this._maxListeners || undefined;
    428 }
    429 module.exports = EventEmitter;
    430 
    431 // Backwards-compat with node 0.10.x
    432 EventEmitter.EventEmitter = EventEmitter;
    433 
    434 EventEmitter.prototype._events = undefined;
    435 EventEmitter.prototype._maxListeners = undefined;
    436 
    437 // By default EventEmitters will print a warning if more than 10 listeners are
    438 // added to it. This is a useful default which helps finding memory leaks.
    439 EventEmitter.defaultMaxListeners = 10;
    440 
    441 // Obviously not all Emitters should be limited to 10. This function allows
    442 // that to be increased. Set to zero for unlimited.
    443 EventEmitter.prototype.setMaxListeners = function(n) {
    444   if (!isNumber(n) || n < 0 || isNaN(n))
    445     throw TypeError('n must be a positive number');
    446   this._maxListeners = n;
    447   return this;
    448 };
    449 
    450 EventEmitter.prototype.emit = function(type) {
    451   var er, handler, len, args, i, listeners;
    452 
    453   if (!this._events)
    454     this._events = {};
    455 
    456   // If there is no 'error' event listener then throw.
    457   if (type === 'error') {
    458     if (!this._events.error ||
    459         (isObject(this._events.error) && !this._events.error.length)) {
    460       er = arguments[1];
    461       if (er instanceof Error) {
    462         throw er; // Unhandled 'error' event
    463       }
    464       throw TypeError('Uncaught, unspecified "error" event.');
    465     }
    466   }
    467 
    468   handler = this._events[type];
    469 
    470   if (isUndefined(handler))
    471     return false;
    472 
    473   if (isFunction(handler)) {
    474     switch (arguments.length) {
    475       // fast cases
    476       case 1:
    477         handler.call(this);
    478         break;
    479       case 2:
    480         handler.call(this, arguments[1]);
    481         break;
    482       case 3:
    483         handler.call(this, arguments[1], arguments[2]);
    484         break;
    485       // slower
    486       default:
    487         len = arguments.length;
    488         args = new Array(len - 1);
    489         for (i = 1; i < len; i++)
    490           args[i - 1] = arguments[i];
    491         handler.apply(this, args);
    492     }
    493   } else if (isObject(handler)) {
    494     len = arguments.length;
    495     args = new Array(len - 1);
    496     for (i = 1; i < len; i++)
    497       args[i - 1] = arguments[i];
    498 
    499     listeners = handler.slice();
    500     len = listeners.length;
    501     for (i = 0; i < len; i++)
    502       listeners[i].apply(this, args);
    503   }
    504 
    505   return true;
    506 };
    507 
    508 EventEmitter.prototype.addListener = function(type, listener) {
    509   var m;
    510 
    511   if (!isFunction(listener))
    512     throw TypeError('listener must be a function');
    513 
    514   if (!this._events)
    515     this._events = {};
    516 
    517   // To avoid recursion in the case that type === "newListener"! Before
    518   // adding it to the listeners, first emit "newListener".
    519   if (this._events.newListener)
    520     this.emit('newListener', type,
    521               isFunction(listener.listener) ?
    522               listener.listener : listener);
    523 
    524   if (!this._events[type])
    525     // Optimize the case of one listener. Don't need the extra array object.
    526     this._events[type] = listener;
    527   else if (isObject(this._events[type]))
    528     // If we've already got an array, just append.
    529     this._events[type].push(listener);
    530   else
    531     // Adding the second element, need to change to array.
    532     this._events[type] = [this._events[type], listener];
    533 
    534   // Check for listener leak
    535   if (isObject(this._events[type]) && !this._events[type].warned) {
    536     var m;
    537     if (!isUndefined(this._maxListeners)) {
    538       m = this._maxListeners;
    539     } else {
    540       m = EventEmitter.defaultMaxListeners;
    541     }
    542 
    543     if (m && m > 0 && this._events[type].length > m) {
    544       this._events[type].warned = true;
    545       console.error('(node) warning: possible EventEmitter memory ' +
    546                     'leak detected. %d listeners added. ' +
    547                     'Use emitter.setMaxListeners() to increase limit.',
    548                     this._events[type].length);
    549       if (typeof console.trace === 'function') {
    550         // not supported in IE 10
    551         console.trace();
    552       }
    553     }
    554   }
    555 
    556   return this;
    557 };
    558 
    559 EventEmitter.prototype.on = EventEmitter.prototype.addListener;
    560 
    561 EventEmitter.prototype.once = function(type, listener) {
    562   if (!isFunction(listener))
    563     throw TypeError('listener must be a function');
    564 
    565   var fired = false;
    566 
    567   function g() {
    568     this.removeListener(type, g);
    569 
    570     if (!fired) {
    571       fired = true;
    572       listener.apply(this, arguments);
    573     }
    574   }
    575 
    576   g.listener = listener;
    577   this.on(type, g);
    578 
    579   return this;
    580 };
    581 
    582 // emits a 'removeListener' event iff the listener was removed
    583 EventEmitter.prototype.removeListener = function(type, listener) {
    584   var list, position, length, i;
    585 
    586   if (!isFunction(listener))
    587     throw TypeError('listener must be a function');
    588 
    589   if (!this._events || !this._events[type])
    590     return this;
    591 
    592   list = this._events[type];
    593   length = list.length;
    594   position = -1;
    595 
    596   if (list === listener ||
    597       (isFunction(list.listener) && list.listener === listener)) {
    598     delete this._events[type];
    599     if (this._events.removeListener)
    600       this.emit('removeListener', type, listener);
    601 
    602   } else if (isObject(list)) {
    603     for (i = length; i-- > 0;) {
    604       if (list[i] === listener ||
    605           (list[i].listener && list[i].listener === listener)) {
    606         position = i;
    607         break;
    608       }
    609     }
    610 
    611     if (position < 0)
    612       return this;
    613 
    614     if (list.length === 1) {
    615       list.length = 0;
    616       delete this._events[type];
    617     } else {
    618       list.splice(position, 1);
    619     }
    620 
    621     if (this._events.removeListener)
    622       this.emit('removeListener', type, listener);
    623   }
    624 
    625   return this;
    626 };
    627 
    628 EventEmitter.prototype.removeAllListeners = function(type) {
    629   var key, listeners;
    630 
    631   if (!this._events)
    632     return this;
    633 
    634   // not listening for removeListener, no need to emit
    635   if (!this._events.removeListener) {
    636     if (arguments.length === 0)
    637       this._events = {};
    638     else if (this._events[type])
    639       delete this._events[type];
    640     return this;
    641   }
    642 
    643   // emit removeListener for all listeners on all events
    644   if (arguments.length === 0) {
    645     for (key in this._events) {
    646       if (key === 'removeListener') continue;
    647       this.removeAllListeners(key);
    648     }
    649     this.removeAllListeners('removeListener');
    650     this._events = {};
    651     return this;
    652   }
    653 
    654   listeners = this._events[type];
    655 
    656   if (isFunction(listeners)) {
    657     this.removeListener(type, listeners);
    658   } else {
    659     // LIFO order
    660     while (listeners.length)
    661       this.removeListener(type, listeners[listeners.length - 1]);
    662   }
    663   delete this._events[type];
    664 
    665   return this;
    666 };
    667 
    668 EventEmitter.prototype.listeners = function(type) {
    669   var ret;
    670   if (!this._events || !this._events[type])
    671     ret = [];
    672   else if (isFunction(this._events[type]))
    673     ret = [this._events[type]];
    674   else
    675     ret = this._events[type].slice();
    676   return ret;
    677 };
    678 
    679 EventEmitter.listenerCount = function(emitter, type) {
    680   var ret;
    681   if (!emitter._events || !emitter._events[type])
    682     ret = 0;
    683   else if (isFunction(emitter._events[type]))
    684     ret = 1;
    685   else
    686     ret = emitter._events[type].length;
    687   return ret;
    688 };
    689 
    690 function isFunction(arg) {
    691   return typeof arg === 'function';
    692 }
    693 
    694 function isNumber(arg) {
    695   return typeof arg === 'number';
    696 }
    697 
    698 function isObject(arg) {
    699   return typeof arg === 'object' && arg !== null;
    700 }
    701 
    702 function isUndefined(arg) {
    703   return arg === void 0;
    704 }
    705 
    706 },{}],6:[function(require,module,exports){
    707 // shim for using process in browser
    708 
    709 var process = module.exports = {};
    710 var queue = [];
    711 var draining = false;
    712 
    713 function drainQueue() {
    714     if (draining) {
    715         return;
    716     }
    717     draining = true;
    718     var currentQueue;
    719     var len = queue.length;
    720     while(len) {
    721         currentQueue = queue;
    722         queue = [];
    723         var i = -1;
    724         while (++i < len) {
    725             currentQueue[i]();
    726         }
    727         len = queue.length;
    728     }
    729     draining = false;
    730 }
    731 process.nextTick = function (fun) {
    732     queue.push(fun);
    733     if (!draining) {
    734         setTimeout(drainQueue, 0);
    735     }
    736 };
    737 
    738 process.title = 'browser';
    739 process.browser = true;
    740 process.env = {};
    741 process.argv = [];
    742 process.version = ''; // empty string to avoid regexp issues
    743 process.versions = {};
    744 
    745 function noop() {}
    746 
    747 process.on = noop;
    748 process.addListener = noop;
    749 process.once = noop;
    750 process.off = noop;
    751 process.removeListener = noop;
    752 process.removeAllListeners = noop;
    753 process.emit = noop;
    754 
    755 process.binding = function (name) {
    756     throw new Error('process.binding is not supported');
    757 };
    758 
    759 // TODO(shtylman)
    760 process.cwd = function () { return '/' };
    761 process.chdir = function (dir) {
    762     throw new Error('process.chdir is not supported');
    763 };
    764 process.umask = function() { return 0; };
    765 
    766 },{}],7:[function(require,module,exports){
    767 if (typeof Object.create === 'function') {
    768   // implementation from standard node.js 'util' module
    769   module.exports = function inherits(ctor, superCtor) {
    770     ctor.super_ = superCtor
    771     ctor.prototype = Object.create(superCtor.prototype, {
    772       constructor: {
    773         value: ctor,
    774         enumerable: false,
    775         writable: true,
    776         configurable: true
    777       }
    778     });
    779   };
    780 } else {
    781   // old school shim for old browsers
    782   module.exports = function inherits(ctor, superCtor) {
    783     ctor.super_ = superCtor
    784     var TempCtor = function () {}
    785     TempCtor.prototype = superCtor.prototype
    786     ctor.prototype = new TempCtor()
    787     ctor.prototype.constructor = ctor
    788   }
    789 }
    790 
    791 },{}],8:[function(require,module,exports){
    792 module.exports = function isBuffer(arg) {
    793   return arg && typeof arg === 'object'
    794     && typeof arg.copy === 'function'
    795     && typeof arg.fill === 'function'
    796     && typeof arg.readUInt8 === 'function';
    797 }
    798 },{}],9:[function(require,module,exports){
    799 (function (process,global){
    800 // Copyright Joyent, Inc. and other Node contributors.
    801 //
    802 // Permission is hereby granted, free of charge, to any person obtaining a
    803 // copy of this software and associated documentation files (the
    804 // "Software"), to deal in the Software without restriction, including
    805 // without limitation the rights to use, copy, modify, merge, publish,
    806 // distribute, sublicense, and/or sell copies of the Software, and to permit
    807 // persons to whom the Software is furnished to do so, subject to the
    808 // following conditions:
    809 //
    810 // The above copyright notice and this permission notice shall be included
    811 // in all copies or substantial portions of the Software.
    812 //
    813 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    814 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    815 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
    816 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
    817 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
    818 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
    819 // USE OR OTHER DEALINGS IN THE SOFTWARE.
    820 
    821 var formatRegExp = /%[sdj%]/g;
    822 exports.format = function(f) {
    823   if (!isString(f)) {
    824     var objects = [];
    825     for (var i = 0; i < arguments.length; i++) {
    826       objects.push(inspect(arguments[i]));
    827     }
    828     return objects.join(' ');
    829   }
    830 
    831   var i = 1;
    832   var args = arguments;
    833   var len = args.length;
    834   var str = String(f).replace(formatRegExp, function(x) {
    835     if (x === '%%') return '%';
    836     if (i >= len) return x;
    837     switch (x) {
    838       case '%s': return String(args[i++]);
    839       case '%d': return Number(args[i++]);
    840       case '%j':
    841         try {
    842           return JSON.stringify(args[i++]);
    843         } catch (_) {
    844           return '[Circular]';
    845         }
    846       default:
    847         return x;
    848     }
    849   });
    850   for (var x = args[i]; i < len; x = args[++i]) {
    851     if (isNull(x) || !isObject(x)) {
    852       str += ' ' + x;
    853     } else {
    854       str += ' ' + inspect(x);
    855     }
    856   }
    857   return str;
     6738window.JSHINT.data = function(){
     6739        return {
     6740                errors: fakeJSHINT.data
     6741        };
    8586742};
    8596743
    8606744
    861 // Mark that a method should not be used.
    862 // Returns a modified function which warns once by default.
    863 // If --no-deprecation is set, then it is a no-op.
    864 exports.deprecate = function(fn, msg) {
    865   // Allow for deprecating things in the process of starting up.
    866   if (isUndefined(global.process)) {
    867     return function() {
    868       return exports.deprecate(fn, msg).apply(this, arguments);
    869     };
    870   }
    871 
    872   if (process.noDeprecation === true) {
    873     return fn;
    874   }
    875 
    876   var warned = false;
    877   function deprecated() {
    878     if (!warned) {
    879       if (process.throwDeprecation) {
    880         throw new Error(msg);
    881       } else if (process.traceDeprecation) {
    882         console.trace(msg);
    883       } else {
    884         console.error(msg);
    885       }
    886       warned = true;
    887     }
    888     return fn.apply(this, arguments);
    889   }
    890 
    891   return deprecated;
    892 };
    893 
    894 
    895 var debugs = {};
    896 var debugEnviron;
    897 exports.debuglog = function(set) {
    898   if (isUndefined(debugEnviron))
    899     debugEnviron = process.env.NODE_DEBUG || '';
    900   set = set.toUpperCase();
    901   if (!debugs[set]) {
    902     if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
    903       var pid = process.pid;
    904       debugs[set] = function() {
    905         var msg = exports.format.apply(exports, arguments);
    906         console.error('%s %d: %s', set, pid, msg);
    907       };
    908     } else {
    909       debugs[set] = function() {};
    910     }
    911   }
    912   return debugs[set];
    913 };
    914 
    915 
    916 /**
    917  * Echos the value of a value. Trys to print the value out
    918  * in the best way possible given the different types.
    919  *
    920  * @param {Object} obj The object to print out.
    921  * @param {Object} opts Optional options object that alters the output.
    922  */
    923 /* legacy: obj, showHidden, depth, colors*/
    924 function inspect(obj, opts) {
    925   // default options
    926   var ctx = {
    927     seen: [],
    928     stylize: stylizeNoColor
    929   };
    930   // legacy...
    931   if (arguments.length >= 3) ctx.depth = arguments[2];
    932   if (arguments.length >= 4) ctx.colors = arguments[3];
    933   if (isBoolean(opts)) {
    934     // legacy...
    935     ctx.showHidden = opts;
    936   } else if (opts) {
    937     // got an "options" object
    938     exports._extend(ctx, opts);
    939   }
    940   // set default options
    941   if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
    942   if (isUndefined(ctx.depth)) ctx.depth = 2;
    943   if (isUndefined(ctx.colors)) ctx.colors = false;
    944   if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
    945   if (ctx.colors) ctx.stylize = stylizeWithColor;
    946   return formatValue(ctx, obj, ctx.depth);
    947 }
    948 exports.inspect = inspect;
    949 
    950 
    951 // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
    952 inspect.colors = {
    953   'bold' : [1, 22],
    954   'italic' : [3, 23],
    955   'underline' : [4, 24],
    956   'inverse' : [7, 27],
    957   'white' : [37, 39],
    958   'grey' : [90, 39],
    959   'black' : [30, 39],
    960   'blue' : [34, 39],
    961   'cyan' : [36, 39],
    962   'green' : [32, 39],
    963   'magenta' : [35, 39],
    964   'red' : [31, 39],
    965   'yellow' : [33, 39]
    966 };
    967 
    968 // Don't use 'blue' not visible on cmd.exe
    969 inspect.styles = {
    970   'special': 'cyan',
    971   'number': 'yellow',
    972   'boolean': 'yellow',
    973   'undefined': 'grey',
    974   'null': 'bold',
    975   'string': 'green',
    976   'date': 'magenta',
    977   // "name": intentionally not styling
    978   'regexp': 'red'
    979 };
    980 
    981 
    982 function stylizeWithColor(str, styleType) {
    983   var style = inspect.styles[styleType];
    984 
    985   if (style) {
    986     return '\u001b[' + inspect.colors[style][0] + 'm' + str +
    987            '\u001b[' + inspect.colors[style][1] + 'm';
    988   } else {
    989     return str;
    990   }
    991 }
    992 
    993 
    994 function stylizeNoColor(str, styleType) {
    995   return str;
    996 }
    997 
    998 
    999 function arrayToHash(array) {
    1000   var hash = {};
    1001 
    1002   array.forEach(function(val, idx) {
    1003     hash[val] = true;
    1004   });
    1005 
    1006   return hash;
    1007 }
    1008 
    1009 
    1010 function formatValue(ctx, value, recurseTimes) {
    1011   // Provide a hook for user-specified inspect functions.
    1012   // Check that value is an object with an inspect function on it
    1013   if (ctx.customInspect &&
    1014       value &&
    1015       isFunction(value.inspect) &&
    1016       // Filter out the util module, it's inspect function is special
    1017       value.inspect !== exports.inspect &&
    1018       // Also filter out any prototype objects using the circular check.
    1019       !(value.constructor && value.constructor.prototype === value)) {
    1020     var ret = value.inspect(recurseTimes, ctx);
    1021     if (!isString(ret)) {
    1022       ret = formatValue(ctx, ret, recurseTimes);
    1023     }
    1024     return ret;
    1025   }
    1026 
    1027   // Primitive types cannot have properties
    1028   var primitive = formatPrimitive(ctx, value);
    1029   if (primitive) {
    1030     return primitive;
    1031   }
    1032 
    1033   // Look up the keys of the object.
    1034   var keys = Object.keys(value);
    1035   var visibleKeys = arrayToHash(keys);
    1036 
    1037   if (ctx.showHidden) {
    1038     keys = Object.getOwnPropertyNames(value);
    1039   }
    1040 
    1041   // IE doesn't make error fields non-enumerable
    1042   // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
    1043   if (isError(value)
    1044       && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
    1045     return formatError(value);
    1046   }
    1047 
    1048   // Some type of object without properties can be shortcutted.
    1049   if (keys.length === 0) {
    1050     if (isFunction(value)) {
    1051       var name = value.name ? ': ' + value.name : '';
    1052       return ctx.stylize('[Function' + name + ']', 'special');
    1053     }
    1054     if (isRegExp(value)) {
    1055       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    1056     }
    1057     if (isDate(value)) {
    1058       return ctx.stylize(Date.prototype.toString.call(value), 'date');
    1059     }
    1060     if (isError(value)) {
    1061       return formatError(value);
    1062     }
    1063   }
    1064 
    1065   var base = '', array = false, braces = ['{', '}'];
    1066 
    1067   // Make Array say that they are Array
    1068   if (isArray(value)) {
    1069     array = true;
    1070     braces = ['[', ']'];
    1071   }
    1072 
    1073   // Make functions say that they are functions
    1074   if (isFunction(value)) {
    1075     var n = value.name ? ': ' + value.name : '';
    1076     base = ' [Function' + n + ']';
    1077   }
    1078 
    1079   // Make RegExps say that they are RegExps
    1080   if (isRegExp(value)) {
    1081     base = ' ' + RegExp.prototype.toString.call(value);
    1082   }
    1083 
    1084   // Make dates with properties first say the date
    1085   if (isDate(value)) {
    1086     base = ' ' + Date.prototype.toUTCString.call(value);
    1087   }
    1088 
    1089   // Make error with message first say the error
    1090   if (isError(value)) {
    1091     base = ' ' + formatError(value);
    1092   }
    1093 
    1094   if (keys.length === 0 && (!array || value.length == 0)) {
    1095     return braces[0] + base + braces[1];
    1096   }
    1097 
    1098   if (recurseTimes < 0) {
    1099     if (isRegExp(value)) {
    1100       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    1101     } else {
    1102       return ctx.stylize('[Object]', 'special');
    1103     }
    1104   }
    1105 
    1106   ctx.seen.push(value);
    1107 
    1108   var output;
    1109   if (array) {
    1110     output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
    1111   } else {
    1112     output = keys.map(function(key) {
    1113       return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
    1114     });
    1115   }
    1116 
    1117   ctx.seen.pop();
    1118 
    1119   return reduceToSingleString(output, base, braces);
    1120 }
    1121 
    1122 
    1123 function formatPrimitive(ctx, value) {
    1124   if (isUndefined(value))
    1125     return ctx.stylize('undefined', 'undefined');
    1126   if (isString(value)) {
    1127     var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
    1128                                              .replace(/'/g, "\\'")
    1129                                              .replace(/\\"/g, '"') + '\'';
    1130     return ctx.stylize(simple, 'string');
    1131   }
    1132   if (isNumber(value))
    1133     return ctx.stylize('' + value, 'number');
    1134   if (isBoolean(value))
    1135     return ctx.stylize('' + value, 'boolean');
    1136   // For some reason typeof null is "object", so special case here.
    1137   if (isNull(value))
    1138     return ctx.stylize('null', 'null');
    1139 }
    1140 
    1141 
    1142 function formatError(value) {
    1143   return '[' + Error.prototype.toString.call(value) + ']';
    1144 }
    1145 
    1146 
    1147 function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
    1148   var output = [];
    1149   for (var i = 0, l = value.length; i < l; ++i) {
    1150     if (hasOwnProperty(value, String(i))) {
    1151       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
    1152           String(i), true));
    1153     } else {
    1154       output.push('');
    1155     }
    1156   }
    1157   keys.forEach(function(key) {
    1158     if (!key.match(/^\d+$/)) {
    1159       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
    1160           key, true));
    1161     }
    1162   });
    1163   return output;
    1164 }
    1165 
    1166 
    1167 function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
    1168   var name, str, desc;
    1169   desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
    1170   if (desc.get) {
    1171     if (desc.set) {
    1172       str = ctx.stylize('[Getter/Setter]', 'special');
    1173     } else {
    1174       str = ctx.stylize('[Getter]', 'special');
    1175     }
    1176   } else {
    1177     if (desc.set) {
    1178       str = ctx.stylize('[Setter]', 'special');
    1179     }
    1180   }
    1181   if (!hasOwnProperty(visibleKeys, key)) {
    1182     name = '[' + key + ']';
    1183   }
    1184   if (!str) {
    1185     if (ctx.seen.indexOf(desc.value) < 0) {
    1186       if (isNull(recurseTimes)) {
    1187         str = formatValue(ctx, desc.value, null);
    1188       } else {
    1189         str = formatValue(ctx, desc.value, recurseTimes - 1);
    1190       }
    1191       if (str.indexOf('\n') > -1) {
    1192         if (array) {
    1193           str = str.split('\n').map(function(line) {
    1194             return '  ' + line;
    1195           }).join('\n').substr(2);
    1196         } else {
    1197           str = '\n' + str.split('\n').map(function(line) {
    1198             return '   ' + line;
    1199           }).join('\n');
    1200         }
    1201       }
    1202     } else {
    1203       str = ctx.stylize('[Circular]', 'special');
    1204     }
    1205   }
    1206   if (isUndefined(name)) {
    1207     if (array && key.match(/^\d+$/)) {
    1208       return str;
    1209     }
    1210     name = JSON.stringify('' + key);
    1211     if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
    1212       name = name.substr(1, name.length - 2);
    1213       name = ctx.stylize(name, 'name');
    1214     } else {
    1215       name = name.replace(/'/g, "\\'")
    1216                  .replace(/\\"/g, '"')
    1217                  .replace(/(^"|"$)/g, "'");
    1218       name = ctx.stylize(name, 'string');
    1219     }
    1220   }
    1221 
    1222   return name + ': ' + str;
    1223 }
    1224 
    1225 
    1226 function reduceToSingleString(output, base, braces) {
    1227   var numLinesEst = 0;
    1228   var length = output.reduce(function(prev, cur) {
    1229     numLinesEst++;
    1230     if (cur.indexOf('\n') >= 0) numLinesEst++;
    1231     return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
    1232   }, 0);
    1233 
    1234   if (length > 60) {
    1235     return braces[0] +
    1236            (base === '' ? '' : base + '\n ') +
    1237            ' ' +
    1238            output.join(',\n  ') +
    1239            ' ' +
    1240            braces[1];
    1241   }
    1242 
    1243   return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
    1244 }
    1245 
    1246 
    1247 // NOTE: These type checking functions intentionally don't use `instanceof`
    1248 // because it is fragile and can be easily faked with `Object.create()`.
    1249 function isArray(ar) {
    1250   return Array.isArray(ar);
    1251 }
    1252 exports.isArray = isArray;
    1253 
    1254 function isBoolean(arg) {
    1255   return typeof arg === 'boolean';
    1256 }
    1257 exports.isBoolean = isBoolean;
    1258 
    1259 function isNull(arg) {
    1260   return arg === null;
    1261 }
    1262 exports.isNull = isNull;
    1263 
    1264 function isNullOrUndefined(arg) {
    1265   return arg == null;
    1266 }
    1267 exports.isNullOrUndefined = isNullOrUndefined;
    1268 
    1269 function isNumber(arg) {
    1270   return typeof arg === 'number';
    1271 }
    1272 exports.isNumber = isNumber;
    1273 
    1274 function isString(arg) {
    1275   return typeof arg === 'string';
    1276 }
    1277 exports.isString = isString;
    1278 
    1279 function isSymbol(arg) {
    1280   return typeof arg === 'symbol';
    1281 }
    1282 exports.isSymbol = isSymbol;
    1283 
    1284 function isUndefined(arg) {
    1285   return arg === void 0;
    1286 }
    1287 exports.isUndefined = isUndefined;
    1288 
    1289 function isRegExp(re) {
    1290   return isObject(re) && objectToString(re) === '[object RegExp]';
    1291 }
    1292 exports.isRegExp = isRegExp;
    1293 
    1294 function isObject(arg) {
    1295   return typeof arg === 'object' && arg !== null;
    1296 }
    1297 exports.isObject = isObject;
    1298 
    1299 function isDate(d) {
    1300   return isObject(d) && objectToString(d) === '[object Date]';
    1301 }
    1302 exports.isDate = isDate;
    1303 
    1304 function isError(e) {
    1305   return isObject(e) &&
    1306       (objectToString(e) === '[object Error]' || e instanceof Error);
    1307 }
    1308 exports.isError = isError;
    1309 
    1310 function isFunction(arg) {
    1311   return typeof arg === 'function';
    1312 }
    1313 exports.isFunction = isFunction;
    1314 
    1315 function isPrimitive(arg) {
    1316   return arg === null ||
    1317          typeof arg === 'boolean' ||
    1318          typeof arg === 'number' ||
    1319          typeof arg === 'string' ||
    1320          typeof arg === 'symbol' ||  // ES6 symbol
    1321          typeof arg === 'undefined';
    1322 }
    1323 exports.isPrimitive = isPrimitive;
    1324 
    1325 exports.isBuffer = require('./support/isBuffer');
    1326 
    1327 function objectToString(o) {
    1328   return Object.prototype.toString.call(o);
    1329 }
    1330 
    1331 
    1332 function pad(n) {
    1333   return n < 10 ? '0' + n.toString(10) : n.toString(10);
    1334 }
    1335 
    1336 
    1337 var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
    1338               'Oct', 'Nov', 'Dec'];
    1339 
    1340 // 26 Feb 16:19:34
    1341 function timestamp() {
    1342   var d = new Date();
    1343   var time = [pad(d.getHours()),
    1344               pad(d.getMinutes()),
    1345               pad(d.getSeconds())].join(':');
    1346   return [d.getDate(), months[d.getMonth()], time].join(' ');
    1347 }
    1348 
    1349 
    1350 // log is just a thin wrapper to console.log that prepends a timestamp
    1351 exports.log = function() {
    1352   console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
    1353 };
    1354 
    1355 
    1356 /**
    1357  * Inherit the prototype methods from one constructor into another.
    1358  *
    1359  * The Function.prototype.inherits from lang.js rewritten as a standalone
    1360  * function (not on Function.prototype). NOTE: If this file is to be loaded
    1361  * during bootstrapping this function needs to be rewritten using some native
    1362  * functions as prototype setup using normal JavaScript does not work as
    1363  * expected during bootstrapping (see mirror.js in r114903).
    1364  *
    1365  * @param {function} ctor Constructor function which needs to inherit the
    1366  *     prototype.
    1367  * @param {function} superCtor Constructor function to inherit prototype from.
    1368  */
    1369 exports.inherits = require('inherits');
    1370 
    1371 exports._extend = function(origin, add) {
    1372   // Don't do anything if add isn't an object
    1373   if (!add || !isObject(add)) return origin;
    1374 
    1375   var keys = Object.keys(add);
    1376   var i = keys.length;
    1377   while (i--) {
    1378     origin[keys[i]] = add[keys[i]];
    1379   }
    1380   return origin;
    1381 };
    1382 
    1383 function hasOwnProperty(obj, prop) {
    1384   return Object.prototype.hasOwnProperty.call(obj, prop);
    1385 }
    1386 
    1387 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    1388 },{"./support/isBuffer":8,"_process":6,"inherits":7}],10:[function(require,module,exports){
    1389 (function (global){
    1390 /*global window, global*/
    1391 var util = require("util")
    1392 var assert = require("assert")
    1393 var now = require("date-now")
    1394 
    1395 var slice = Array.prototype.slice
    1396 var console
    1397 var times = {}
    1398 
    1399 if (typeof global !== "undefined" && global.console) {
    1400     console = global.console
    1401 } else if (typeof window !== "undefined" && window.console) {
    1402     console = window.console
    1403 } else {
    1404     console = {}
    1405 }
    1406 
    1407 var functions = [
    1408     [log, "log"],
    1409     [info, "info"],
    1410     [warn, "warn"],
    1411     [error, "error"],
    1412     [time, "time"],
    1413     [timeEnd, "timeEnd"],
    1414     [trace, "trace"],
    1415     [dir, "dir"],
    1416     [consoleAssert, "assert"]
    1417 ]
    1418 
    1419 for (var i = 0; i < functions.length; i++) {
    1420     var tuple = functions[i]
    1421     var f = tuple[0]
    1422     var name = tuple[1]
    1423 
    1424     if (!console[name]) {
    1425         console[name] = f
    1426     }
    1427 }
    1428 
    1429 module.exports = console
    1430 
    1431 function log() {}
    1432 
    1433 function info() {
    1434     console.log.apply(console, arguments)
    1435 }
    1436 
    1437 function warn() {
    1438     console.log.apply(console, arguments)
    1439 }
    1440 
    1441 function error() {
    1442     console.warn.apply(console, arguments)
    1443 }
    1444 
    1445 function time(label) {
    1446     times[label] = now()
    1447 }
    1448 
    1449 function timeEnd(label) {
    1450     var time = times[label]
    1451     if (!time) {
    1452         throw new Error("No such label: " + label)
    1453     }
    1454 
    1455     var duration = now() - time
    1456     console.log(label + ": " + duration + "ms")
    1457 }
    1458 
    1459 function trace() {
    1460     var err = new Error()
    1461     err.name = "Trace"
    1462     err.message = util.format.apply(null, arguments)
    1463     console.error(err.stack)
    1464 }
    1465 
    1466 function dir(object) {
    1467     console.log(util.inspect(object) + "\n")
    1468 }
    1469 
    1470 function consoleAssert(expression) {
    1471     if (!expression) {
    1472         var arr = slice.call(arguments, 1)
    1473         assert.ok(false, util.format.apply(null, arr))
    1474     }
    1475 }
    1476 
    1477 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    1478 },{"assert":4,"date-now":11,"util":9}],11:[function(require,module,exports){
    1479 module.exports = now
    1480 
    1481 function now() {
    1482     return new Date().getTime()
    1483 }
    1484 
    1485 },{}],12:[function(require,module,exports){
    1486 (function (global){
    1487 /**
    1488  * @license
    1489  * lodash 3.7.0 (Custom Build) <https://lodash.com/>
    1490  * Build: `lodash modern -d -o ./index.js`
    1491  * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
    1492  * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
    1493  * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    1494  * Available under MIT license <https://lodash.com/license>
    1495  */
    1496 ;(function() {
    1497 
    1498   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
    1499   var undefined;
    1500 
    1501   /** Used as the semantic version number. */
    1502   var VERSION = '3.7.0';
    1503 
    1504   /** Used to compose bitmasks for wrapper metadata. */
    1505   var BIND_FLAG = 1,
    1506       BIND_KEY_FLAG = 2,
    1507       CURRY_BOUND_FLAG = 4,
    1508       CURRY_FLAG = 8,
    1509       CURRY_RIGHT_FLAG = 16,
    1510       PARTIAL_FLAG = 32,
    1511       PARTIAL_RIGHT_FLAG = 64,
    1512       ARY_FLAG = 128,
    1513       REARG_FLAG = 256;
    1514 
    1515   /** Used as default options for `_.trunc`. */
    1516   var DEFAULT_TRUNC_LENGTH = 30,
    1517       DEFAULT_TRUNC_OMISSION = '...';
    1518 
    1519   /** Used to detect when a function becomes hot. */
    1520   var HOT_COUNT = 150,
    1521       HOT_SPAN = 16;
    1522 
    1523   /** Used to indicate the type of lazy iteratees. */
    1524   var LAZY_DROP_WHILE_FLAG = 0,
    1525       LAZY_FILTER_FLAG = 1,
    1526       LAZY_MAP_FLAG = 2;
    1527 
    1528   /** Used as the `TypeError` message for "Functions" methods. */
    1529   var FUNC_ERROR_TEXT = 'Expected a function';
    1530 
    1531   /** Used as the internal argument placeholder. */
    1532   var PLACEHOLDER = '__lodash_placeholder__';
    1533 
    1534   /** `Object#toString` result references. */
    1535   var argsTag = '[object Arguments]',
    1536       arrayTag = '[object Array]',
    1537       boolTag = '[object Boolean]',
    1538       dateTag = '[object Date]',
    1539       errorTag = '[object Error]',
    1540       funcTag = '[object Function]',
    1541       mapTag = '[object Map]',
    1542       numberTag = '[object Number]',
    1543       objectTag = '[object Object]',
    1544       regexpTag = '[object RegExp]',
    1545       setTag = '[object Set]',
    1546       stringTag = '[object String]',
    1547       weakMapTag = '[object WeakMap]';
    1548 
    1549   var arrayBufferTag = '[object ArrayBuffer]',
    1550       float32Tag = '[object Float32Array]',
    1551       float64Tag = '[object Float64Array]',
    1552       int8Tag = '[object Int8Array]',
    1553       int16Tag = '[object Int16Array]',
    1554       int32Tag = '[object Int32Array]',
    1555       uint8Tag = '[object Uint8Array]',
    1556       uint8ClampedTag = '[object Uint8ClampedArray]',
    1557       uint16Tag = '[object Uint16Array]',
    1558       uint32Tag = '[object Uint32Array]';
    1559 
    1560   /** Used to match empty string literals in compiled template source. */
    1561   var reEmptyStringLeading = /\b__p \+= '';/g,
    1562       reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
    1563       reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
    1564 
    1565   /** Used to match HTML entities and HTML characters. */
    1566   var reEscapedHtml = /&(?:amp|lt|gt|quot|#39|#96);/g,
    1567       reUnescapedHtml = /[&<>"'`]/g,
    1568       reHasEscapedHtml = RegExp(reEscapedHtml.source),
    1569       reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
    1570 
    1571   /** Used to match template delimiters. */
    1572   var reEscape = /<%-([\s\S]+?)%>/g,
    1573       reEvaluate = /<%([\s\S]+?)%>/g,
    1574       reInterpolate = /<%=([\s\S]+?)%>/g;
    1575 
    1576   /** Used to match property names within property paths. */
    1577   var reIsDeepProp = /\.|\[(?:[^[\]]+|(["'])(?:(?!\1)[^\n\\]|\\.)*?)\1\]/,
    1578       reIsPlainProp = /^\w*$/,
    1579       rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;
    1580 
    1581   /**
    1582    * Used to match `RegExp` [special characters](http://www.regular-expressions.info/characters.html#special).
    1583    * In addition to special characters the forward slash is escaped to allow for
    1584    * easier `eval` use and `Function` compilation.
    1585    */
    1586   var reRegExpChars = /[.*+?^${}()|[\]\/\\]/g,
    1587       reHasRegExpChars = RegExp(reRegExpChars.source);
    1588 
    1589   /** Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). */
    1590   var reComboMark = /[\u0300-\u036f\ufe20-\ufe23]/g;
    1591 
    1592   /** Used to match backslashes in property paths. */
    1593   var reEscapeChar = /\\(\\)?/g;
    1594 
    1595   /** Used to match [ES template delimiters](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-template-literal-lexical-components). */
    1596   var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
    1597 
    1598   /** Used to match `RegExp` flags from their coerced string values. */
    1599   var reFlags = /\w*$/;
    1600 
    1601   /** Used to detect hexadecimal string values. */
    1602   var reHasHexPrefix = /^0[xX]/;
    1603 
    1604   /** Used to detect host constructors (Safari > 5). */
    1605   var reIsHostCtor = /^\[object .+?Constructor\]$/;
    1606 
    1607   /** Used to match latin-1 supplementary letters (excluding mathematical operators). */
    1608   var reLatin1 = /[\xc0-\xd6\xd8-\xde\xdf-\xf6\xf8-\xff]/g;
    1609 
    1610   /** Used to ensure capturing order of template delimiters. */
    1611   var reNoMatch = /($^)/;
    1612 
    1613   /** Used to match unescaped characters in compiled string literals. */
    1614   var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
    1615 
    1616   /** Used to match words to create compound words. */
    1617   var reWords = (function() {
    1618     var upper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]',
    1619         lower = '[a-z\\xdf-\\xf6\\xf8-\\xff]+';
    1620 
    1621     return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g');
    1622   }());
    1623 
    1624   /** Used to detect and test for whitespace. */
    1625   var whitespace = (
    1626     // Basic whitespace characters.
    1627     ' \t\x0b\f\xa0\ufeff' +
    1628 
    1629     // Line terminators.
    1630     '\n\r\u2028\u2029' +
    1631 
    1632     // Unicode category "Zs" space separators.
    1633     '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
    1634   );
    1635 
    1636   /** Used to assign default `context` object properties. */
    1637   var contextProps = [
    1638     'Array', 'ArrayBuffer', 'Date', 'Error', 'Float32Array', 'Float64Array',
    1639     'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Math', 'Number',
    1640     'Object', 'RegExp', 'Set', 'String', '_', 'clearTimeout', 'document',
    1641     'isFinite', 'parseInt', 'setTimeout', 'TypeError', 'Uint8Array',
    1642     'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
    1643     'window'
    1644   ];
    1645 
    1646   /** Used to make template sourceURLs easier to identify. */
    1647   var templateCounter = -1;
    1648 
    1649   /** Used to identify `toStringTag` values of typed arrays. */
    1650   var typedArrayTags = {};
    1651   typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
    1652   typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
    1653   typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
    1654   typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
    1655   typedArrayTags[uint32Tag] = true;
    1656   typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
    1657   typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
    1658   typedArrayTags[dateTag] = typedArrayTags[errorTag] =
    1659   typedArrayTags[funcTag] = typedArrayTags[mapTag] =
    1660   typedArrayTags[numberTag] = typedArrayTags[objectTag] =
    1661   typedArrayTags[regexpTag] = typedArrayTags[setTag] =
    1662   typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
    1663 
    1664   /** Used to identify `toStringTag` values supported by `_.clone`. */
    1665   var cloneableTags = {};
    1666   cloneableTags[argsTag] = cloneableTags[arrayTag] =
    1667   cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =
    1668   cloneableTags[dateTag] = cloneableTags[float32Tag] =
    1669   cloneableTags[float64Tag] = cloneableTags[int8Tag] =
    1670   cloneableTags[int16Tag] = cloneableTags[int32Tag] =
    1671   cloneableTags[numberTag] = cloneableTags[objectTag] =
    1672   cloneableTags[regexpTag] = cloneableTags[stringTag] =
    1673   cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
    1674   cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
    1675   cloneableTags[errorTag] = cloneableTags[funcTag] =
    1676   cloneableTags[mapTag] = cloneableTags[setTag] =
    1677   cloneableTags[weakMapTag] = false;
    1678 
    1679   /** Used as an internal `_.debounce` options object by `_.throttle`. */
    1680   var debounceOptions = {
    1681     'leading': false,
    1682     'maxWait': 0,
    1683     'trailing': false
    1684   };
    1685 
    1686   /** Used to map latin-1 supplementary letters to basic latin letters. */
    1687   var deburredLetters = {
    1688     '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
    1689     '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
    1690     '\xc7': 'C',  '\xe7': 'c',
    1691     '\xd0': 'D',  '\xf0': 'd',
    1692     '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
    1693     '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
    1694     '\xcC': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
    1695     '\xeC': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
    1696     '\xd1': 'N',  '\xf1': 'n',
    1697     '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
    1698     '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
    1699     '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
    1700     '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
    1701     '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
    1702     '\xc6': 'Ae', '\xe6': 'ae',
    1703     '\xde': 'Th', '\xfe': 'th',
    1704     '\xdf': 'ss'
    1705   };
    1706 
    1707   /** Used to map characters to HTML entities. */
    1708   var htmlEscapes = {
    1709     '&': '&amp;',
    1710     '<': '&lt;',
    1711     '>': '&gt;',
    1712     '"': '&quot;',
    1713     "'": '&#39;',
    1714     '`': '&#96;'
    1715   };
    1716 
    1717   /** Used to map HTML entities to characters. */
    1718   var htmlUnescapes = {
    1719     '&amp;': '&',
    1720     '&lt;': '<',
    1721     '&gt;': '>',
    1722     '&quot;': '"',
    1723     '&#39;': "'",
    1724     '&#96;': '`'
    1725   };
    1726 
    1727   /** Used to determine if values are of the language type `Object`. */
    1728   var objectTypes = {
    1729     'function': true,
    1730     'object': true
    1731   };
    1732 
    1733   /** Used to escape characters for inclusion in compiled string literals. */
    1734   var stringEscapes = {
    1735     '\\': '\\',
    1736     "'": "'",
    1737     '\n': 'n',
    1738     '\r': 'r',
    1739     '\u2028': 'u2028',
    1740     '\u2029': 'u2029'
    1741   };
    1742 
    1743   /** Detect free variable `exports`. */
    1744   var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
    1745 
    1746   /** Detect free variable `module`. */
    1747   var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
    1748 
    1749   /** Detect free variable `global` from Node.js. */
    1750   var freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global;
    1751 
    1752   /** Detect free variable `self`. */
    1753   var freeSelf = objectTypes[typeof self] && self && self.Object && self;
    1754 
    1755   /** Detect free variable `window`. */
    1756   var freeWindow = objectTypes[typeof window] && window && window.Object && window;
    1757 
    1758   /** Detect the popular CommonJS extension `module.exports`. */
    1759   var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
    1760 
    1761   /**
    1762    * Used as a reference to the global object.
    1763    *
    1764    * The `this` value is used if it is the global object to avoid Greasemonkey's
    1765    * restricted `window` object, otherwise the `window` object is used.
    1766    */
    1767   var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;
    1768 
    1769   /*--------------------------------------------------------------------------*/
    1770 
    1771   /**
    1772    * The base implementation of `compareAscending` which compares values and
    1773    * sorts them in ascending order without guaranteeing a stable sort.
    1774    *
    1775    * @private
    1776    * @param {*} value The value to compare to `other`.
    1777    * @param {*} other The value to compare to `value`.
    1778    * @returns {number} Returns the sort order indicator for `value`.
    1779    */
    1780   function baseCompareAscending(value, other) {
    1781     if (value !== other) {
    1782       var valIsReflexive = value === value,
    1783           othIsReflexive = other === other;
    1784 
    1785       if (value > other || !valIsReflexive || (value === undefined && othIsReflexive)) {
    1786         return 1;
    1787       }
    1788       if (value < other || !othIsReflexive || (other === undefined && valIsReflexive)) {
    1789         return -1;
    1790       }
    1791     }
    1792     return 0;
    1793   }
    1794 
    1795   /**
    1796    * The base implementation of `_.findIndex` and `_.findLastIndex` without
    1797    * support for callback shorthands and `this` binding.
    1798    *
    1799    * @private
    1800    * @param {Array} array The array to search.
    1801    * @param {Function} predicate The function invoked per iteration.
    1802    * @param {boolean} [fromRight] Specify iterating from right to left.
    1803    * @returns {number} Returns the index of the matched value, else `-1`.
    1804    */
    1805   function baseFindIndex(array, predicate, fromRight) {
    1806     var length = array.length,
    1807         index = fromRight ? length : -1;
    1808 
    1809     while ((fromRight ? index-- : ++index < length)) {
    1810       if (predicate(array[index], index, array)) {
    1811         return index;
    1812       }
    1813     }
    1814     return -1;
    1815   }
    1816 
    1817   /**
    1818    * The base implementation of `_.indexOf` without support for binary searches.
    1819    *
    1820    * @private
    1821    * @param {Array} array The array to search.
    1822    * @param {*} value The value to search for.
    1823    * @param {number} fromIndex The index to search from.
    1824    * @returns {number} Returns the index of the matched value, else `-1`.
    1825    */
    1826   function baseIndexOf(array, value, fromIndex) {
    1827     if (value !== value) {
    1828       return indexOfNaN(array, fromIndex);
    1829     }
    1830     var index = fromIndex - 1,
    1831         length = array.length;
    1832 
    1833     while (++index < length) {
    1834       if (array[index] === value) {
    1835         return index;
    1836       }
    1837     }
    1838     return -1;
    1839   }
    1840 
    1841   /**
    1842    * The base implementation of `_.isFunction` without support for environments
    1843    * with incorrect `typeof` results.
    1844    *
    1845    * @private
    1846    * @param {*} value The value to check.
    1847    * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    1848    */
    1849   function baseIsFunction(value) {
    1850     // Avoid a Chakra JIT bug in compatibility modes of IE 11.
    1851     // See https://github.com/jashkenas/underscore/issues/1621 for more details.
    1852     return typeof value == 'function' || false;
    1853   }
    1854 
    1855   /**
    1856    * Converts `value` to a string if it is not one. An empty string is returned
    1857    * for `null` or `undefined` values.
    1858    *
    1859    * @private
    1860    * @param {*} value The value to process.
    1861    * @returns {string} Returns the string.
    1862    */
    1863   function baseToString(value) {
    1864     if (typeof value == 'string') {
    1865       return value;
    1866     }
    1867     return value == null ? '' : (value + '');
    1868   }
    1869 
    1870   /**
    1871    * Used by `_.max` and `_.min` as the default callback for string values.
    1872    *
    1873    * @private
    1874    * @param {string} string The string to inspect.
    1875    * @returns {number} Returns the code unit of the first character of the string.
    1876    */
    1877   function charAtCallback(string) {
    1878     return string.charCodeAt(0);
    1879   }
    1880 
    1881   /**
    1882    * Used by `_.trim` and `_.trimLeft` to get the index of the first character
    1883    * of `string` that is not found in `chars`.
    1884    *
    1885    * @private
    1886    * @param {string} string The string to inspect.
    1887    * @param {string} chars The characters to find.
    1888    * @returns {number} Returns the index of the first character not found in `chars`.
    1889    */
    1890   function charsLeftIndex(string, chars) {
    1891     var index = -1,
    1892         length = string.length;
    1893 
    1894     while (++index < length && chars.indexOf(string.charAt(index)) > -1) {}
    1895     return index;
    1896   }
    1897 
    1898   /**
    1899    * Used by `_.trim` and `_.trimRight` to get the index of the last character
    1900    * of `string` that is not found in `chars`.
    1901    *
    1902    * @private
    1903    * @param {string} string The string to inspect.
    1904    * @param {string} chars The characters to find.
    1905    * @returns {number} Returns the index of the last character not found in `chars`.
    1906    */
    1907   function charsRightIndex(string, chars) {
    1908     var index = string.length;
    1909 
    1910     while (index-- && chars.indexOf(string.charAt(index)) > -1) {}
    1911     return index;
    1912   }
    1913 
    1914   /**
    1915    * Used by `_.sortBy` to compare transformed elements of a collection and stable
    1916    * sort them in ascending order.
    1917    *
    1918    * @private
    1919    * @param {Object} object The object to compare to `other`.
    1920    * @param {Object} other The object to compare to `object`.
    1921    * @returns {number} Returns the sort order indicator for `object`.
    1922    */
    1923   function compareAscending(object, other) {
    1924     return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);
    1925   }
    1926 
    1927   /**
    1928    * Used by `_.sortByOrder` to compare multiple properties of each element
    1929    * in a collection and stable sort them in the following order:
    1930    *
    1931    * If `orders` is unspecified, sort in ascending order for all properties.
    1932    * Otherwise, for each property, sort in ascending order if its corresponding value in
    1933    * orders is true, and descending order if false.
    1934    *
    1935    * @private
    1936    * @param {Object} object The object to compare to `other`.
    1937    * @param {Object} other The object to compare to `object`.
    1938    * @param {boolean[]} orders The order to sort by for each property.
    1939    * @returns {number} Returns the sort order indicator for `object`.
    1940    */
    1941   function compareMultiple(object, other, orders) {
    1942     var index = -1,
    1943         objCriteria = object.criteria,
    1944         othCriteria = other.criteria,
    1945         length = objCriteria.length,
    1946         ordersLength = orders.length;
    1947 
    1948     while (++index < length) {
    1949       var result = baseCompareAscending(objCriteria[index], othCriteria[index]);
    1950       if (result) {
    1951         if (index >= ordersLength) {
    1952           return result;
    1953         }
    1954         return result * (orders[index] ? 1 : -1);
    1955       }
    1956     }
    1957     // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
    1958     // that causes it, under certain circumstances, to provide the same value for
    1959     // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
    1960     // for more details.
    1961     //
    1962     // This also ensures a stable sort in V8 and other engines.
    1963     // See https://code.google.com/p/v8/issues/detail?id=90 for more details.
    1964     return object.index - other.index;
    1965   }
    1966 
    1967   /**
    1968    * Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters.
    1969    *
    1970    * @private
    1971    * @param {string} letter The matched letter to deburr.
    1972    * @returns {string} Returns the deburred letter.
    1973    */
    1974   function deburrLetter(letter) {
    1975     return deburredLetters[letter];
    1976   }
    1977 
    1978   /**
    1979    * Used by `_.escape` to convert characters to HTML entities.
    1980    *
    1981    * @private
    1982    * @param {string} chr The matched character to escape.
    1983    * @returns {string} Returns the escaped character.
    1984    */
    1985   function escapeHtmlChar(chr) {
    1986     return htmlEscapes[chr];
    1987   }
    1988 
    1989   /**
    1990    * Used by `_.template` to escape characters for inclusion in compiled
    1991    * string literals.
    1992    *
    1993    * @private
    1994    * @param {string} chr The matched character to escape.
    1995    * @returns {string} Returns the escaped character.
    1996    */
    1997   function escapeStringChar(chr) {
    1998     return '\\' + stringEscapes[chr];
    1999   }
    2000 
    2001   /**
    2002    * Gets the index at which the first occurrence of `NaN` is found in `array`.
    2003    *
    2004    * @private
    2005    * @param {Array} array The array to search.
    2006    * @param {number} fromIndex The index to search from.
    2007    * @param {boolean} [fromRight] Specify iterating from right to left.
    2008    * @returns {number} Returns the index of the matched `NaN`, else `-1`.
    2009    */
    2010   function indexOfNaN(array, fromIndex, fromRight) {
    2011     var length = array.length,
    2012         index = fromIndex + (fromRight ? 0 : -1);
    2013 
    2014     while ((fromRight ? index-- : ++index < length)) {
    2015       var other = array[index];
    2016       if (other !== other) {
    2017         return index;
    2018       }
    2019     }
    2020     return -1;
    2021   }
    2022 
    2023   /**
    2024    * Checks if `value` is object-like.
    2025    *
    2026    * @private
    2027    * @param {*} value The value to check.
    2028    * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
    2029    */
    2030   function isObjectLike(value) {
    2031     return !!value && typeof value == 'object';
    2032   }
    2033 
    2034   /**
    2035    * Used by `trimmedLeftIndex` and `trimmedRightIndex` to determine if a
    2036    * character code is whitespace.
    2037    *
    2038    * @private
    2039    * @param {number} charCode The character code to inspect.
    2040    * @returns {boolean} Returns `true` if `charCode` is whitespace, else `false`.
    2041    */
    2042   function isSpace(charCode) {
    2043     return ((charCode <= 160 && (charCode >= 9 && charCode <= 13) || charCode == 32 || charCode == 160) || charCode == 5760 || charCode == 6158 ||
    2044       (charCode >= 8192 && (charCode <= 8202 || charCode == 8232 || charCode == 8233 || charCode == 8239 || charCode == 8287 || charCode == 12288 || charCode == 65279)));
    2045   }
    2046 
    2047   /**
    2048    * Replaces all `placeholder` elements in `array` with an internal placeholder
    2049    * and returns an array of their indexes.
    2050    *
    2051    * @private
    2052    * @param {Array} array The array to modify.
    2053    * @param {*} placeholder The placeholder to replace.
    2054    * @returns {Array} Returns the new array of placeholder indexes.
    2055    */
    2056   function replaceHolders(array, placeholder) {
    2057     var index = -1,
    2058         length = array.length,
    2059         resIndex = -1,
    2060         result = [];
    2061 
    2062     while (++index < length) {
    2063       if (array[index] === placeholder) {
    2064         array[index] = PLACEHOLDER;
    2065         result[++resIndex] = index;
    2066       }
    2067     }
    2068     return result;
    2069   }
    2070 
    2071   /**
    2072    * An implementation of `_.uniq` optimized for sorted arrays without support
    2073    * for callback shorthands and `this` binding.
    2074    *
    2075    * @private
    2076    * @param {Array} array The array to inspect.
    2077    * @param {Function} [iteratee] The function invoked per iteration.
    2078    * @returns {Array} Returns the new duplicate-value-free array.
    2079    */
    2080   function sortedUniq(array, iteratee) {
    2081     var seen,
    2082         index = -1,
    2083         length = array.length,
    2084         resIndex = -1,
    2085         result = [];
    2086 
    2087     while (++index < length) {
    2088       var value = array[index],
    2089           computed = iteratee ? iteratee(value, index, array) : value;
    2090 
    2091       if (!index || seen !== computed) {
    2092         seen = computed;
    2093         result[++resIndex] = value;
    2094       }
    2095     }
    2096     return result;
    2097   }
    2098 
    2099   /**
    2100    * Used by `_.trim` and `_.trimLeft` to get the index of the first non-whitespace
    2101    * character of `string`.
    2102    *
    2103    * @private
    2104    * @param {string} string The string to inspect.
    2105    * @returns {number} Returns the index of the first non-whitespace character.
    2106    */
    2107   function trimmedLeftIndex(string) {
    2108     var index = -1,
    2109         length = string.length;
    2110 
    2111     while (++index < length && isSpace(string.charCodeAt(index))) {}
    2112     return index;
    2113   }
    2114 
    2115   /**
    2116    * Used by `_.trim` and `_.trimRight` to get the index of the last non-whitespace
    2117    * character of `string`.
    2118    *
    2119    * @private
    2120    * @param {string} string The string to inspect.
    2121    * @returns {number} Returns the index of the last non-whitespace character.
    2122    */
    2123   function trimmedRightIndex(string) {
    2124     var index = string.length;
    2125 
    2126     while (index-- && isSpace(string.charCodeAt(index))) {}
    2127     return index;
    2128   }
    2129 
    2130   /**
    2131    * Used by `_.unescape` to convert HTML entities to characters.
    2132    *
    2133    * @private
    2134    * @param {string} chr The matched character to unescape.
    2135    * @returns {string} Returns the unescaped character.
    2136    */
    2137   function unescapeHtmlChar(chr) {
    2138     return htmlUnescapes[chr];
    2139   }
    2140 
    2141   /*--------------------------------------------------------------------------*/
    2142 
    2143   /**
    2144    * Create a new pristine `lodash` function using the given `context` object.
    2145    *
    2146    * @static
    2147    * @memberOf _
    2148    * @category Utility
    2149    * @param {Object} [context=root] The context object.
    2150    * @returns {Function} Returns a new `lodash` function.
    2151    * @example
    2152    *
    2153    * _.mixin({ 'foo': _.constant('foo') });
    2154    *
    2155    * var lodash = _.runInContext();
    2156    * lodash.mixin({ 'bar': lodash.constant('bar') });
    2157    *
    2158    * _.isFunction(_.foo);
    2159    * // => true
    2160    * _.isFunction(_.bar);
    2161    * // => false
    2162    *
    2163    * lodash.isFunction(lodash.foo);
    2164    * // => false
    2165    * lodash.isFunction(lodash.bar);
    2166    * // => true
    2167    *
    2168    * // using `context` to mock `Date#getTime` use in `_.now`
    2169    * var mock = _.runInContext({
    2170    *   'Date': function() {
    2171    *     return { 'getTime': getTimeMock };
    2172    *   }
    2173    * });
    2174    *
    2175    * // or creating a suped-up `defer` in Node.js
    2176    * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
    2177    */
    2178   function runInContext(context) {
    2179     // Avoid issues with some ES3 environments that attempt to use values, named
    2180     // after built-in constructors like `Object`, for the creation of literals.
    2181     // ES5 clears this up by stating that literals must use built-in constructors.
    2182     // See https://es5.github.io/#x11.1.5 for more details.
    2183     context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;
    2184 
    2185     /** Native constructor references. */
    2186     var Array = context.Array,
    2187         Date = context.Date,
    2188         Error = context.Error,
    2189         Function = context.Function,
    2190         Math = context.Math,
    2191         Number = context.Number,
    2192         Object = context.Object,
    2193         RegExp = context.RegExp,
    2194         String = context.String,
    2195         TypeError = context.TypeError;
    2196 
    2197     /** Used for native method references. */
    2198     var arrayProto = Array.prototype,
    2199         objectProto = Object.prototype,
    2200         stringProto = String.prototype;
    2201 
    2202     /** Used to detect DOM support. */
    2203     var document = (document = context.window) && document.document;
    2204 
    2205     /** Used to resolve the decompiled source of functions. */
    2206     var fnToString = Function.prototype.toString;
    2207 
    2208     /** Used to check objects for own properties. */
    2209     var hasOwnProperty = objectProto.hasOwnProperty;
    2210 
    2211     /** Used to generate unique IDs. */
    2212     var idCounter = 0;
    2213 
    2214     /**
    2215      * Used to resolve the [`toStringTag`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)
    2216      * of values.
    2217      */
    2218     var objToString = objectProto.toString;
    2219 
    2220     /** Used to restore the original `_` reference in `_.noConflict`. */
    2221     var oldDash = context._;
    2222 
    2223     /** Used to detect if a method is native. */
    2224     var reIsNative = RegExp('^' +
    2225       escapeRegExp(objToString)
    2226       .replace(/toString|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
    2227     );
    2228 
    2229     /** Native method references. */
    2230     var ArrayBuffer = isNative(ArrayBuffer = context.ArrayBuffer) && ArrayBuffer,
    2231         bufferSlice = isNative(bufferSlice = ArrayBuffer && new ArrayBuffer(0).slice) && bufferSlice,
    2232         ceil = Math.ceil,
    2233         clearTimeout = context.clearTimeout,
    2234         floor = Math.floor,
    2235         getOwnPropertySymbols = isNative(getOwnPropertySymbols = Object.getOwnPropertySymbols) && getOwnPropertySymbols,
    2236         getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
    2237         push = arrayProto.push,
    2238         preventExtensions = isNative(Object.preventExtensions = Object.preventExtensions) && preventExtensions,
    2239         propertyIsEnumerable = objectProto.propertyIsEnumerable,
    2240         Set = isNative(Set = context.Set) && Set,
    2241         setTimeout = context.setTimeout,
    2242         splice = arrayProto.splice,
    2243         Uint8Array = isNative(Uint8Array = context.Uint8Array) && Uint8Array,
    2244         WeakMap = isNative(WeakMap = context.WeakMap) && WeakMap;
    2245 
    2246     /** Used to clone array buffers. */
    2247     var Float64Array = (function() {
    2248       // Safari 5 errors when using an array buffer to initialize a typed array
    2249       // where the array buffer's `byteLength` is not a multiple of the typed
    2250       // array's `BYTES_PER_ELEMENT`.
    2251       try {
    2252         var func = isNative(func = context.Float64Array) && func,
    2253             result = new func(new ArrayBuffer(10), 0, 1) && func;
    2254       } catch(e) {}
    2255       return result;
    2256     }());
    2257 
    2258     /** Used as `baseAssign`. */
    2259     var nativeAssign = (function() {
    2260       // Avoid `Object.assign` in Firefox 34-37 which have an early implementation
    2261       // with a now defunct try/catch behavior. See https://bugzilla.mozilla.org/show_bug.cgi?id=1103344
    2262       // for more details.
    2263       //
    2264       // Use `Object.preventExtensions` on a plain object instead of simply using
    2265       // `Object('x')` because Chrome and IE fail to throw an error when attempting
    2266       // to assign values to readonly indexes of strings in strict mode.
    2267       var object = { '1': 0 },
    2268           func = preventExtensions && isNative(func = Object.assign) && func;
    2269 
    2270       try { func(preventExtensions(object), 'xo'); } catch(e) {}
    2271       return !object[1] && func;
    2272     }());
    2273 
    2274     /* Native method references for those with the same name as other `lodash` methods. */
    2275     var nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray,
    2276         nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate,
    2277         nativeIsFinite = context.isFinite,
    2278         nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys,
    2279         nativeMax = Math.max,
    2280         nativeMin = Math.min,
    2281         nativeNow = isNative(nativeNow = Date.now) && nativeNow,
    2282         nativeNumIsFinite = isNative(nativeNumIsFinite = Number.isFinite) && nativeNumIsFinite,
    2283         nativeParseInt = context.parseInt,
    2284         nativeRandom = Math.random;
    2285 
    2286     /** Used as references for `-Infinity` and `Infinity`. */
    2287     var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY,
    2288         POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
    2289 
    2290     /** Used as references for the maximum length and index of an array. */
    2291     var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1,
    2292         MAX_ARRAY_INDEX =  MAX_ARRAY_LENGTH - 1,
    2293         HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
    2294 
    2295     /** Used as the size, in bytes, of each `Float64Array` element. */
    2296     var FLOAT64_BYTES_PER_ELEMENT = Float64Array ? Float64Array.BYTES_PER_ELEMENT : 0;
    2297 
    2298     /**
    2299      * Used as the [maximum length](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.max_safe_integer)
    2300      * of an array-like value.
    2301      */
    2302     var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
    2303 
    2304     /** Used to store function metadata. */
    2305     var metaMap = WeakMap && new WeakMap;
    2306 
    2307     /** Used to lookup unminified function names. */
    2308     var realNames = {};
    2309 
    2310     /*------------------------------------------------------------------------*/
    2311 
    2312     /**
    2313      * Creates a `lodash` object which wraps `value` to enable implicit chaining.
    2314      * Methods that operate on and return arrays, collections, and functions can
    2315      * be chained together. Methods that return a boolean or single value will
    2316      * automatically end the chain returning the unwrapped value. Explicit chaining
    2317      * may be enabled using `_.chain`. The execution of chained methods is lazy,
    2318      * that is, execution is deferred until `_#value` is implicitly or explicitly
    2319      * called.
    2320      *
    2321      * Lazy evaluation allows several methods to support shortcut fusion. Shortcut
    2322      * fusion is an optimization that merges iteratees to avoid creating intermediate
    2323      * arrays and reduce the number of iteratee executions.
    2324      *
    2325      * Chaining is supported in custom builds as long as the `_#value` method is
    2326      * directly or indirectly included in the build.
    2327      *
    2328      * In addition to lodash methods, wrappers have `Array` and `String` methods.
    2329      *
    2330      * The wrapper `Array` methods are:
    2331      * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`,
    2332      * `splice`, and `unshift`
    2333      *
    2334      * The wrapper `String` methods are:
    2335      * `replace` and `split`
    2336      *
    2337      * The wrapper methods that support shortcut fusion are:
    2338      * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`,
    2339      * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`,
    2340      * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`,
    2341      * and `where`
    2342      *
    2343      * The chainable wrapper methods are:
    2344      * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`,
    2345      * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`,
    2346      * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defer`, `delay`,
    2347      * `difference`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `fill`,
    2348      * `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`, `forEach`,
    2349      * `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `functions`,
    2350      * `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, `invoke`, `keys`,
    2351      * `keysIn`, `map`, `mapValues`, `matches`, `matchesProperty`, `memoize`,
    2352      * `merge`, `mixin`, `negate`, `omit`, `once`, `pairs`, `partial`, `partialRight`,
    2353      * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`,
    2354      * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `reverse`,
    2355      * `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`, `sortByOrder`, `splice`,
    2356      * `spread`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `tap`,
    2357      * `throttle`, `thru`, `times`, `toArray`, `toPlainObject`, `transform`,
    2358      * `union`, `uniq`, `unshift`, `unzip`, `values`, `valuesIn`, `where`,
    2359      * `without`, `wrap`, `xor`, `zip`, and `zipObject`
    2360      *
    2361      * The wrapper methods that are **not** chainable by default are:
    2362      * `add`, `attempt`, `camelCase`, `capitalize`, `clone`, `cloneDeep`, `deburr`,
    2363      * `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`,
    2364      * `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`, `has`,
    2365      * `identity`, `includes`, `indexOf`, `inRange`, `isArguments`, `isArray`,
    2366      * `isBoolean`, `isDate`, `isElement`, `isEmpty`, `isEqual`, `isError`, `isFinite`
    2367      * `isFunction`, `isMatch`, `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`,
    2368      * `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `isTypedArray`,
    2369      * `join`, `kebabCase`, `last`, `lastIndexOf`, `max`, `min`, `noConflict`,
    2370      * `noop`, `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, `random`,
    2371      * `reduce`, `reduceRight`, `repeat`, `result`, `runInContext`, `shift`, `size`,
    2372      * `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, `startCase`, `startsWith`,
    2373      * `sum`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`, `unescape`,
    2374      * `uniqueId`, `value`, and `words`
    2375      *
    2376      * The wrapper method `sample` will return a wrapped value when `n` is provided,
    2377      * otherwise an unwrapped value is returned.
    2378      *
    2379      * @name _
    2380      * @constructor
    2381      * @category Chain
    2382      * @param {*} value The value to wrap in a `lodash` instance.
    2383      * @returns {Object} Returns the new `lodash` wrapper instance.
    2384      * @example
    2385      *
    2386      * var wrapped = _([1, 2, 3]);
    2387      *
    2388      * // returns an unwrapped value
    2389      * wrapped.reduce(function(total, n) {
    2390      *   return total + n;
    2391      * });
    2392      * // => 6
    2393      *
    2394      * // returns a wrapped value
    2395      * var squares = wrapped.map(function(n) {
    2396      *   return n * n;
    2397      * });
    2398      *
    2399      * _.isArray(squares);
    2400      * // => false
    2401      *
    2402      * _.isArray(squares.value());
    2403      * // => true
    2404      */
    2405     function lodash(value) {
    2406       if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
    2407         if (value instanceof LodashWrapper) {
    2408           return value;
    2409         }
    2410         if (hasOwnProperty.call(value, '__chain__') && hasOwnProperty.call(value, '__wrapped__')) {
    2411           return wrapperClone(value);
    2412         }
    2413       }
    2414       return new LodashWrapper(value);
    2415     }
    2416 
    2417     /**
    2418      * The function whose prototype all chaining wrappers inherit from.
    2419      *
    2420      * @private
    2421      */
    2422     function baseLodash() {
    2423       // No operation performed.
    2424     }
    2425 
    2426     /**
    2427      * The base constructor for creating `lodash` wrapper objects.
    2428      *
    2429      * @private
    2430      * @param {*} value The value to wrap.
    2431      * @param {boolean} [chainAll] Enable chaining for all wrapper methods.
    2432      * @param {Array} [actions=[]] Actions to peform to resolve the unwrapped value.
    2433      */
    2434     function LodashWrapper(value, chainAll, actions) {
    2435       this.__wrapped__ = value;
    2436       this.__actions__ = actions || [];
    2437       this.__chain__ = !!chainAll;
    2438     }
    2439 
    2440     /**
    2441      * An object environment feature flags.
    2442      *
    2443      * @static
    2444      * @memberOf _
    2445      * @type Object
    2446      */
    2447     var support = lodash.support = {};
    2448 
    2449     (function(x) {
    2450       var Ctor = function() { this.x = x; },
    2451           object = { '0': x, 'length': x },
    2452           props = [];
    2453 
    2454       Ctor.prototype = { 'valueOf': x, 'y': x };
    2455       for (var key in new Ctor) { props.push(key); }
    2456 
    2457       /**
    2458        * Detect if functions can be decompiled by `Function#toString`
    2459        * (all but Firefox OS certified apps, older Opera mobile browsers, and
    2460        * the PlayStation 3; forced `false` for Windows 8 apps).
    2461        *
    2462        * @memberOf _.support
    2463        * @type boolean
    2464        */
    2465       support.funcDecomp = /\bthis\b/.test(function() { return this; });
    2466 
    2467       /**
    2468        * Detect if `Function#name` is supported (all but IE).
    2469        *
    2470        * @memberOf _.support
    2471        * @type boolean
    2472        */
    2473       support.funcNames = typeof Function.name == 'string';
    2474 
    2475       /**
    2476        * Detect if the DOM is supported.
    2477        *
    2478        * @memberOf _.support
    2479        * @type boolean
    2480        */
    2481       try {
    2482         support.dom = document.createDocumentFragment().nodeType === 11;
    2483       } catch(e) {
    2484         support.dom = false;
    2485       }
    2486 
    2487       /**
    2488        * Detect if `arguments` object indexes are non-enumerable.
    2489        *
    2490        * In Firefox < 4, IE < 9, PhantomJS, and Safari < 5.1 `arguments` object
    2491        * indexes are non-enumerable. Chrome < 25 and Node.js < 0.11.0 treat
    2492        * `arguments` object indexes as non-enumerable and fail `hasOwnProperty`
    2493        * checks for indexes that exceed the number of function parameters and
    2494        * whose associated argument values are `0`.
    2495        *
    2496        * @memberOf _.support
    2497        * @type boolean
    2498        */
    2499       try {
    2500         support.nonEnumArgs = !propertyIsEnumerable.call(arguments, 1);
    2501       } catch(e) {
    2502         support.nonEnumArgs = true;
    2503       }
    2504     }(1, 0));
    2505 
    2506     /**
    2507      * By default, the template delimiters used by lodash are like those in
    2508      * embedded Ruby (ERB). Change the following template settings to use
    2509      * alternative delimiters.
    2510      *
    2511      * @static
    2512      * @memberOf _
    2513      * @type Object
    2514      */
    2515     lodash.templateSettings = {
    2516 
    2517       /**
    2518        * Used to detect `data` property values to be HTML-escaped.
    2519        *
    2520        * @memberOf _.templateSettings
    2521        * @type RegExp
    2522        */
    2523       'escape': reEscape,
    2524 
    2525       /**
    2526        * Used to detect code to be evaluated.
    2527        *
    2528        * @memberOf _.templateSettings
    2529        * @type RegExp
    2530        */
    2531       'evaluate': reEvaluate,
    2532 
    2533       /**
    2534        * Used to detect `data` property values to inject.
    2535        *
    2536        * @memberOf _.templateSettings
    2537        * @type RegExp
    2538        */
    2539       'interpolate': reInterpolate,
    2540 
    2541       /**
    2542        * Used to reference the data object in the template text.
    2543        *
    2544        * @memberOf _.templateSettings
    2545        * @type string
    2546        */
    2547       'variable': '',
    2548 
    2549       /**
    2550        * Used to import variables into the compiled template.
    2551        *
    2552        * @memberOf _.templateSettings
    2553        * @type Object
    2554        */
    2555       'imports': {
    2556 
    2557         /**
    2558          * A reference to the `lodash` function.
    2559          *
    2560          * @memberOf _.templateSettings.imports
    2561          * @type Function
    2562          */
    2563         '_': lodash
    2564       }
    2565     };
    2566 
    2567     /*------------------------------------------------------------------------*/
    2568 
    2569     /**
    2570      * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
    2571      *
    2572      * @private
    2573      * @param {*} value The value to wrap.
    2574      */
    2575     function LazyWrapper(value) {
    2576       this.__wrapped__ = value;
    2577       this.__actions__ = null;
    2578       this.__dir__ = 1;
    2579       this.__dropCount__ = 0;
    2580       this.__filtered__ = false;
    2581       this.__iteratees__ = null;
    2582       this.__takeCount__ = POSITIVE_INFINITY;
    2583       this.__views__ = null;
    2584     }
    2585 
    2586     /**
    2587      * Creates a clone of the lazy wrapper object.
    2588      *
    2589      * @private
    2590      * @name clone
    2591      * @memberOf LazyWrapper
    2592      * @returns {Object} Returns the cloned `LazyWrapper` object.
    2593      */
    2594     function lazyClone() {
    2595       var actions = this.__actions__,
    2596           iteratees = this.__iteratees__,
    2597           views = this.__views__,
    2598           result = new LazyWrapper(this.__wrapped__);
    2599 
    2600       result.__actions__ = actions ? arrayCopy(actions) : null;
    2601       result.__dir__ = this.__dir__;
    2602       result.__filtered__ = this.__filtered__;
    2603       result.__iteratees__ = iteratees ? arrayCopy(iteratees) : null;
    2604       result.__takeCount__ = this.__takeCount__;
    2605       result.__views__ = views ? arrayCopy(views) : null;
    2606       return result;
    2607     }
    2608 
    2609     /**
    2610      * Reverses the direction of lazy iteration.
    2611      *
    2612      * @private
    2613      * @name reverse
    2614      * @memberOf LazyWrapper
    2615      * @returns {Object} Returns the new reversed `LazyWrapper` object.
    2616      */
    2617     function lazyReverse() {
    2618       if (this.__filtered__) {
    2619         var result = new LazyWrapper(this);
    2620         result.__dir__ = -1;
    2621         result.__filtered__ = true;
    2622       } else {
    2623         result = this.clone();
    2624         result.__dir__ *= -1;
    2625       }
    2626       return result;
    2627     }
    2628 
    2629     /**
    2630      * Extracts the unwrapped value from its lazy wrapper.
    2631      *
    2632      * @private
    2633      * @name value
    2634      * @memberOf LazyWrapper
    2635      * @returns {*} Returns the unwrapped value.
    2636      */
    2637     function lazyValue() {
    2638       var array = this.__wrapped__.value();
    2639       if (!isArray(array)) {
    2640         return baseWrapperValue(array, this.__actions__);
    2641       }
    2642       var dir = this.__dir__,
    2643           isRight = dir < 0,
    2644           view = getView(0, array.length, this.__views__),
    2645           start = view.start,
    2646           end = view.end,
    2647           length = end - start,
    2648           index = isRight ? end : (start - 1),
    2649           takeCount = nativeMin(length, this.__takeCount__),
    2650           iteratees = this.__iteratees__,
    2651           iterLength = iteratees ? iteratees.length : 0,
    2652           resIndex = 0,
    2653           result = [];
    2654 
    2655       outer:
    2656       while (length-- && resIndex < takeCount) {
    2657         index += dir;
    2658 
    2659         var iterIndex = -1,
    2660             value = array[index];
    2661 
    2662         while (++iterIndex < iterLength) {
    2663           var data = iteratees[iterIndex],
    2664               iteratee = data.iteratee,
    2665               type = data.type;
    2666 
    2667           if (type == LAZY_DROP_WHILE_FLAG) {
    2668             if (data.done && (isRight ? (index > data.index) : (index < data.index))) {
    2669               data.count = 0;
    2670               data.done = false;
    2671             }
    2672             data.index = index;
    2673             if (!data.done) {
    2674               var limit = data.limit;
    2675               if (!(data.done = limit > -1 ? (data.count++ >= limit) : !iteratee(value))) {
    2676                 continue outer;
    2677               }
    2678             }
    2679           } else {
    2680             var computed = iteratee(value);
    2681             if (type == LAZY_MAP_FLAG) {
    2682               value = computed;
    2683             } else if (!computed) {
    2684               if (type == LAZY_FILTER_FLAG) {
    2685                 continue outer;
    2686               } else {
    2687                 break outer;
    2688               }
    2689             }
    2690           }
    2691         }
    2692         result[resIndex++] = value;
    2693       }
    2694       return result;
    2695     }
    2696 
    2697     /*------------------------------------------------------------------------*/
    2698 
    2699     /**
    2700      * Creates a cache object to store key/value pairs.
    2701      *
    2702      * @private
    2703      * @static
    2704      * @name Cache
    2705      * @memberOf _.memoize
    2706      */
    2707     function MapCache() {
    2708       this.__data__ = {};
    2709     }
    2710 
    2711     /**
    2712      * Removes `key` and its value from the cache.
    2713      *
    2714      * @private
    2715      * @name delete
    2716      * @memberOf _.memoize.Cache
    2717      * @param {string} key The key of the value to remove.
    2718      * @returns {boolean} Returns `true` if the entry was removed successfully, else `false`.
    2719      */
    2720     function mapDelete(key) {
    2721       return this.has(key) && delete this.__data__[key];
    2722     }
    2723 
    2724     /**
    2725      * Gets the cached value for `key`.
    2726      *
    2727      * @private
    2728      * @name get
    2729      * @memberOf _.memoize.Cache
    2730      * @param {string} key The key of the value to get.
    2731      * @returns {*} Returns the cached value.
    2732      */
    2733     function mapGet(key) {
    2734       return key == '__proto__' ? undefined : this.__data__[key];
    2735     }
    2736 
    2737     /**
    2738      * Checks if a cached value for `key` exists.
    2739      *
    2740      * @private
    2741      * @name has
    2742      * @memberOf _.memoize.Cache
    2743      * @param {string} key The key of the entry to check.
    2744      * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
    2745      */
    2746     function mapHas(key) {
    2747       return key != '__proto__' && hasOwnProperty.call(this.__data__, key);
    2748     }
    2749 
    2750     /**
    2751      * Sets `value` to `key` of the cache.
    2752      *
    2753      * @private
    2754      * @name set
    2755      * @memberOf _.memoize.Cache
    2756      * @param {string} key The key of the value to cache.
    2757      * @param {*} value The value to cache.
    2758      * @returns {Object} Returns the cache object.
    2759      */
    2760     function mapSet(key, value) {
    2761       if (key != '__proto__') {
    2762         this.__data__[key] = value;
    2763       }
    2764       return this;
    2765     }
    2766 
    2767     /*------------------------------------------------------------------------*/
    2768 
    2769     /**
    2770      *
    2771      * Creates a cache object to store unique values.
    2772      *
    2773      * @private
    2774      * @param {Array} [values] The values to cache.
    2775      */
    2776     function SetCache(values) {
    2777       var length = values ? values.length : 0;
    2778 
    2779       this.data = { 'hash': nativeCreate(null), 'set': new Set };
    2780       while (length--) {
    2781         this.push(values[length]);
    2782       }
    2783     }
    2784 
    2785     /**
    2786      * Checks if `value` is in `cache` mimicking the return signature of
    2787      * `_.indexOf` by returning `0` if the value is found, else `-1`.
    2788      *
    2789      * @private
    2790      * @param {Object} cache The cache to search.
    2791      * @param {*} value The value to search for.
    2792      * @returns {number} Returns `0` if `value` is found, else `-1`.
    2793      */
    2794     function cacheIndexOf(cache, value) {
    2795       var data = cache.data,
    2796           result = (typeof value == 'string' || isObject(value)) ? data.set.has(value) : data.hash[value];
    2797 
    2798       return result ? 0 : -1;
    2799     }
    2800 
    2801     /**
    2802      * Adds `value` to the cache.
    2803      *
    2804      * @private
    2805      * @name push
    2806      * @memberOf SetCache
    2807      * @param {*} value The value to cache.
    2808      */
    2809     function cachePush(value) {
    2810       var data = this.data;
    2811       if (typeof value == 'string' || isObject(value)) {
    2812         data.set.add(value);
    2813       } else {
    2814         data.hash[value] = true;
    2815       }
    2816     }
    2817 
    2818     /*------------------------------------------------------------------------*/
    2819 
    2820     /**
    2821      * Copies the values of `source` to `array`.
    2822      *
    2823      * @private
    2824      * @param {Array} source The array to copy values from.
    2825      * @param {Array} [array=[]] The array to copy values to.
    2826      * @returns {Array} Returns `array`.
    2827      */
    2828     function arrayCopy(source, array) {
    2829       var index = -1,
    2830           length = source.length;
    2831 
    2832       array || (array = Array(length));
    2833       while (++index < length) {
    2834         array[index] = source[index];
    2835       }
    2836       return array;
    2837     }
    2838 
    2839     /**
    2840      * A specialized version of `_.forEach` for arrays without support for callback
    2841      * shorthands and `this` binding.
    2842      *
    2843      * @private
    2844      * @param {Array} array The array to iterate over.
    2845      * @param {Function} iteratee The function invoked per iteration.
    2846      * @returns {Array} Returns `array`.
    2847      */
    2848     function arrayEach(array, iteratee) {
    2849       var index = -1,
    2850           length = array.length;
    2851 
    2852       while (++index < length) {
    2853         if (iteratee(array[index], index, array) === false) {
    2854           break;
    2855         }
    2856       }
    2857       return array;
    2858     }
    2859 
    2860     /**
    2861      * A specialized version of `_.forEachRight` for arrays without support for
    2862      * callback shorthands and `this` binding.
    2863      *
    2864      * @private
    2865      * @param {Array} array The array to iterate over.
    2866      * @param {Function} iteratee The function invoked per iteration.
    2867      * @returns {Array} Returns `array`.
    2868      */
    2869     function arrayEachRight(array, iteratee) {
    2870       var length = array.length;
    2871 
    2872       while (length--) {
    2873         if (iteratee(array[length], length, array) === false) {
    2874           break;
    2875         }
    2876       }
    2877       return array;
    2878     }
    2879 
    2880     /**
    2881      * A specialized version of `_.every` for arrays without support for callback
    2882      * shorthands and `this` binding.
    2883      *
    2884      * @private
    2885      * @param {Array} array The array to iterate over.
    2886      * @param {Function} predicate The function invoked per iteration.
    2887      * @returns {boolean} Returns `true` if all elements pass the predicate check,
    2888      *  else `false`.
    2889      */
    2890     function arrayEvery(array, predicate) {
    2891       var index = -1,
    2892           length = array.length;
    2893 
    2894       while (++index < length) {
    2895         if (!predicate(array[index], index, array)) {
    2896           return false;
    2897         }
    2898       }
    2899       return true;
    2900     }
    2901 
    2902     /**
    2903      * A specialized version of `_.filter` for arrays without support for callback
    2904      * shorthands and `this` binding.
    2905      *
    2906      * @private
    2907      * @param {Array} array The array to iterate over.
    2908      * @param {Function} predicate The function invoked per iteration.
    2909      * @returns {Array} Returns the new filtered array.
    2910      */
    2911     function arrayFilter(array, predicate) {
    2912       var index = -1,
    2913           length = array.length,
    2914           resIndex = -1,
    2915           result = [];
    2916 
    2917       while (++index < length) {
    2918         var value = array[index];
    2919         if (predicate(value, index, array)) {
    2920           result[++resIndex] = value;
    2921         }
    2922       }
    2923       return result;
    2924     }
    2925 
    2926     /**
    2927      * A specialized version of `_.map` for arrays without support for callback
    2928      * shorthands and `this` binding.
    2929      *
    2930      * @private
    2931      * @param {Array} array The array to iterate over.
    2932      * @param {Function} iteratee The function invoked per iteration.
    2933      * @returns {Array} Returns the new mapped array.
    2934      */
    2935     function arrayMap(array, iteratee) {
    2936       var index = -1,
    2937           length = array.length,
    2938           result = Array(length);
    2939 
    2940       while (++index < length) {
    2941         result[index] = iteratee(array[index], index, array);
    2942       }
    2943       return result;
    2944     }
    2945 
    2946     /**
    2947      * A specialized version of `_.max` for arrays without support for iteratees.
    2948      *
    2949      * @private
    2950      * @param {Array} array The array to iterate over.
    2951      * @returns {*} Returns the maximum value.
    2952      */
    2953     function arrayMax(array) {
    2954       var index = -1,
    2955           length = array.length,
    2956           result = NEGATIVE_INFINITY;
    2957 
    2958       while (++index < length) {
    2959         var value = array[index];
    2960         if (value > result) {
    2961           result = value;
    2962         }
    2963       }
    2964       return result;
    2965     }
    2966 
    2967     /**
    2968      * A specialized version of `_.min` for arrays without support for iteratees.
    2969      *
    2970      * @private
    2971      * @param {Array} array The array to iterate over.
    2972      * @returns {*} Returns the minimum value.
    2973      */
    2974     function arrayMin(array) {
    2975       var index = -1,
    2976           length = array.length,
    2977           result = POSITIVE_INFINITY;
    2978 
    2979       while (++index < length) {
    2980         var value = array[index];
    2981         if (value < result) {
    2982           result = value;
    2983         }
    2984       }
    2985       return result;
    2986     }
    2987 
    2988     /**
    2989      * A specialized version of `_.reduce` for arrays without support for callback
    2990      * shorthands and `this` binding.
    2991      *
    2992      * @private
    2993      * @param {Array} array The array to iterate over.
    2994      * @param {Function} iteratee The function invoked per iteration.
    2995      * @param {*} [accumulator] The initial value.
    2996      * @param {boolean} [initFromArray] Specify using the first element of `array`
    2997      *  as the initial value.
    2998      * @returns {*} Returns the accumulated value.
    2999      */
    3000     function arrayReduce(array, iteratee, accumulator, initFromArray) {
    3001       var index = -1,
    3002           length = array.length;
    3003 
    3004       if (initFromArray && length) {
    3005         accumulator = array[++index];
    3006       }
    3007       while (++index < length) {
    3008         accumulator = iteratee(accumulator, array[index], index, array);
    3009       }
    3010       return accumulator;
    3011     }
    3012 
    3013     /**
    3014      * A specialized version of `_.reduceRight` for arrays without support for
    3015      * callback shorthands and `this` binding.
    3016      *
    3017      * @private
    3018      * @param {Array} array The array to iterate over.
    3019      * @param {Function} iteratee The function invoked per iteration.
    3020      * @param {*} [accumulator] The initial value.
    3021      * @param {boolean} [initFromArray] Specify using the last element of `array`
    3022      *  as the initial value.
    3023      * @returns {*} Returns the accumulated value.
    3024      */
    3025     function arrayReduceRight(array, iteratee, accumulator, initFromArray) {
    3026       var length = array.length;
    3027       if (initFromArray && length) {
    3028         accumulator = array[--length];
    3029       }
    3030       while (length--) {
    3031         accumulator = iteratee(accumulator, array[length], length, array);
    3032       }
    3033       return accumulator;
    3034     }
    3035 
    3036     /**
    3037      * A specialized version of `_.some` for arrays without support for callback
    3038      * shorthands and `this` binding.
    3039      *
    3040      * @private
    3041      * @param {Array} array The array to iterate over.
    3042      * @param {Function} predicate The function invoked per iteration.
    3043      * @returns {boolean} Returns `true` if any element passes the predicate check,
    3044      *  else `false`.
    3045      */
    3046     function arraySome(array, predicate) {
    3047       var index = -1,
    3048           length = array.length;
    3049 
    3050       while (++index < length) {
    3051         if (predicate(array[index], index, array)) {
    3052           return true;
    3053         }
    3054       }
    3055       return false;
    3056     }
    3057 
    3058     /**
    3059      * A specialized version of `_.sum` for arrays without support for iteratees.
    3060      *
    3061      * @private
    3062      * @param {Array} array The array to iterate over.
    3063      * @returns {number} Returns the sum.
    3064      */
    3065     function arraySum(array) {
    3066       var length = array.length,
    3067           result = 0;
    3068 
    3069       while (length--) {
    3070         result += +array[length] || 0;
    3071       }
    3072       return result;
    3073     }
    3074 
    3075     /**
    3076      * Used by `_.defaults` to customize its `_.assign` use.
    3077      *
    3078      * @private
    3079      * @param {*} objectValue The destination object property value.
    3080      * @param {*} sourceValue The source object property value.
    3081      * @returns {*} Returns the value to assign to the destination object.
    3082      */
    3083     function assignDefaults(objectValue, sourceValue) {
    3084       return objectValue === undefined ? sourceValue : objectValue;
    3085     }
    3086 
    3087     /**
    3088      * Used by `_.template` to customize its `_.assign` use.
    3089      *
    3090      * **Note:** This function is like `assignDefaults` except that it ignores
    3091      * inherited property values when checking if a property is `undefined`.
    3092      *
    3093      * @private
    3094      * @param {*} objectValue The destination object property value.
    3095      * @param {*} sourceValue The source object property value.
    3096      * @param {string} key The key associated with the object and source values.
    3097      * @param {Object} object The destination object.
    3098      * @returns {*} Returns the value to assign to the destination object.
    3099      */
    3100     function assignOwnDefaults(objectValue, sourceValue, key, object) {
    3101       return (objectValue === undefined || !hasOwnProperty.call(object, key))
    3102         ? sourceValue
    3103         : objectValue;
    3104     }
    3105 
    3106     /**
    3107      * A specialized version of `_.assign` for customizing assigned values without
    3108      * support for argument juggling, multiple sources, and `this` binding `customizer`
    3109      * functions.
    3110      *
    3111      * @private
    3112      * @param {Object} object The destination object.
    3113      * @param {Object} source The source object.
    3114      * @param {Function} customizer The function to customize assigned values.
    3115      * @returns {Object} Returns `object`.
    3116      */
    3117     function assignWith(object, source, customizer) {
    3118       var props = keys(source);
    3119       push.apply(props, getSymbols(source));
    3120 
    3121       var index = -1,
    3122           length = props.length;
    3123 
    3124       while (++index < length) {
    3125         var key = props[index],
    3126             value = object[key],
    3127             result = customizer(value, source[key], key, object, source);
    3128 
    3129         if ((result === result ? (result !== value) : (value === value)) ||
    3130             (value === undefined && !(key in object))) {
    3131           object[key] = result;
    3132         }
    3133       }
    3134       return object;
    3135     }
    3136 
    3137     /**
    3138      * The base implementation of `_.assign` without support for argument juggling,
    3139      * multiple sources, and `customizer` functions.
    3140      *
    3141      * @private
    3142      * @param {Object} object The destination object.
    3143      * @param {Object} source The source object.
    3144      * @returns {Object} Returns `object`.
    3145      */
    3146     var baseAssign = nativeAssign || function(object, source) {
    3147       return source == null
    3148         ? object
    3149         : baseCopy(source, getSymbols(source), baseCopy(source, keys(source), object));
    3150     };
    3151 
    3152     /**
    3153      * The base implementation of `_.at` without support for string collections
    3154      * and individual key arguments.
    3155      *
    3156      * @private
    3157      * @param {Array|Object} collection The collection to iterate over.
    3158      * @param {number[]|string[]} props The property names or indexes of elements to pick.
    3159      * @returns {Array} Returns the new array of picked elements.
    3160      */
    3161     function baseAt(collection, props) {
    3162       var index = -1,
    3163           length = collection.length,
    3164           isArr = isLength(length),
    3165           propsLength = props.length,
    3166           result = Array(propsLength);
    3167 
    3168       while(++index < propsLength) {
    3169         var key = props[index];
    3170         if (isArr) {
    3171           result[index] = isIndex(key, length) ? collection[key] : undefined;
    3172         } else {
    3173           result[index] = collection[key];
    3174         }
    3175       }
    3176       return result;
    3177     }
    3178 
    3179     /**
    3180      * Copies properties of `source` to `object`.
    3181      *
    3182      * @private
    3183      * @param {Object} source The object to copy properties from.
    3184      * @param {Array} props The property names to copy.
    3185      * @param {Object} [object={}] The object to copy properties to.
    3186      * @returns {Object} Returns `object`.
    3187      */
    3188     function baseCopy(source, props, object) {
    3189       object || (object = {});
    3190 
    3191       var index = -1,
    3192           length = props.length;
    3193 
    3194       while (++index < length) {
    3195         var key = props[index];
    3196         object[key] = source[key];
    3197       }
    3198       return object;
    3199     }
    3200 
    3201     /**
    3202      * The base implementation of `_.callback` which supports specifying the
    3203      * number of arguments to provide to `func`.
    3204      *
    3205      * @private
    3206      * @param {*} [func=_.identity] The value to convert to a callback.
    3207      * @param {*} [thisArg] The `this` binding of `func`.
    3208      * @param {number} [argCount] The number of arguments to provide to `func`.
    3209      * @returns {Function} Returns the callback.
    3210      */
    3211     function baseCallback(func, thisArg, argCount) {
    3212       var type = typeof func;
    3213       if (type == 'function') {
    3214         return thisArg === undefined
    3215           ? func
    3216           : bindCallback(func, thisArg, argCount);
    3217       }
    3218       if (func == null) {
    3219         return identity;
    3220       }
    3221       if (type == 'object') {
    3222         return baseMatches(func);
    3223       }
    3224       return thisArg === undefined
    3225         ? property(func)
    3226         : baseMatchesProperty(func, thisArg);
    3227     }
    3228 
    3229     /**
    3230      * The base implementation of `_.clone` without support for argument juggling
    3231      * and `this` binding `customizer` functions.
    3232      *
    3233      * @private
    3234      * @param {*} value The value to clone.
    3235      * @param {boolean} [isDeep] Specify a deep clone.
    3236      * @param {Function} [customizer] The function to customize cloning values.
    3237      * @param {string} [key] The key of `value`.
    3238      * @param {Object} [object] The object `value` belongs to.
    3239      * @param {Array} [stackA=[]] Tracks traversed source objects.
    3240      * @param {Array} [stackB=[]] Associates clones with source counterparts.
    3241      * @returns {*} Returns the cloned value.
    3242      */
    3243     function baseClone(value, isDeep, customizer, key, object, stackA, stackB) {
    3244       var result;
    3245       if (customizer) {
    3246         result = object ? customizer(value, key, object) : customizer(value);
    3247       }
    3248       if (result !== undefined) {
    3249         return result;
    3250       }
    3251       if (!isObject(value)) {
    3252         return value;
    3253       }
    3254       var isArr = isArray(value);
    3255       if (isArr) {
    3256         result = initCloneArray(value);
    3257         if (!isDeep) {
    3258           return arrayCopy(value, result);
    3259         }
    3260       } else {
    3261         var tag = objToString.call(value),
    3262             isFunc = tag == funcTag;
    3263 
    3264         if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
    3265           result = initCloneObject(isFunc ? {} : value);
    3266           if (!isDeep) {
    3267             return baseAssign(result, value);
    3268           }
    3269         } else {
    3270           return cloneableTags[tag]
    3271             ? initCloneByTag(value, tag, isDeep)
    3272             : (object ? value : {});
    3273         }
    3274       }
    3275       // Check for circular references and return corresponding clone.
    3276       stackA || (stackA = []);
    3277       stackB || (stackB = []);
    3278 
    3279       var length = stackA.length;
    3280       while (length--) {
    3281         if (stackA[length] == value) {
    3282           return stackB[length];
    3283         }
    3284       }
    3285       // Add the source value to the stack of traversed objects and associate it with its clone.
    3286       stackA.push(value);
    3287       stackB.push(result);
    3288 
    3289       // Recursively populate clone (susceptible to call stack limits).
    3290       (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
    3291         result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB);
    3292       });
    3293       return result;
    3294     }
    3295 
    3296     /**
    3297      * The base implementation of `_.create` without support for assigning
    3298      * properties to the created object.
    3299      *
    3300      * @private
    3301      * @param {Object} prototype The object to inherit from.
    3302      * @returns {Object} Returns the new object.
    3303      */
    3304     var baseCreate = (function() {
    3305       function Object() {}
    3306       return function(prototype) {
    3307         if (isObject(prototype)) {
    3308           Object.prototype = prototype;
    3309           var result = new Object;
    3310           Object.prototype = null;
    3311         }
    3312         return result || context.Object();
    3313       };
    3314     }());
    3315 
    3316     /**
    3317      * The base implementation of `_.delay` and `_.defer` which accepts an index
    3318      * of where to slice the arguments to provide to `func`.
    3319      *
    3320      * @private
    3321      * @param {Function} func The function to delay.
    3322      * @param {number} wait The number of milliseconds to delay invocation.
    3323      * @param {Object} args The arguments provide to `func`.
    3324      * @returns {number} Returns the timer id.
    3325      */
    3326     function baseDelay(func, wait, args) {
    3327       if (typeof func != 'function') {
    3328         throw new TypeError(FUNC_ERROR_TEXT);
    3329       }
    3330       return setTimeout(function() { func.apply(undefined, args); }, wait);
    3331     }
    3332 
    3333     /**
    3334      * The base implementation of `_.difference` which accepts a single array
    3335      * of values to exclude.
    3336      *
    3337      * @private
    3338      * @param {Array} array The array to inspect.
    3339      * @param {Array} values The values to exclude.
    3340      * @returns {Array} Returns the new array of filtered values.
    3341      */
    3342     function baseDifference(array, values) {
    3343       var length = array ? array.length : 0,
    3344           result = [];
    3345 
    3346       if (!length) {
    3347         return result;
    3348       }
    3349       var index = -1,
    3350           indexOf = getIndexOf(),
    3351           isCommon = indexOf == baseIndexOf,
    3352           cache = (isCommon && values.length >= 200) ? createCache(values) : null,
    3353           valuesLength = values.length;
    3354 
    3355       if (cache) {
    3356         indexOf = cacheIndexOf;
    3357         isCommon = false;
    3358         values = cache;
    3359       }
    3360       outer:
    3361       while (++index < length) {
    3362         var value = array[index];
    3363 
    3364         if (isCommon && value === value) {
    3365           var valuesIndex = valuesLength;
    3366           while (valuesIndex--) {
    3367             if (values[valuesIndex] === value) {
    3368               continue outer;
    3369             }
    3370           }
    3371           result.push(value);
    3372         }
    3373         else if (indexOf(values, value, 0) < 0) {
    3374           result.push(value);
    3375         }
    3376       }
    3377       return result;
    3378     }
    3379 
    3380     /**
    3381      * The base implementation of `_.forEach` without support for callback
    3382      * shorthands and `this` binding.
    3383      *
    3384      * @private
    3385      * @param {Array|Object|string} collection The collection to iterate over.
    3386      * @param {Function} iteratee The function invoked per iteration.
    3387      * @returns {Array|Object|string} Returns `collection`.
    3388      */
    3389     var baseEach = createBaseEach(baseForOwn);
    3390 
    3391     /**
    3392      * The base implementation of `_.forEachRight` without support for callback
    3393      * shorthands and `this` binding.
    3394      *
    3395      * @private
    3396      * @param {Array|Object|string} collection The collection to iterate over.
    3397      * @param {Function} iteratee The function invoked per iteration.
    3398      * @returns {Array|Object|string} Returns `collection`.
    3399      */
    3400     var baseEachRight = createBaseEach(baseForOwnRight, true);
    3401 
    3402     /**
    3403      * The base implementation of `_.every` without support for callback
    3404      * shorthands and `this` binding.
    3405      *
    3406      * @private
    3407      * @param {Array|Object|string} collection The collection to iterate over.
    3408      * @param {Function} predicate The function invoked per iteration.
    3409      * @returns {boolean} Returns `true` if all elements pass the predicate check,
    3410      *  else `false`
    3411      */
    3412     function baseEvery(collection, predicate) {
    3413       var result = true;
    3414       baseEach(collection, function(value, index, collection) {
    3415         result = !!predicate(value, index, collection);
    3416         return result;
    3417       });
    3418       return result;
    3419     }
    3420 
    3421     /**
    3422      * The base implementation of `_.fill` without an iteratee call guard.
    3423      *
    3424      * @private
    3425      * @param {Array} array The array to fill.
    3426      * @param {*} value The value to fill `array` with.
    3427      * @param {number} [start=0] The start position.
    3428      * @param {number} [end=array.length] The end position.
    3429      * @returns {Array} Returns `array`.
    3430      */
    3431     function baseFill(array, value, start, end) {
    3432       var length = array.length;
    3433 
    3434       start = start == null ? 0 : (+start || 0);
    3435       if (start < 0) {
    3436         start = -start > length ? 0 : (length + start);
    3437       }
    3438       end = (end === undefined || end > length) ? length : (+end || 0);
    3439       if (end < 0) {
    3440         end += length;
    3441       }
    3442       length = start > end ? 0 : (end >>> 0);
    3443       start >>>= 0;
    3444 
    3445       while (start < length) {
    3446         array[start++] = value;
    3447       }
    3448       return array;
    3449     }
    3450 
    3451     /**
    3452      * The base implementation of `_.filter` without support for callback
    3453      * shorthands and `this` binding.
    3454      *
    3455      * @private
    3456      * @param {Array|Object|string} collection The collection to iterate over.
    3457      * @param {Function} predicate The function invoked per iteration.
    3458      * @returns {Array} Returns the new filtered array.
    3459      */
    3460     function baseFilter(collection, predicate) {
    3461       var result = [];
    3462       baseEach(collection, function(value, index, collection) {
    3463         if (predicate(value, index, collection)) {
    3464           result.push(value);
    3465         }
    3466       });
    3467       return result;
    3468     }
    3469 
    3470     /**
    3471      * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`,
    3472      * without support for callback shorthands and `this` binding, which iterates
    3473      * over `collection` using the provided `eachFunc`.
    3474      *
    3475      * @private
    3476      * @param {Array|Object|string} collection The collection to search.
    3477      * @param {Function} predicate The function invoked per iteration.
    3478      * @param {Function} eachFunc The function to iterate over `collection`.
    3479      * @param {boolean} [retKey] Specify returning the key of the found element
    3480      *  instead of the element itself.
    3481      * @returns {*} Returns the found element or its key, else `undefined`.
    3482      */
    3483     function baseFind(collection, predicate, eachFunc, retKey) {
    3484       var result;
    3485       eachFunc(collection, function(value, key, collection) {
    3486         if (predicate(value, key, collection)) {
    3487           result = retKey ? key : value;
    3488           return false;
    3489         }
    3490       });
    3491       return result;
    3492     }
    3493 
    3494     /**
    3495      * The base implementation of `_.flatten` with added support for restricting
    3496      * flattening and specifying the start index.
    3497      *
    3498      * @private
    3499      * @param {Array} array The array to flatten.
    3500      * @param {boolean} isDeep Specify a deep flatten.
    3501      * @param {boolean} isStrict Restrict flattening to arrays and `arguments` objects.
    3502      * @returns {Array} Returns the new flattened array.
    3503      */
    3504     function baseFlatten(array, isDeep, isStrict) {
    3505       var index = -1,
    3506           length = array.length,
    3507           resIndex = -1,
    3508           result = [];
    3509 
    3510       while (++index < length) {
    3511         var value = array[index];
    3512 
    3513         if (isObjectLike(value) && isLength(value.length) && (isArray(value) || isArguments(value))) {
    3514           if (isDeep) {
    3515             // Recursively flatten arrays (susceptible to call stack limits).
    3516             value = baseFlatten(value, isDeep, isStrict);
    3517           }
    3518           var valIndex = -1,
    3519               valLength = value.length;
    3520 
    3521           result.length += valLength;
    3522           while (++valIndex < valLength) {
    3523             result[++resIndex] = value[valIndex];
    3524           }
    3525         } else if (!isStrict) {
    3526           result[++resIndex] = value;
    3527         }
    3528       }
    3529       return result;
    3530     }
    3531 
    3532     /**
    3533      * The base implementation of `baseForIn` and `baseForOwn` which iterates
    3534      * over `object` properties returned by `keysFunc` invoking `iteratee` for
    3535      * each property. Iteratee functions may exit iteration early by explicitly
    3536      * returning `false`.
    3537      *
    3538      * @private
    3539      * @param {Object} object The object to iterate over.
    3540      * @param {Function} iteratee The function invoked per iteration.
    3541      * @param {Function} keysFunc The function to get the keys of `object`.
    3542      * @returns {Object} Returns `object`.
    3543      */
    3544     var baseFor = createBaseFor();
    3545 
    3546     /**
    3547      * This function is like `baseFor` except that it iterates over properties
    3548      * in the opposite order.
    3549      *
    3550      * @private
    3551      * @param {Object} object The object to iterate over.
    3552      * @param {Function} iteratee The function invoked per iteration.
    3553      * @param {Function} keysFunc The function to get the keys of `object`.
    3554      * @returns {Object} Returns `object`.
    3555      */
    3556     var baseForRight = createBaseFor(true);
    3557 
    3558     /**
    3559      * The base implementation of `_.forIn` without support for callback
    3560      * shorthands and `this` binding.
    3561      *
    3562      * @private
    3563      * @param {Object} object The object to iterate over.
    3564      * @param {Function} iteratee The function invoked per iteration.
    3565      * @returns {Object} Returns `object`.
    3566      */
    3567     function baseForIn(object, iteratee) {
    3568       return baseFor(object, iteratee, keysIn);
    3569     }
    3570 
    3571     /**
    3572      * The base implementation of `_.forOwn` without support for callback
    3573      * shorthands and `this` binding.
    3574      *
    3575      * @private
    3576      * @param {Object} object The object to iterate over.
    3577      * @param {Function} iteratee The function invoked per iteration.
    3578      * @returns {Object} Returns `object`.
    3579      */
    3580     function baseForOwn(object, iteratee) {
    3581       return baseFor(object, iteratee, keys);
    3582     }
    3583 
    3584     /**
    3585      * The base implementation of `_.forOwnRight` without support for callback
    3586      * shorthands and `this` binding.
    3587      *
    3588      * @private
    3589      * @param {Object} object The object to iterate over.
    3590      * @param {Function} iteratee The function invoked per iteration.
    3591      * @returns {Object} Returns `object`.
    3592      */
    3593     function baseForOwnRight(object, iteratee) {
    3594       return baseForRight(object, iteratee, keys);
    3595     }
    3596 
    3597     /**
    3598      * The base implementation of `_.functions` which creates an array of
    3599      * `object` function property names filtered from those provided.
    3600      *
    3601      * @private
    3602      * @param {Object} object The object to inspect.
    3603      * @param {Array} props The property names to filter.
    3604      * @returns {Array} Returns the new array of filtered property names.
    3605      */
    3606     function baseFunctions(object, props) {
    3607       var index = -1,
    3608           length = props.length,
    3609           resIndex = -1,
    3610           result = [];
    3611 
    3612       while (++index < length) {
    3613         var key = props[index];
    3614         if (isFunction(object[key])) {
    3615           result[++resIndex] = key;
    3616         }
    3617       }
    3618       return result;
    3619     }
    3620 
    3621     /**
    3622      * The base implementation of `get` without support for string paths
    3623      * and default values.
    3624      *
    3625      * @private
    3626      * @param {Object} object The object to query.
    3627      * @param {Array} path The path of the property to get.
    3628      * @param {string} [pathKey] The key representation of path.
    3629      * @returns {*} Returns the resolved value.
    3630      */
    3631     function baseGet(object, path, pathKey) {
    3632       if (object == null) {
    3633         return;
    3634       }
    3635       if (pathKey !== undefined && pathKey in toObject(object)) {
    3636         path = [pathKey];
    3637       }
    3638       var index = -1,
    3639           length = path.length;
    3640 
    3641       while (object != null && ++index < length) {
    3642         var result = object = object[path[index]];
    3643       }
    3644       return result;
    3645     }
    3646 
    3647     /**
    3648      * The base implementation of `_.isEqual` without support for `this` binding
    3649      * `customizer` functions.
    3650      *
    3651      * @private
    3652      * @param {*} value The value to compare.
    3653      * @param {*} other The other value to compare.
    3654      * @param {Function} [customizer] The function to customize comparing values.
    3655      * @param {boolean} [isLoose] Specify performing partial comparisons.
    3656      * @param {Array} [stackA] Tracks traversed `value` objects.
    3657      * @param {Array} [stackB] Tracks traversed `other` objects.
    3658      * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
    3659      */
    3660     function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
    3661       // Exit early for identical values.
    3662       if (value === other) {
    3663         // Treat `+0` vs. `-0` as not equal.
    3664         return value !== 0 || (1 / value == 1 / other);
    3665       }
    3666       var valType = typeof value,
    3667           othType = typeof other;
    3668 
    3669       // Exit early for unlike primitive values.
    3670       if ((valType != 'function' && valType != 'object' && othType != 'function' && othType != 'object') ||
    3671           value == null || other == null) {
    3672         // Return `false` unless both values are `NaN`.
    3673         return value !== value && other !== other;
    3674       }
    3675       return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
    3676     }
    3677 
    3678     /**
    3679      * A specialized version of `baseIsEqual` for arrays and objects which performs
    3680      * deep comparisons and tracks traversed objects enabling objects with circular
    3681      * references to be compared.
    3682      *
    3683      * @private
    3684      * @param {Object} object The object to compare.
    3685      * @param {Object} other The other object to compare.
    3686      * @param {Function} equalFunc The function to determine equivalents of values.
    3687      * @param {Function} [customizer] The function to customize comparing objects.
    3688      * @param {boolean} [isLoose] Specify performing partial comparisons.
    3689      * @param {Array} [stackA=[]] Tracks traversed `value` objects.
    3690      * @param {Array} [stackB=[]] Tracks traversed `other` objects.
    3691      * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    3692      */
    3693     function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
    3694       var objIsArr = isArray(object),
    3695           othIsArr = isArray(other),
    3696           objTag = arrayTag,
    3697           othTag = arrayTag;
    3698 
    3699       if (!objIsArr) {
    3700         objTag = objToString.call(object);
    3701         if (objTag == argsTag) {
    3702           objTag = objectTag;
    3703         } else if (objTag != objectTag) {
    3704           objIsArr = isTypedArray(object);
    3705         }
    3706       }
    3707       if (!othIsArr) {
    3708         othTag = objToString.call(other);
    3709         if (othTag == argsTag) {
    3710           othTag = objectTag;
    3711         } else if (othTag != objectTag) {
    3712           othIsArr = isTypedArray(other);
    3713         }
    3714       }
    3715       var objIsObj = objTag == objectTag,
    3716           othIsObj = othTag == objectTag,
    3717           isSameTag = objTag == othTag;
    3718 
    3719       if (isSameTag && !(objIsArr || objIsObj)) {
    3720         return equalByTag(object, other, objTag);
    3721       }
    3722       if (!isLoose) {
    3723         var valWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
    3724             othWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
    3725 
    3726         if (valWrapped || othWrapped) {
    3727           return equalFunc(valWrapped ? object.value() : object, othWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
    3728         }
    3729       }
    3730       if (!isSameTag) {
    3731         return false;
    3732       }
    3733       // Assume cyclic values are equal.
    3734       // For more information on detecting circular references see https://es5.github.io/#JO.
    3735       stackA || (stackA = []);
    3736       stackB || (stackB = []);
    3737 
    3738       var length = stackA.length;
    3739       while (length--) {
    3740         if (stackA[length] == object) {
    3741           return stackB[length] == other;
    3742         }
    3743       }
    3744       // Add `object` and `other` to the stack of traversed objects.
    3745       stackA.push(object);
    3746       stackB.push(other);
    3747 
    3748       var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);
    3749 
    3750       stackA.pop();
    3751       stackB.pop();
    3752 
    3753       return result;
    3754     }
    3755 
    3756     /**
    3757      * The base implementation of `_.isMatch` without support for callback
    3758      * shorthands and `this` binding.
    3759      *
    3760      * @private
    3761      * @param {Object} object The object to inspect.
    3762      * @param {Array} props The source property names to match.
    3763      * @param {Array} values The source values to match.
    3764      * @param {Array} strictCompareFlags Strict comparison flags for source values.
    3765      * @param {Function} [customizer] The function to customize comparing objects.
    3766      * @returns {boolean} Returns `true` if `object` is a match, else `false`.
    3767      */
    3768     function baseIsMatch(object, props, values, strictCompareFlags, customizer) {
    3769       var index = -1,
    3770           length = props.length,
    3771           noCustomizer = !customizer;
    3772 
    3773       while (++index < length) {
    3774         if ((noCustomizer && strictCompareFlags[index])
    3775               ? values[index] !== object[props[index]]
    3776               : !(props[index] in object)
    3777             ) {
    3778           return false;
    3779         }
    3780       }
    3781       index = -1;
    3782       while (++index < length) {
    3783         var key = props[index],
    3784             objValue = object[key],
    3785             srcValue = values[index];
    3786 
    3787         if (noCustomizer && strictCompareFlags[index]) {
    3788           var result = objValue !== undefined || (key in object);
    3789         } else {
    3790           result = customizer ? customizer(objValue, srcValue, key) : undefined;
    3791           if (result === undefined) {
    3792             result = baseIsEqual(srcValue, objValue, customizer, true);
    3793           }
    3794         }
    3795         if (!result) {
    3796           return false;
    3797         }
    3798       }
    3799       return true;
    3800     }
    3801 
    3802     /**
    3803      * The base implementation of `_.map` without support for callback shorthands
    3804      * and `this` binding.
    3805      *
    3806      * @private
    3807      * @param {Array|Object|string} collection The collection to iterate over.
    3808      * @param {Function} iteratee The function invoked per iteration.
    3809      * @returns {Array} Returns the new mapped array.
    3810      */
    3811     function baseMap(collection, iteratee) {
    3812       var index = -1,
    3813           length = getLength(collection),
    3814           result = isLength(length) ? Array(length) : [];
    3815 
    3816       baseEach(collection, function(value, key, collection) {
    3817         result[++index] = iteratee(value, key, collection);
    3818       });
    3819       return result;
    3820     }
    3821 
    3822     /**
    3823      * The base implementation of `_.matches` which does not clone `source`.
    3824      *
    3825      * @private
    3826      * @param {Object} source The object of property values to match.
    3827      * @returns {Function} Returns the new function.
    3828      */
    3829     function baseMatches(source) {
    3830       var props = keys(source),
    3831           length = props.length;
    3832 
    3833       if (!length) {
    3834         return constant(true);
    3835       }
    3836       if (length == 1) {
    3837         var key = props[0],
    3838             value = source[key];
    3839 
    3840         if (isStrictComparable(value)) {
    3841           return function(object) {
    3842             if (object == null) {
    3843               return false;
    3844             }
    3845             return object[key] === value && (value !== undefined || (key in toObject(object)));
    3846           };
    3847         }
    3848       }
    3849       var values = Array(length),
    3850           strictCompareFlags = Array(length);
    3851 
    3852       while (length--) {
    3853         value = source[props[length]];
    3854         values[length] = value;
    3855         strictCompareFlags[length] = isStrictComparable(value);
    3856       }
    3857       return function(object) {
    3858         return object != null && baseIsMatch(toObject(object), props, values, strictCompareFlags);
    3859       };
    3860     }
    3861 
    3862     /**
    3863      * The base implementation of `_.matchesProperty` which does not which does
    3864      * not clone `value`.
    3865      *
    3866      * @private
    3867      * @param {string} path The path of the property to get.
    3868      * @param {*} value The value to compare.
    3869      * @returns {Function} Returns the new function.
    3870      */
    3871     function baseMatchesProperty(path, value) {
    3872       var isArr = isArray(path),
    3873           isCommon = isKey(path) && isStrictComparable(value),
    3874           pathKey = (path + '');
    3875 
    3876       path = toPath(path);
    3877       return function(object) {
    3878         if (object == null) {
    3879           return false;
    3880         }
    3881         var key = pathKey;
    3882         object = toObject(object);
    3883         if ((isArr || !isCommon) && !(key in object)) {
    3884           object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
    3885           if (object == null) {
    3886             return false;
    3887           }
    3888           key = last(path);
    3889           object = toObject(object);
    3890         }
    3891         return object[key] === value
    3892           ? (value !== undefined || (key in object))
    3893           : baseIsEqual(value, object[key], null, true);
    3894       };
    3895     }
    3896 
    3897     /**
    3898      * The base implementation of `_.merge` without support for argument juggling,
    3899      * multiple sources, and `this` binding `customizer` functions.
    3900      *
    3901      * @private
    3902      * @param {Object} object The destination object.
    3903      * @param {Object} source The source object.
    3904      * @param {Function} [customizer] The function to customize merging properties.
    3905      * @param {Array} [stackA=[]] Tracks traversed source objects.
    3906      * @param {Array} [stackB=[]] Associates values with source counterparts.
    3907      * @returns {Object} Returns `object`.
    3908      */
    3909     function baseMerge(object, source, customizer, stackA, stackB) {
    3910       if (!isObject(object)) {
    3911         return object;
    3912       }
    3913       var isSrcArr = isLength(source.length) && (isArray(source) || isTypedArray(source));
    3914       if (!isSrcArr) {
    3915         var props = keys(source);
    3916         push.apply(props, getSymbols(source));
    3917       }
    3918       arrayEach(props || source, function(srcValue, key) {
    3919         if (props) {
    3920           key = srcValue;
    3921           srcValue = source[key];
    3922         }
    3923         if (isObjectLike(srcValue)) {
    3924           stackA || (stackA = []);
    3925           stackB || (stackB = []);
    3926           baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB);
    3927         }
    3928         else {
    3929           var value = object[key],
    3930               result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
    3931               isCommon = result === undefined;
    3932 
    3933           if (isCommon) {
    3934             result = srcValue;
    3935           }
    3936           if ((isSrcArr || result !== undefined) &&
    3937               (isCommon || (result === result ? (result !== value) : (value === value)))) {
    3938             object[key] = result;
    3939           }
    3940         }
    3941       });
    3942       return object;
    3943     }
    3944 
    3945     /**
    3946      * A specialized version of `baseMerge` for arrays and objects which performs
    3947      * deep merges and tracks traversed objects enabling objects with circular
    3948      * references to be merged.
    3949      *
    3950      * @private
    3951      * @param {Object} object The destination object.
    3952      * @param {Object} source The source object.
    3953      * @param {string} key The key of the value to merge.
    3954      * @param {Function} mergeFunc The function to merge values.
    3955      * @param {Function} [customizer] The function to customize merging properties.
    3956      * @param {Array} [stackA=[]] Tracks traversed source objects.
    3957      * @param {Array} [stackB=[]] Associates values with source counterparts.
    3958      * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    3959      */
    3960     function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) {
    3961       var length = stackA.length,
    3962           srcValue = source[key];
    3963 
    3964       while (length--) {
    3965         if (stackA[length] == srcValue) {
    3966           object[key] = stackB[length];
    3967           return;
    3968         }
    3969       }
    3970       var value = object[key],
    3971           result = customizer ? customizer(value, srcValue, key, object, source) : undefined,
    3972           isCommon = result === undefined;
    3973 
    3974       if (isCommon) {
    3975         result = srcValue;
    3976         if (isLength(srcValue.length) && (isArray(srcValue) || isTypedArray(srcValue))) {
    3977           result = isArray(value)
    3978             ? value
    3979             : (getLength(value) ? arrayCopy(value) : []);
    3980         }
    3981         else if (isPlainObject(srcValue) || isArguments(srcValue)) {
    3982           result = isArguments(value)
    3983             ? toPlainObject(value)
    3984             : (isPlainObject(value) ? value : {});
    3985         }
    3986         else {
    3987           isCommon = false;
    3988         }
    3989       }
    3990       // Add the source value to the stack of traversed objects and associate
    3991       // it with its merged value.
    3992       stackA.push(srcValue);
    3993       stackB.push(result);
    3994 
    3995       if (isCommon) {
    3996         // Recursively merge objects and arrays (susceptible to call stack limits).
    3997         object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB);
    3998       } else if (result === result ? (result !== value) : (value === value)) {
    3999         object[key] = result;
    4000       }
    4001     }
    4002 
    4003     /**
    4004      * The base implementation of `_.property` without support for deep paths.
    4005      *
    4006      * @private
    4007      * @param {string} key The key of the property to get.
    4008      * @returns {Function} Returns the new function.
    4009      */
    4010     function baseProperty(key) {
    4011       return function(object) {
    4012         return object == null ? undefined : object[key];
    4013       };
    4014     }
    4015 
    4016     /**
    4017      * A specialized version of `baseProperty` which supports deep paths.
    4018      *
    4019      * @private
    4020      * @param {Array|string} path The path of the property to get.
    4021      * @returns {Function} Returns the new function.
    4022      */
    4023     function basePropertyDeep(path) {
    4024       var pathKey = (path + '');
    4025       path = toPath(path);
    4026       return function(object) {
    4027         return baseGet(object, path, pathKey);
    4028       };
    4029     }
    4030 
    4031     /**
    4032      * The base implementation of `_.pullAt` without support for individual
    4033      * index arguments and capturing the removed elements.
    4034      *
    4035      * @private
    4036      * @param {Array} array The array to modify.
    4037      * @param {number[]} indexes The indexes of elements to remove.
    4038      * @returns {Array} Returns `array`.
    4039      */
    4040     function basePullAt(array, indexes) {
    4041       var length = indexes.length;
    4042       while (length--) {
    4043         var index = parseFloat(indexes[length]);
    4044         if (index != previous && isIndex(index)) {
    4045           var previous = index;
    4046           splice.call(array, index, 1);
    4047         }
    4048       }
    4049       return array;
    4050     }
    4051 
    4052     /**
    4053      * The base implementation of `_.random` without support for argument juggling
    4054      * and returning floating-point numbers.
    4055      *
    4056      * @private
    4057      * @param {number} min The minimum possible value.
    4058      * @param {number} max The maximum possible value.
    4059      * @returns {number} Returns the random number.
    4060      */
    4061     function baseRandom(min, max) {
    4062       return min + floor(nativeRandom() * (max - min + 1));
    4063     }
    4064 
    4065     /**
    4066      * The base implementation of `_.reduce` and `_.reduceRight` without support
    4067      * for callback shorthands and `this` binding, which iterates over `collection`
    4068      * using the provided `eachFunc`.
    4069      *
    4070      * @private
    4071      * @param {Array|Object|string} collection The collection to iterate over.
    4072      * @param {Function} iteratee The function invoked per iteration.
    4073      * @param {*} accumulator The initial value.
    4074      * @param {boolean} initFromCollection Specify using the first or last element
    4075      *  of `collection` as the initial value.
    4076      * @param {Function} eachFunc The function to iterate over `collection`.
    4077      * @returns {*} Returns the accumulated value.
    4078      */
    4079     function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) {
    4080       eachFunc(collection, function(value, index, collection) {
    4081         accumulator = initFromCollection
    4082           ? (initFromCollection = false, value)
    4083           : iteratee(accumulator, value, index, collection);
    4084       });
    4085       return accumulator;
    4086     }
    4087 
    4088     /**
    4089      * The base implementation of `setData` without support for hot loop detection.
    4090      *
    4091      * @private
    4092      * @param {Function} func The function to associate metadata with.
    4093      * @param {*} data The metadata.
    4094      * @returns {Function} Returns `func`.
    4095      */
    4096     var baseSetData = !metaMap ? identity : function(func, data) {
    4097       metaMap.set(func, data);
    4098       return func;
    4099     };
    4100 
    4101     /**
    4102      * The base implementation of `_.slice` without an iteratee call guard.
    4103      *
    4104      * @private
    4105      * @param {Array} array The array to slice.
    4106      * @param {number} [start=0] The start position.
    4107      * @param {number} [end=array.length] The end position.
    4108      * @returns {Array} Returns the slice of `array`.
    4109      */
    4110     function baseSlice(array, start, end) {
    4111       var index = -1,
    4112           length = array.length;
    4113 
    4114       start = start == null ? 0 : (+start || 0);
    4115       if (start < 0) {
    4116         start = -start > length ? 0 : (length + start);
    4117       }
    4118       end = (end === undefined || end > length) ? length : (+end || 0);
    4119       if (end < 0) {
    4120         end += length;
    4121       }
    4122       length = start > end ? 0 : ((end - start) >>> 0);
    4123       start >>>= 0;
    4124 
    4125       var result = Array(length);
    4126       while (++index < length) {
    4127         result[index] = array[index + start];
    4128       }
    4129       return result;
    4130     }
    4131 
    4132     /**
    4133      * The base implementation of `_.some` without support for callback shorthands
    4134      * and `this` binding.
    4135      *
    4136      * @private
    4137      * @param {Array|Object|string} collection The collection to iterate over.
    4138      * @param {Function} predicate The function invoked per iteration.
    4139      * @returns {boolean} Returns `true` if any element passes the predicate check,
    4140      *  else `false`.
    4141      */
    4142     function baseSome(collection, predicate) {
    4143       var result;
    4144 
    4145       baseEach(collection, function(value, index, collection) {
    4146         result = predicate(value, index, collection);
    4147         return !result;
    4148       });
    4149       return !!result;
    4150     }
    4151 
    4152     /**
    4153      * The base implementation of `_.sortBy` which uses `comparer` to define
    4154      * the sort order of `array` and replaces criteria objects with their
    4155      * corresponding values.
    4156      *
    4157      * @private
    4158      * @param {Array} array The array to sort.
    4159      * @param {Function} comparer The function to define sort order.
    4160      * @returns {Array} Returns `array`.
    4161      */
    4162     function baseSortBy(array, comparer) {
    4163       var length = array.length;
    4164 
    4165       array.sort(comparer);
    4166       while (length--) {
    4167         array[length] = array[length].value;
    4168       }
    4169       return array;
    4170     }
    4171 
    4172     /**
    4173      * The base implementation of `_.sortByOrder` without param guards.
    4174      *
    4175      * @private
    4176      * @param {Array|Object|string} collection The collection to iterate over.
    4177      * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
    4178      * @param {boolean[]} orders The sort orders of `iteratees`.
    4179      * @returns {Array} Returns the new sorted array.
    4180      */
    4181     function baseSortByOrder(collection, iteratees, orders) {
    4182       var callback = getCallback(),
    4183           index = -1;
    4184 
    4185       iteratees = arrayMap(iteratees, function(iteratee) { return callback(iteratee); });
    4186 
    4187       var result = baseMap(collection, function(value) {
    4188         var criteria = arrayMap(iteratees, function(iteratee) { return iteratee(value); });
    4189         return { 'criteria': criteria, 'index': ++index, 'value': value };
    4190       });
    4191 
    4192       return baseSortBy(result, function(object, other) {
    4193         return compareMultiple(object, other, orders);
    4194       });
    4195     }
    4196 
    4197     /**
    4198      * The base implementation of `_.sum` without support for callback shorthands
    4199      * and `this` binding.
    4200      *
    4201      * @private
    4202      * @param {Array|Object|string} collection The collection to iterate over.
    4203      * @param {Function} iteratee The function invoked per iteration.
    4204      * @returns {number} Returns the sum.
    4205      */
    4206     function baseSum(collection, iteratee) {
    4207       var result = 0;
    4208       baseEach(collection, function(value, index, collection) {
    4209         result += +iteratee(value, index, collection) || 0;
    4210       });
    4211       return result;
    4212     }
    4213 
    4214     /**
    4215      * The base implementation of `_.uniq` without support for callback shorthands
    4216      * and `this` binding.
    4217      *
    4218      * @private
    4219      * @param {Array} array The array to inspect.
    4220      * @param {Function} [iteratee] The function invoked per iteration.
    4221      * @returns {Array} Returns the new duplicate-value-free array.
    4222      */
    4223     function baseUniq(array, iteratee) {
    4224       var index = -1,
    4225           indexOf = getIndexOf(),
    4226           length = array.length,
    4227           isCommon = indexOf == baseIndexOf,
    4228           isLarge = isCommon && length >= 200,
    4229           seen = isLarge ? createCache() : null,
    4230           result = [];
    4231 
    4232       if (seen) {
    4233         indexOf = cacheIndexOf;
    4234         isCommon = false;
    4235       } else {
    4236         isLarge = false;
    4237         seen = iteratee ? [] : result;
    4238       }
    4239       outer:
    4240       while (++index < length) {
    4241         var value = array[index],
    4242             computed = iteratee ? iteratee(value, index, array) : value;
    4243 
    4244         if (isCommon && value === value) {
    4245           var seenIndex = seen.length;
    4246           while (seenIndex--) {
    4247             if (seen[seenIndex] === computed) {
    4248               continue outer;
    4249             }
    4250           }
    4251           if (iteratee) {
    4252             seen.push(computed);
    4253           }
    4254           result.push(value);
    4255         }
    4256         else if (indexOf(seen, computed, 0) < 0) {
    4257           if (iteratee || isLarge) {
    4258             seen.push(computed);
    4259           }
    4260           result.push(value);
    4261         }
    4262       }
    4263       return result;
    4264     }
    4265 
    4266     /**
    4267      * The base implementation of `_.values` and `_.valuesIn` which creates an
    4268      * array of `object` property values corresponding to the property names
    4269      * of `props`.
    4270      *
    4271      * @private
    4272      * @param {Object} object The object to query.
    4273      * @param {Array} props The property names to get values for.
    4274      * @returns {Object} Returns the array of property values.
    4275      */
    4276     function baseValues(object, props) {
    4277       var index = -1,
    4278           length = props.length,
    4279           result = Array(length);
    4280 
    4281       while (++index < length) {
    4282         result[index] = object[props[index]];
    4283       }
    4284       return result;
    4285     }
    4286 
    4287     /**
    4288      * The base implementation of `_.dropRightWhile`, `_.dropWhile`, `_.takeRightWhile`,
    4289      * and `_.takeWhile` without support for callback shorthands and `this` binding.
    4290      *
    4291      * @private
    4292      * @param {Array} array The array to query.
    4293      * @param {Function} predicate The function invoked per iteration.
    4294      * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
    4295      * @param {boolean} [fromRight] Specify iterating from right to left.
    4296      * @returns {Array} Returns the slice of `array`.
    4297      */
    4298     function baseWhile(array, predicate, isDrop, fromRight) {
    4299       var length = array.length,
    4300           index = fromRight ? length : -1;
    4301 
    4302       while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {}
    4303       return isDrop
    4304         ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
    4305         : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
    4306     }
    4307 
    4308     /**
    4309      * The base implementation of `wrapperValue` which returns the result of
    4310      * performing a sequence of actions on the unwrapped `value`, where each
    4311      * successive action is supplied the return value of the previous.
    4312      *
    4313      * @private
    4314      * @param {*} value The unwrapped value.
    4315      * @param {Array} actions Actions to peform to resolve the unwrapped value.
    4316      * @returns {*} Returns the resolved value.
    4317      */
    4318     function baseWrapperValue(value, actions) {
    4319       var result = value;
    4320       if (result instanceof LazyWrapper) {
    4321         result = result.value();
    4322       }
    4323       var index = -1,
    4324           length = actions.length;
    4325 
    4326       while (++index < length) {
    4327         var args = [result],
    4328             action = actions[index];
    4329 
    4330         push.apply(args, action.args);
    4331         result = action.func.apply(action.thisArg, args);
    4332       }
    4333       return result;
    4334     }
    4335 
    4336     /**
    4337      * Performs a binary search of `array` to determine the index at which `value`
    4338      * should be inserted into `array` in order to maintain its sort order.
    4339      *
    4340      * @private
    4341      * @param {Array} array The sorted array to inspect.
    4342      * @param {*} value The value to evaluate.
    4343      * @param {boolean} [retHighest] Specify returning the highest qualified index.
    4344      * @returns {number} Returns the index at which `value` should be inserted
    4345      *  into `array`.
    4346      */
    4347     function binaryIndex(array, value, retHighest) {
    4348       var low = 0,
    4349           high = array ? array.length : low;
    4350 
    4351       if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
    4352         while (low < high) {
    4353           var mid = (low + high) >>> 1,
    4354               computed = array[mid];
    4355 
    4356           if (retHighest ? (computed <= value) : (computed < value)) {
    4357             low = mid + 1;
    4358           } else {
    4359             high = mid;
    4360           }
    4361         }
    4362         return high;
    4363       }
    4364       return binaryIndexBy(array, value, identity, retHighest);
    4365     }
    4366 
    4367     /**
    4368      * This function is like `binaryIndex` except that it invokes `iteratee` for
    4369      * `value` and each element of `array` to compute their sort ranking. The
    4370      * iteratee is invoked with one argument; (value).
    4371      *
    4372      * @private
    4373      * @param {Array} array The sorted array to inspect.
    4374      * @param {*} value The value to evaluate.
    4375      * @param {Function} iteratee The function invoked per iteration.
    4376      * @param {boolean} [retHighest] Specify returning the highest qualified index.
    4377      * @returns {number} Returns the index at which `value` should be inserted
    4378      *  into `array`.
    4379      */
    4380     function binaryIndexBy(array, value, iteratee, retHighest) {
    4381       value = iteratee(value);
    4382 
    4383       var low = 0,
    4384           high = array ? array.length : 0,
    4385           valIsNaN = value !== value,
    4386           valIsUndef = value === undefined;
    4387 
    4388       while (low < high) {
    4389         var mid = floor((low + high) / 2),
    4390             computed = iteratee(array[mid]),
    4391             isReflexive = computed === computed;
    4392 
    4393         if (valIsNaN) {
    4394           var setLow = isReflexive || retHighest;
    4395         } else if (valIsUndef) {
    4396           setLow = isReflexive && (retHighest || computed !== undefined);
    4397         } else {
    4398           setLow = retHighest ? (computed <= value) : (computed < value);
    4399         }
    4400         if (setLow) {
    4401           low = mid + 1;
    4402         } else {
    4403           high = mid;
    4404         }
    4405       }
    4406       return nativeMin(high, MAX_ARRAY_INDEX);
    4407     }
    4408 
    4409     /**
    4410      * A specialized version of `baseCallback` which only supports `this` binding
    4411      * and specifying the number of arguments to provide to `func`.
    4412      *
    4413      * @private
    4414      * @param {Function} func The function to bind.
    4415      * @param {*} thisArg The `this` binding of `func`.
    4416      * @param {number} [argCount] The number of arguments to provide to `func`.
    4417      * @returns {Function} Returns the callback.
    4418      */
    4419     function bindCallback(func, thisArg, argCount) {
    4420       if (typeof func != 'function') {
    4421         return identity;
    4422       }
    4423       if (thisArg === undefined) {
    4424         return func;
    4425       }
    4426       switch (argCount) {
    4427         case 1: return function(value) {
    4428           return func.call(thisArg, value);
    4429         };
    4430         case 3: return function(value, index, collection) {
    4431           return func.call(thisArg, value, index, collection);
    4432         };
    4433         case 4: return function(accumulator, value, index, collection) {
    4434           return func.call(thisArg, accumulator, value, index, collection);
    4435         };
    4436         case 5: return function(value, other, key, object, source) {
    4437           return func.call(thisArg, value, other, key, object, source);
    4438         };
    4439       }
    4440       return function() {
    4441         return func.apply(thisArg, arguments);
    4442       };
    4443     }
    4444 
    4445     /**
    4446      * Creates a clone of the given array buffer.
    4447      *
    4448      * @private
    4449      * @param {ArrayBuffer} buffer The array buffer to clone.
    4450      * @returns {ArrayBuffer} Returns the cloned array buffer.
    4451      */
    4452     function bufferClone(buffer) {
    4453       return bufferSlice.call(buffer, 0);
    4454     }
    4455     if (!bufferSlice) {
    4456       // PhantomJS has `ArrayBuffer` and `Uint8Array` but not `Float64Array`.
    4457       bufferClone = !(ArrayBuffer && Uint8Array) ? constant(null) : function(buffer) {
    4458         var byteLength = buffer.byteLength,
    4459             floatLength = Float64Array ? floor(byteLength / FLOAT64_BYTES_PER_ELEMENT) : 0,
    4460             offset = floatLength * FLOAT64_BYTES_PER_ELEMENT,
    4461             result = new ArrayBuffer(byteLength);
    4462 
    4463         if (floatLength) {
    4464           var view = new Float64Array(result, 0, floatLength);
    4465           view.set(new Float64Array(buffer, 0, floatLength));
    4466         }
    4467         if (byteLength != offset) {
    4468           view = new Uint8Array(result, offset);
    4469           view.set(new Uint8Array(buffer, offset));
    4470         }
    4471         return result;
    4472       };
    4473     }
    4474 
    4475     /**
    4476      * Creates an array that is the composition of partially applied arguments,
    4477      * placeholders, and provided arguments into a single array of arguments.
    4478      *
    4479      * @private
    4480      * @param {Array|Object} args The provided arguments.
    4481      * @param {Array} partials The arguments to prepend to those provided.
    4482      * @param {Array} holders The `partials` placeholder indexes.
    4483      * @returns {Array} Returns the new array of composed arguments.
    4484      */
    4485     function composeArgs(args, partials, holders) {
    4486       var holdersLength = holders.length,
    4487           argsIndex = -1,
    4488           argsLength = nativeMax(args.length - holdersLength, 0),
    4489           leftIndex = -1,
    4490           leftLength = partials.length,
    4491           result = Array(argsLength + leftLength);
    4492 
    4493       while (++leftIndex < leftLength) {
    4494         result[leftIndex] = partials[leftIndex];
    4495       }
    4496       while (++argsIndex < holdersLength) {
    4497         result[holders[argsIndex]] = args[argsIndex];
    4498       }
    4499       while (argsLength--) {
    4500         result[leftIndex++] = args[argsIndex++];
    4501       }
    4502       return result;
    4503     }
    4504 
    4505     /**
    4506      * This function is like `composeArgs` except that the arguments composition
    4507      * is tailored for `_.partialRight`.
    4508      *
    4509      * @private
    4510      * @param {Array|Object} args The provided arguments.
    4511      * @param {Array} partials The arguments to append to those provided.
    4512      * @param {Array} holders The `partials` placeholder indexes.
    4513      * @returns {Array} Returns the new array of composed arguments.
    4514      */
    4515     function composeArgsRight(args, partials, holders) {
    4516       var holdersIndex = -1,
    4517           holdersLength = holders.length,
    4518           argsIndex = -1,
    4519           argsLength = nativeMax(args.length - holdersLength, 0),
    4520           rightIndex = -1,
    4521           rightLength = partials.length,
    4522           result = Array(argsLength + rightLength);
    4523 
    4524       while (++argsIndex < argsLength) {
    4525         result[argsIndex] = args[argsIndex];
    4526       }
    4527       var pad = argsIndex;
    4528       while (++rightIndex < rightLength) {
    4529         result[pad + rightIndex] = partials[rightIndex];
    4530       }
    4531       while (++holdersIndex < holdersLength) {
    4532         result[pad + holders[holdersIndex]] = args[argsIndex++];
    4533       }
    4534       return result;
    4535     }
    4536 
    4537     /**
    4538      * Creates a function that aggregates a collection, creating an accumulator
    4539      * object composed from the results of running each element in the collection
    4540      * through an iteratee.
    4541      *
    4542      * **Note:** This function is used to create `_.countBy`, `_.groupBy`, `_.indexBy`,
    4543      * and `_.partition`.
    4544      *
    4545      * @private
    4546      * @param {Function} setter The function to set keys and values of the accumulator object.
    4547      * @param {Function} [initializer] The function to initialize the accumulator object.
    4548      * @returns {Function} Returns the new aggregator function.
    4549      */
    4550     function createAggregator(setter, initializer) {
    4551       return function(collection, iteratee, thisArg) {
    4552         var result = initializer ? initializer() : {};
    4553         iteratee = getCallback(iteratee, thisArg, 3);
    4554 
    4555         if (isArray(collection)) {
    4556           var index = -1,
    4557               length = collection.length;
    4558 
    4559           while (++index < length) {
    4560             var value = collection[index];
    4561             setter(result, value, iteratee(value, index, collection), collection);
    4562           }
    4563         } else {
    4564           baseEach(collection, function(value, key, collection) {
    4565             setter(result, value, iteratee(value, key, collection), collection);
    4566           });
    4567         }
    4568         return result;
    4569       };
    4570     }
    4571 
    4572     /**
    4573      * Creates a function that assigns properties of source object(s) to a given
    4574      * destination object.
    4575      *
    4576      * **Note:** This function is used to create `_.assign`, `_.defaults`, and `_.merge`.
    4577      *
    4578      * @private
    4579      * @param {Function} assigner The function to assign values.
    4580      * @returns {Function} Returns the new assigner function.
    4581      */
    4582     function createAssigner(assigner) {
    4583       return restParam(function(object, sources) {
    4584         var index = -1,
    4585             length = object == null ? 0 : sources.length,
    4586             customizer = length > 2 && sources[length - 2],
    4587             guard = length > 2 && sources[2],
    4588             thisArg = length > 1 && sources[length - 1];
    4589 
    4590         if (typeof customizer == 'function') {
    4591           customizer = bindCallback(customizer, thisArg, 5);
    4592           length -= 2;
    4593         } else {
    4594           customizer = typeof thisArg == 'function' ? thisArg : null;
    4595           length -= (customizer ? 1 : 0);
    4596         }
    4597         if (guard && isIterateeCall(sources[0], sources[1], guard)) {
    4598           customizer = length < 3 ? null : customizer;
    4599           length = 1;
    4600         }
    4601         while (++index < length) {
    4602           var source = sources[index];
    4603           if (source) {
    4604             assigner(object, source, customizer);
    4605           }
    4606         }
    4607         return object;
    4608       });
    4609     }
    4610 
    4611     /**
    4612      * Creates a `baseEach` or `baseEachRight` function.
    4613      *
    4614      * @private
    4615      * @param {Function} eachFunc The function to iterate over a collection.
    4616      * @param {boolean} [fromRight] Specify iterating from right to left.
    4617      * @returns {Function} Returns the new base function.
    4618      */
    4619     function createBaseEach(eachFunc, fromRight) {
    4620       return function(collection, iteratee) {
    4621         var length = collection ? getLength(collection) : 0;
    4622         if (!isLength(length)) {
    4623           return eachFunc(collection, iteratee);
    4624         }
    4625         var index = fromRight ? length : -1,
    4626             iterable = toObject(collection);
    4627 
    4628         while ((fromRight ? index-- : ++index < length)) {
    4629           if (iteratee(iterable[index], index, iterable) === false) {
    4630             break;
    4631           }
    4632         }
    4633         return collection;
    4634       };
    4635     }
    4636 
    4637     /**
    4638      * Creates a base function for `_.forIn` or `_.forInRight`.
    4639      *
    4640      * @private
    4641      * @param {boolean} [fromRight] Specify iterating from right to left.
    4642      * @returns {Function} Returns the new base function.
    4643      */
    4644     function createBaseFor(fromRight) {
    4645       return function(object, iteratee, keysFunc) {
    4646         var iterable = toObject(object),
    4647             props = keysFunc(object),
    4648             length = props.length,
    4649             index = fromRight ? length : -1;
    4650 
    4651         while ((fromRight ? index-- : ++index < length)) {
    4652           var key = props[index];
    4653           if (iteratee(iterable[key], key, iterable) === false) {
    4654             break;
    4655           }
    4656         }
    4657         return object;
    4658       };
    4659     }
    4660 
    4661     /**
    4662      * Creates a function that wraps `func` and invokes it with the `this`
    4663      * binding of `thisArg`.
    4664      *
    4665      * @private
    4666      * @param {Function} func The function to bind.
    4667      * @param {*} [thisArg] The `this` binding of `func`.
    4668      * @returns {Function} Returns the new bound function.
    4669      */
    4670     function createBindWrapper(func, thisArg) {
    4671       var Ctor = createCtorWrapper(func);
    4672 
    4673       function wrapper() {
    4674         var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
    4675         return fn.apply(thisArg, arguments);
    4676       }
    4677       return wrapper;
    4678     }
    4679 
    4680     /**
    4681      * Creates a `Set` cache object to optimize linear searches of large arrays.
    4682      *
    4683      * @private
    4684      * @param {Array} [values] The values to cache.
    4685      * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`.
    4686      */
    4687     var createCache = !(nativeCreate && Set) ? constant(null) : function(values) {
    4688       return new SetCache(values);
    4689     };
    4690 
    4691     /**
    4692      * Creates a function that produces compound words out of the words in a
    4693      * given string.
    4694      *
    4695      * @private
    4696      * @param {Function} callback The function to combine each word.
    4697      * @returns {Function} Returns the new compounder function.
    4698      */
    4699     function createCompounder(callback) {
    4700       return function(string) {
    4701         var index = -1,
    4702             array = words(deburr(string)),
    4703             length = array.length,
    4704             result = '';
    4705 
    4706         while (++index < length) {
    4707           result = callback(result, array[index], index);
    4708         }
    4709         return result;
    4710       };
    4711     }
    4712 
    4713     /**
    4714      * Creates a function that produces an instance of `Ctor` regardless of
    4715      * whether it was invoked as part of a `new` expression or by `call` or `apply`.
    4716      *
    4717      * @private
    4718      * @param {Function} Ctor The constructor to wrap.
    4719      * @returns {Function} Returns the new wrapped function.
    4720      */
    4721     function createCtorWrapper(Ctor) {
    4722       return function() {
    4723         var thisBinding = baseCreate(Ctor.prototype),
    4724             result = Ctor.apply(thisBinding, arguments);
    4725 
    4726         // Mimic the constructor's `return` behavior.
    4727         // See https://es5.github.io/#x13.2.2 for more details.
    4728         return isObject(result) ? result : thisBinding;
    4729       };
    4730     }
    4731 
    4732     /**
    4733      * Creates a `_.curry` or `_.curryRight` function.
    4734      *
    4735      * @private
    4736      * @param {boolean} flag The curry bit flag.
    4737      * @returns {Function} Returns the new curry function.
    4738      */
    4739     function createCurry(flag) {
    4740       function curryFunc(func, arity, guard) {
    4741         if (guard && isIterateeCall(func, arity, guard)) {
    4742           arity = null;
    4743         }
    4744         var result = createWrapper(func, flag, null, null, null, null, null, arity);
    4745         result.placeholder = curryFunc.placeholder;
    4746         return result;
    4747       }
    4748       return curryFunc;
    4749     }
    4750 
    4751     /**
    4752      * Creates a `_.max` or `_.min` function.
    4753      *
    4754      * @private
    4755      * @param {Function} arrayFunc The function to get the extremum value from an array.
    4756      * @param {boolean} [isMin] Specify returning the minimum, instead of the maximum,
    4757      *  extremum value.
    4758      * @returns {Function} Returns the new extremum function.
    4759      */
    4760     function createExtremum(arrayFunc, isMin) {
    4761       return function(collection, iteratee, thisArg) {
    4762         if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {
    4763           iteratee = null;
    4764         }
    4765         var func = getCallback(),
    4766             noIteratee = iteratee == null;
    4767 
    4768         if (!(func === baseCallback && noIteratee)) {
    4769           noIteratee = false;
    4770           iteratee = func(iteratee, thisArg, 3);
    4771         }
    4772         if (noIteratee) {
    4773           var isArr = isArray(collection);
    4774           if (!isArr && isString(collection)) {
    4775             iteratee = charAtCallback;
    4776           } else {
    4777             return arrayFunc(isArr ? collection : toIterable(collection));
    4778           }
    4779         }
    4780         return extremumBy(collection, iteratee, isMin);
    4781       };
    4782     }
    4783 
    4784     /**
    4785      * Creates a `_.find` or `_.findLast` function.
    4786      *
    4787      * @private
    4788      * @param {Function} eachFunc The function to iterate over a collection.
    4789      * @param {boolean} [fromRight] Specify iterating from right to left.
    4790      * @returns {Function} Returns the new find function.
    4791      */
    4792     function createFind(eachFunc, fromRight) {
    4793       return function(collection, predicate, thisArg) {
    4794         predicate = getCallback(predicate, thisArg, 3);
    4795         if (isArray(collection)) {
    4796           var index = baseFindIndex(collection, predicate, fromRight);
    4797           return index > -1 ? collection[index] : undefined;
    4798         }
    4799         return baseFind(collection, predicate, eachFunc);
    4800       }
    4801     }
    4802 
    4803     /**
    4804      * Creates a `_.findIndex` or `_.findLastIndex` function.
    4805      *
    4806      * @private
    4807      * @param {boolean} [fromRight] Specify iterating from right to left.
    4808      * @returns {Function} Returns the new find function.
    4809      */
    4810     function createFindIndex(fromRight) {
    4811       return function(array, predicate, thisArg) {
    4812         if (!(array && array.length)) {
    4813           return -1;
    4814         }
    4815         predicate = getCallback(predicate, thisArg, 3);
    4816         return baseFindIndex(array, predicate, fromRight);
    4817       };
    4818     }
    4819 
    4820     /**
    4821      * Creates a `_.findKey` or `_.findLastKey` function.
    4822      *
    4823      * @private
    4824      * @param {Function} objectFunc The function to iterate over an object.
    4825      * @returns {Function} Returns the new find function.
    4826      */
    4827     function createFindKey(objectFunc) {
    4828       return function(object, predicate, thisArg) {
    4829         predicate = getCallback(predicate, thisArg, 3);
    4830         return baseFind(object, predicate, objectFunc, true);
    4831       };
    4832     }
    4833 
    4834     /**
    4835      * Creates a `_.flow` or `_.flowRight` function.
    4836      *
    4837      * @private
    4838      * @param {boolean} [fromRight] Specify iterating from right to left.
    4839      * @returns {Function} Returns the new flow function.
    4840      */
    4841     function createFlow(fromRight) {
    4842       return function() {
    4843         var length = arguments.length;
    4844         if (!length) {
    4845           return function() { return arguments[0]; };
    4846         }
    4847         var wrapper,
    4848             index = fromRight ? length : -1,
    4849             leftIndex = 0,
    4850             funcs = Array(length);
    4851 
    4852         while ((fromRight ? index-- : ++index < length)) {
    4853           var func = funcs[leftIndex++] = arguments[index];
    4854           if (typeof func != 'function') {
    4855             throw new TypeError(FUNC_ERROR_TEXT);
    4856           }
    4857           var funcName = wrapper ? '' : getFuncName(func);
    4858           wrapper = funcName == 'wrapper' ? new LodashWrapper([]) : wrapper;
    4859         }
    4860         index = wrapper ? -1 : length;
    4861         while (++index < length) {
    4862           func = funcs[index];
    4863           funcName = getFuncName(func);
    4864 
    4865           var data = funcName == 'wrapper' ? getData(func) : null;
    4866           if (data && isLaziable(data[0])) {
    4867             wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
    4868           } else {
    4869             wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func);
    4870           }
    4871         }
    4872         return function() {
    4873           var args = arguments;
    4874           if (wrapper && args.length == 1 && isArray(args[0])) {
    4875             return wrapper.plant(args[0]).value();
    4876           }
    4877           var index = 0,
    4878               result = funcs[index].apply(this, args);
    4879 
    4880           while (++index < length) {
    4881             result = funcs[index].call(this, result);
    4882           }
    4883           return result;
    4884         };
    4885       };
    4886     }
    4887 
    4888     /**
    4889      * Creates a function for `_.forEach` or `_.forEachRight`.
    4890      *
    4891      * @private
    4892      * @param {Function} arrayFunc The function to iterate over an array.
    4893      * @param {Function} eachFunc The function to iterate over a collection.
    4894      * @returns {Function} Returns the new each function.
    4895      */
    4896     function createForEach(arrayFunc, eachFunc) {
    4897       return function(collection, iteratee, thisArg) {
    4898         return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))
    4899           ? arrayFunc(collection, iteratee)
    4900           : eachFunc(collection, bindCallback(iteratee, thisArg, 3));
    4901       };
    4902     }
    4903 
    4904     /**
    4905      * Creates a function for `_.forIn` or `_.forInRight`.
    4906      *
    4907      * @private
    4908      * @param {Function} objectFunc The function to iterate over an object.
    4909      * @returns {Function} Returns the new each function.
    4910      */
    4911     function createForIn(objectFunc) {
    4912       return function(object, iteratee, thisArg) {
    4913         if (typeof iteratee != 'function' || thisArg !== undefined) {
    4914           iteratee = bindCallback(iteratee, thisArg, 3);
    4915         }
    4916         return objectFunc(object, iteratee, keysIn);
    4917       };
    4918     }
    4919 
    4920     /**
    4921      * Creates a function for `_.forOwn` or `_.forOwnRight`.
    4922      *
    4923      * @private
    4924      * @param {Function} objectFunc The function to iterate over an object.
    4925      * @returns {Function} Returns the new each function.
    4926      */
    4927     function createForOwn(objectFunc) {
    4928       return function(object, iteratee, thisArg) {
    4929         if (typeof iteratee != 'function' || thisArg !== undefined) {
    4930           iteratee = bindCallback(iteratee, thisArg, 3);
    4931         }
    4932         return objectFunc(object, iteratee);
    4933       };
    4934     }
    4935 
    4936     /**
    4937      * Creates a function for `_.padLeft` or `_.padRight`.
    4938      *
    4939      * @private
    4940      * @param {boolean} [fromRight] Specify padding from the right.
    4941      * @returns {Function} Returns the new pad function.
    4942      */
    4943     function createPadDir(fromRight) {
    4944       return function(string, length, chars) {
    4945         string = baseToString(string);
    4946         return string && ((fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string));
    4947       };
    4948     }
    4949 
    4950     /**
    4951      * Creates a `_.partial` or `_.partialRight` function.
    4952      *
    4953      * @private
    4954      * @param {boolean} flag The partial bit flag.
    4955      * @returns {Function} Returns the new partial function.
    4956      */
    4957     function createPartial(flag) {
    4958       var partialFunc = restParam(function(func, partials) {
    4959         var holders = replaceHolders(partials, partialFunc.placeholder);
    4960         return createWrapper(func, flag, null, partials, holders);
    4961       });
    4962       return partialFunc;
    4963     }
    4964 
    4965     /**
    4966      * Creates a function for `_.reduce` or `_.reduceRight`.
    4967      *
    4968      * @private
    4969      * @param {Function} arrayFunc The function to iterate over an array.
    4970      * @param {Function} eachFunc The function to iterate over a collection.
    4971      * @returns {Function} Returns the new each function.
    4972      */
    4973     function createReduce(arrayFunc, eachFunc) {
    4974       return function(collection, iteratee, accumulator, thisArg) {
    4975         var initFromArray = arguments.length < 3;
    4976         return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))
    4977           ? arrayFunc(collection, iteratee, accumulator, initFromArray)
    4978           : baseReduce(collection, getCallback(iteratee, thisArg, 4), accumulator, initFromArray, eachFunc);
    4979       };
    4980     }
    4981 
    4982     /**
    4983      * Creates a function that wraps `func` and invokes it with optional `this`
    4984      * binding of, partial application, and currying.
    4985      *
    4986      * @private
    4987      * @param {Function|string} func The function or method name to reference.
    4988      * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details.
    4989      * @param {*} [thisArg] The `this` binding of `func`.
    4990      * @param {Array} [partials] The arguments to prepend to those provided to the new function.
    4991      * @param {Array} [holders] The `partials` placeholder indexes.
    4992      * @param {Array} [partialsRight] The arguments to append to those provided to the new function.
    4993      * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
    4994      * @param {Array} [argPos] The argument positions of the new function.
    4995      * @param {number} [ary] The arity cap of `func`.
    4996      * @param {number} [arity] The arity of `func`.
    4997      * @returns {Function} Returns the new wrapped function.
    4998      */
    4999     function createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
    5000       var isAry = bitmask & ARY_FLAG,
    5001           isBind = bitmask & BIND_FLAG,
    5002           isBindKey = bitmask & BIND_KEY_FLAG,
    5003           isCurry = bitmask & CURRY_FLAG,
    5004           isCurryBound = bitmask & CURRY_BOUND_FLAG,
    5005           isCurryRight = bitmask & CURRY_RIGHT_FLAG;
    5006 
    5007       var Ctor = !isBindKey && createCtorWrapper(func),
    5008           key = func;
    5009 
    5010       function wrapper() {
    5011         // Avoid `arguments` object use disqualifying optimizations by
    5012         // converting it to an array before providing it to other functions.
    5013         var length = arguments.length,
    5014             index = length,
    5015             args = Array(length);
    5016 
    5017         while (index--) {
    5018           args[index] = arguments[index];
    5019         }
    5020         if (partials) {
    5021           args = composeArgs(args, partials, holders);
    5022         }
    5023         if (partialsRight) {
    5024           args = composeArgsRight(args, partialsRight, holdersRight);
    5025         }
    5026         if (isCurry || isCurryRight) {
    5027           var placeholder = wrapper.placeholder,
    5028               argsHolders = replaceHolders(args, placeholder);
    5029 
    5030           length -= argsHolders.length;
    5031           if (length < arity) {
    5032             var newArgPos = argPos ? arrayCopy(argPos) : null,
    5033                 newArity = nativeMax(arity - length, 0),
    5034                 newsHolders = isCurry ? argsHolders : null,
    5035                 newHoldersRight = isCurry ? null : argsHolders,
    5036                 newPartials = isCurry ? args : null,
    5037                 newPartialsRight = isCurry ? null : args;
    5038 
    5039             bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);
    5040             bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);
    5041 
    5042             if (!isCurryBound) {
    5043               bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);
    5044             }
    5045             var newData = [func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, newArity],
    5046                 result = createHybridWrapper.apply(undefined, newData);
    5047 
    5048             if (isLaziable(func)) {
    5049               setData(result, newData);
    5050             }
    5051             result.placeholder = placeholder;
    5052             return result;
    5053           }
    5054         }
    5055         var thisBinding = isBind ? thisArg : this;
    5056         if (isBindKey) {
    5057           func = thisBinding[key];
    5058         }
    5059         if (argPos) {
    5060           args = reorder(args, argPos);
    5061         }
    5062         if (isAry && ary < args.length) {
    5063           args.length = ary;
    5064         }
    5065         var fn = (this && this !== root && this instanceof wrapper) ? (Ctor || createCtorWrapper(func)) : func;
    5066         return fn.apply(thisBinding, args);
    5067       }
    5068       return wrapper;
    5069     }
    5070 
    5071     /**
    5072      * Creates the padding required for `string` based on the given `length`.
    5073      * The `chars` string is truncated if the number of characters exceeds `length`.
    5074      *
    5075      * @private
    5076      * @param {string} string The string to create padding for.
    5077      * @param {number} [length=0] The padding length.
    5078      * @param {string} [chars=' '] The string used as padding.
    5079      * @returns {string} Returns the pad for `string`.
    5080      */
    5081     function createPadding(string, length, chars) {
    5082       var strLength = string.length;
    5083       length = +length;
    5084 
    5085       if (strLength >= length || !nativeIsFinite(length)) {
    5086         return '';
    5087       }
    5088       var padLength = length - strLength;
    5089       chars = chars == null ? ' ' : (chars + '');
    5090       return repeat(chars, ceil(padLength / chars.length)).slice(0, padLength);
    5091     }
    5092 
    5093     /**
    5094      * Creates a function that wraps `func` and invokes it with the optional `this`
    5095      * binding of `thisArg` and the `partials` prepended to those provided to
    5096      * the wrapper.
    5097      *
    5098      * @private
    5099      * @param {Function} func The function to partially apply arguments to.
    5100      * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details.
    5101      * @param {*} thisArg The `this` binding of `func`.
    5102      * @param {Array} partials The arguments to prepend to those provided to the new function.
    5103      * @returns {Function} Returns the new bound function.
    5104      */
    5105     function createPartialWrapper(func, bitmask, thisArg, partials) {
    5106       var isBind = bitmask & BIND_FLAG,
    5107           Ctor = createCtorWrapper(func);
    5108 
    5109       function wrapper() {
    5110         // Avoid `arguments` object use disqualifying optimizations by
    5111         // converting it to an array before providing it `func`.
    5112         var argsIndex = -1,
    5113             argsLength = arguments.length,
    5114             leftIndex = -1,
    5115             leftLength = partials.length,
    5116             args = Array(argsLength + leftLength);
    5117 
    5118         while (++leftIndex < leftLength) {
    5119           args[leftIndex] = partials[leftIndex];
    5120         }
    5121         while (argsLength--) {
    5122           args[leftIndex++] = arguments[++argsIndex];
    5123         }
    5124         var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
    5125         return fn.apply(isBind ? thisArg : this, args);
    5126       }
    5127       return wrapper;
    5128     }
    5129 
    5130     /**
    5131      * Creates a `_.sortedIndex` or `_.sortedLastIndex` function.
    5132      *
    5133      * @private
    5134      * @param {boolean} [retHighest] Specify returning the highest qualified index.
    5135      * @returns {Function} Returns the new index function.
    5136      */
    5137     function createSortedIndex(retHighest) {
    5138       return function(array, value, iteratee, thisArg) {
    5139         var func = getCallback(iteratee);
    5140         return (func === baseCallback && iteratee == null)
    5141           ? binaryIndex(array, value, retHighest)
    5142           : binaryIndexBy(array, value, func(iteratee, thisArg, 1), retHighest);
    5143       };
    5144     }
    5145 
    5146     /**
    5147      * Creates a function that either curries or invokes `func` with optional
    5148      * `this` binding and partially applied arguments.
    5149      *
    5150      * @private
    5151      * @param {Function|string} func The function or method name to reference.
    5152      * @param {number} bitmask The bitmask of flags.
    5153      *  The bitmask may be composed of the following flags:
    5154      *     1 - `_.bind`
    5155      *     2 - `_.bindKey`
    5156      *     4 - `_.curry` or `_.curryRight` of a bound function
    5157      *     8 - `_.curry`
    5158      *    16 - `_.curryRight`
    5159      *    32 - `_.partial`
    5160      *    64 - `_.partialRight`
    5161      *   128 - `_.rearg`
    5162      *   256 - `_.ary`
    5163      * @param {*} [thisArg] The `this` binding of `func`.
    5164      * @param {Array} [partials] The arguments to be partially applied.
    5165      * @param {Array} [holders] The `partials` placeholder indexes.
    5166      * @param {Array} [argPos] The argument positions of the new function.
    5167      * @param {number} [ary] The arity cap of `func`.
    5168      * @param {number} [arity] The arity of `func`.
    5169      * @returns {Function} Returns the new wrapped function.
    5170      */
    5171     function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
    5172       var isBindKey = bitmask & BIND_KEY_FLAG;
    5173       if (!isBindKey && typeof func != 'function') {
    5174         throw new TypeError(FUNC_ERROR_TEXT);
    5175       }
    5176       var length = partials ? partials.length : 0;
    5177       if (!length) {
    5178         bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);
    5179         partials = holders = null;
    5180       }
    5181       length -= (holders ? holders.length : 0);
    5182       if (bitmask & PARTIAL_RIGHT_FLAG) {
    5183         var partialsRight = partials,
    5184             holdersRight = holders;
    5185 
    5186         partials = holders = null;
    5187       }
    5188       var data = isBindKey ? null : getData(func),
    5189           newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity];
    5190 
    5191       if (data) {
    5192         mergeData(newData, data);
    5193         bitmask = newData[1];
    5194         arity = newData[9];
    5195       }
    5196       newData[9] = arity == null
    5197         ? (isBindKey ? 0 : func.length)
    5198         : (nativeMax(arity - length, 0) || 0);
    5199 
    5200       if (bitmask == BIND_FLAG) {
    5201         var result = createBindWrapper(newData[0], newData[2]);
    5202       } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !newData[4].length) {
    5203         result = createPartialWrapper.apply(undefined, newData);
    5204       } else {
    5205         result = createHybridWrapper.apply(undefined, newData);
    5206       }
    5207       var setter = data ? baseSetData : setData;
    5208       return setter(result, newData);
    5209     }
    5210 
    5211     /**
    5212      * A specialized version of `baseIsEqualDeep` for arrays with support for
    5213      * partial deep comparisons.
    5214      *
    5215      * @private
    5216      * @param {Array} array The array to compare.
    5217      * @param {Array} other The other array to compare.
    5218      * @param {Function} equalFunc The function to determine equivalents of values.
    5219      * @param {Function} [customizer] The function to customize comparing arrays.
    5220      * @param {boolean} [isLoose] Specify performing partial comparisons.
    5221      * @param {Array} [stackA] Tracks traversed `value` objects.
    5222      * @param {Array} [stackB] Tracks traversed `other` objects.
    5223      * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
    5224      */
    5225     function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
    5226       var index = -1,
    5227           arrLength = array.length,
    5228           othLength = other.length,
    5229           result = true;
    5230 
    5231       if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
    5232         return false;
    5233       }
    5234       // Deep compare the contents, ignoring non-numeric properties.
    5235       while (result && ++index < arrLength) {
    5236         var arrValue = array[index],
    5237             othValue = other[index];
    5238 
    5239         result = undefined;
    5240         if (customizer) {
    5241           result = isLoose
    5242             ? customizer(othValue, arrValue, index)
    5243             : customizer(arrValue, othValue, index);
    5244         }
    5245         if (result === undefined) {
    5246           // Recursively compare arrays (susceptible to call stack limits).
    5247           if (isLoose) {
    5248             var othIndex = othLength;
    5249             while (othIndex--) {
    5250               othValue = other[othIndex];
    5251               result = (arrValue && arrValue === othValue) || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
    5252               if (result) {
    5253                 break;
    5254               }
    5255             }
    5256           } else {
    5257             result = (arrValue && arrValue === othValue) || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
    5258           }
    5259         }
    5260       }
    5261       return !!result;
    5262     }
    5263 
    5264     /**
    5265      * A specialized version of `baseIsEqualDeep` for comparing objects of
    5266      * the same `toStringTag`.
    5267      *
    5268      * **Note:** This function only supports comparing values with tags of
    5269      * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
    5270      *
    5271      * @private
    5272      * @param {Object} value The object to compare.
    5273      * @param {Object} other The other object to compare.
    5274      * @param {string} tag The `toStringTag` of the objects to compare.
    5275      * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    5276      */
    5277     function equalByTag(object, other, tag) {
    5278       switch (tag) {
    5279         case boolTag:
    5280         case dateTag:
    5281           // Coerce dates and booleans to numbers, dates to milliseconds and booleans
    5282           // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
    5283           return +object == +other;
    5284 
    5285         case errorTag:
    5286           return object.name == other.name && object.message == other.message;
    5287 
    5288         case numberTag:
    5289           // Treat `NaN` vs. `NaN` as equal.
    5290           return (object != +object)
    5291             ? other != +other
    5292             // But, treat `-0` vs. `+0` as not equal.
    5293             : (object == 0 ? ((1 / object) == (1 / other)) : object == +other);
    5294 
    5295         case regexpTag:
    5296         case stringTag:
    5297           // Coerce regexes to strings and treat strings primitives and string
    5298           // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
    5299           return object == (other + '');
    5300       }
    5301       return false;
    5302     }
    5303 
    5304     /**
    5305      * A specialized version of `baseIsEqualDeep` for objects with support for
    5306      * partial deep comparisons.
    5307      *
    5308      * @private
    5309      * @param {Object} object The object to compare.
    5310      * @param {Object} other The other object to compare.
    5311      * @param {Function} equalFunc The function to determine equivalents of values.
    5312      * @param {Function} [customizer] The function to customize comparing values.
    5313      * @param {boolean} [isLoose] Specify performing partial comparisons.
    5314      * @param {Array} [stackA] Tracks traversed `value` objects.
    5315      * @param {Array} [stackB] Tracks traversed `other` objects.
    5316      * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    5317      */
    5318     function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
    5319       var objProps = keys(object),
    5320           objLength = objProps.length,
    5321           othProps = keys(other),
    5322           othLength = othProps.length;
    5323 
    5324       if (objLength != othLength && !isLoose) {
    5325         return false;
    5326       }
    5327       var skipCtor = isLoose,
    5328           index = -1;
    5329 
    5330       while (++index < objLength) {
    5331         var key = objProps[index],
    5332             result = isLoose ? key in other : hasOwnProperty.call(other, key);
    5333 
    5334         if (result) {
    5335           var objValue = object[key],
    5336               othValue = other[key];
    5337 
    5338           result = undefined;
    5339           if (customizer) {
    5340             result = isLoose
    5341               ? customizer(othValue, objValue, key)
    5342               : customizer(objValue, othValue, key);
    5343           }
    5344           if (result === undefined) {
    5345             // Recursively compare objects (susceptible to call stack limits).
    5346             result = (objValue && objValue === othValue) || equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB);
    5347           }
    5348         }
    5349         if (!result) {
    5350           return false;
    5351         }
    5352         skipCtor || (skipCtor = key == 'constructor');
    5353       }
    5354       if (!skipCtor) {
    5355         var objCtor = object.constructor,
    5356             othCtor = other.constructor;
    5357 
    5358         // Non `Object` object instances with different constructors are not equal.
    5359         if (objCtor != othCtor &&
    5360             ('constructor' in object && 'constructor' in other) &&
    5361             !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
    5362               typeof othCtor == 'function' && othCtor instanceof othCtor)) {
    5363           return false;
    5364         }
    5365       }
    5366       return true;
    5367     }
    5368 
    5369     /**
    5370      * Gets the extremum value of `collection` invoking `iteratee` for each value
    5371      * in `collection` to generate the criterion by which the value is ranked.
    5372      * The `iteratee` is invoked with three arguments: (value, index, collection).
    5373      *
    5374      * @private
    5375      * @param {Array|Object|string} collection The collection to iterate over.
    5376      * @param {Function} iteratee The function invoked per iteration.
    5377      * @param {boolean} [isMin] Specify returning the minimum, instead of the
    5378      *  maximum, extremum value.
    5379      * @returns {*} Returns the extremum value.
    5380      */
    5381     function extremumBy(collection, iteratee, isMin) {
    5382       var exValue = isMin ? POSITIVE_INFINITY : NEGATIVE_INFINITY,
    5383           computed = exValue,
    5384           result = computed;
    5385 
    5386       baseEach(collection, function(value, index, collection) {
    5387         var current = iteratee(value, index, collection);
    5388         if ((isMin ? (current < computed) : (current > computed)) ||
    5389             (current === exValue && current === result)) {
    5390           computed = current;
    5391           result = value;
    5392         }
    5393       });
    5394       return result;
    5395     }
    5396 
    5397     /**
    5398      * Gets the appropriate "callback" function. If the `_.callback` method is
    5399      * customized this function returns the custom method, otherwise it returns
    5400      * the `baseCallback` function. If arguments are provided the chosen function
    5401      * is invoked with them and its result is returned.
    5402      *
    5403      * @private
    5404      * @returns {Function} Returns the chosen function or its result.
    5405      */
    5406     function getCallback(func, thisArg, argCount) {
    5407       var result = lodash.callback || callback;
    5408       result = result === callback ? baseCallback : result;
    5409       return argCount ? result(func, thisArg, argCount) : result;
    5410     }
    5411 
    5412     /**
    5413      * Gets metadata for `func`.
    5414      *
    5415      * @private
    5416      * @param {Function} func The function to query.
    5417      * @returns {*} Returns the metadata for `func`.
    5418      */
    5419     var getData = !metaMap ? noop : function(func) {
    5420       return metaMap.get(func);
    5421     };
    5422 
    5423     /**
    5424      * Gets the name of `func`.
    5425      *
    5426      * @private
    5427      * @param {Function} func The function to query.
    5428      * @returns {string} Returns the function name.
    5429      */
    5430     var getFuncName = (function() {
    5431       if (!support.funcNames) {
    5432         return constant('');
    5433       }
    5434       if (constant.name == 'constant') {
    5435         return baseProperty('name');
    5436       }
    5437       return function(func) {
    5438         var result = func.name,
    5439             array = realNames[result],
    5440             length = array ? array.length : 0;
    5441 
    5442         while (length--) {
    5443           var data = array[length],
    5444               otherFunc = data.func;
    5445 
    5446           if (otherFunc == null || otherFunc == func) {
    5447             return data.name;
    5448           }
    5449         }
    5450         return result;
    5451       };
    5452     }());
    5453 
    5454     /**
    5455      * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
    5456      * customized this function returns the custom method, otherwise it returns
    5457      * the `baseIndexOf` function. If arguments are provided the chosen function
    5458      * is invoked with them and its result is returned.
    5459      *
    5460      * @private
    5461      * @returns {Function|number} Returns the chosen function or its result.
    5462      */
    5463     function getIndexOf(collection, target, fromIndex) {
    5464       var result = lodash.indexOf || indexOf;
    5465       result = result === indexOf ? baseIndexOf : result;
    5466       return collection ? result(collection, target, fromIndex) : result;
    5467     }
    5468 
    5469     /**
    5470      * Gets the "length" property value of `object`.
    5471      *
    5472      * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
    5473      * in Safari on iOS 8.1 ARM64.
    5474      *
    5475      * @private
    5476      * @param {Object} object The object to query.
    5477      * @returns {*} Returns the "length" value.
    5478      */
    5479     var getLength = baseProperty('length');
    5480 
    5481     /**
    5482      * Creates an array of the own symbols of `object`.
    5483      *
    5484      * @private
    5485      * @param {Object} object The object to query.
    5486      * @returns {Array} Returns the array of symbols.
    5487      */
    5488     var getSymbols = !getOwnPropertySymbols ? constant([]) : function(object) {
    5489       return getOwnPropertySymbols(toObject(object));
    5490     };
    5491 
    5492     /**
    5493      * Gets the view, applying any `transforms` to the `start` and `end` positions.
    5494      *
    5495      * @private
    5496      * @param {number} start The start of the view.
    5497      * @param {number} end The end of the view.
    5498      * @param {Array} [transforms] The transformations to apply to the view.
    5499      * @returns {Object} Returns an object containing the `start` and `end`
    5500      *  positions of the view.
    5501      */
    5502     function getView(start, end, transforms) {
    5503       var index = -1,
    5504           length = transforms ? transforms.length : 0;
    5505 
    5506       while (++index < length) {
    5507         var data = transforms[index],
    5508             size = data.size;
    5509 
    5510         switch (data.type) {
    5511           case 'drop':      start += size; break;
    5512           case 'dropRight': end -= size; break;
    5513           case 'take':      end = nativeMin(end, start + size); break;
    5514           case 'takeRight': start = nativeMax(start, end - size); break;
    5515         }
    5516       }
    5517       return { 'start': start, 'end': end };
    5518     }
    5519 
    5520     /**
    5521      * Initializes an array clone.
    5522      *
    5523      * @private
    5524      * @param {Array} array The array to clone.
    5525      * @returns {Array} Returns the initialized clone.
    5526      */
    5527     function initCloneArray(array) {
    5528       var length = array.length,
    5529           result = new array.constructor(length);
    5530 
    5531       // Add array properties assigned by `RegExp#exec`.
    5532       if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
    5533         result.index = array.index;
    5534         result.input = array.input;
    5535       }
    5536       return result;
    5537     }
    5538 
    5539     /**
    5540      * Initializes an object clone.
    5541      *
    5542      * @private
    5543      * @param {Object} object The object to clone.
    5544      * @returns {Object} Returns the initialized clone.
    5545      */
    5546     function initCloneObject(object) {
    5547       var Ctor = object.constructor;
    5548       if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) {
    5549         Ctor = Object;
    5550       }
    5551       return new Ctor;
    5552     }
    5553 
    5554     /**
    5555      * Initializes an object clone based on its `toStringTag`.
    5556      *
    5557      * **Note:** This function only supports cloning values with tags of
    5558      * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
    5559      *
    5560      * @private
    5561      * @param {Object} object The object to clone.
    5562      * @param {string} tag The `toStringTag` of the object to clone.
    5563      * @param {boolean} [isDeep] Specify a deep clone.
    5564      * @returns {Object} Returns the initialized clone.
    5565      */
    5566     function initCloneByTag(object, tag, isDeep) {
    5567       var Ctor = object.constructor;
    5568       switch (tag) {
    5569         case arrayBufferTag:
    5570           return bufferClone(object);
    5571 
    5572         case boolTag:
    5573         case dateTag:
    5574           return new Ctor(+object);
    5575 
    5576         case float32Tag: case float64Tag:
    5577         case int8Tag: case int16Tag: case int32Tag:
    5578         case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
    5579           var buffer = object.buffer;
    5580           return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length);
    5581 
    5582         case numberTag:
    5583         case stringTag:
    5584           return new Ctor(object);
    5585 
    5586         case regexpTag:
    5587           var result = new Ctor(object.source, reFlags.exec(object));
    5588           result.lastIndex = object.lastIndex;
    5589       }
    5590       return result;
    5591     }
    5592 
    5593     /**
    5594      * Invokes the method at `path` on `object`.
    5595      *
    5596      * @private
    5597      * @param {Object} object The object to query.
    5598      * @param {Array|string} path The path of the method to invoke.
    5599      * @param {Array} args The arguments to invoke the method with.
    5600      * @returns {*} Returns the result of the invoked method.
    5601      */
    5602     function invokePath(object, path, args) {
    5603       if (object != null && !isKey(path, object)) {
    5604         path = toPath(path);
    5605         object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
    5606         path = last(path);
    5607       }
    5608       var func = object == null ? object : object[path];
    5609       return func == null ? undefined : func.apply(object, args);
    5610     }
    5611 
    5612     /**
    5613      * Checks if `value` is a valid array-like index.
    5614      *
    5615      * @private
    5616      * @param {*} value The value to check.
    5617      * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
    5618      * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
    5619      */
    5620     function isIndex(value, length) {
    5621       value = +value;
    5622       length = length == null ? MAX_SAFE_INTEGER : length;
    5623       return value > -1 && value % 1 == 0 && value < length;
    5624     }
    5625 
    5626     /**
    5627      * Checks if the provided arguments are from an iteratee call.
    5628      *
    5629      * @private
    5630      * @param {*} value The potential iteratee value argument.
    5631      * @param {*} index The potential iteratee index or key argument.
    5632      * @param {*} object The potential iteratee object argument.
    5633      * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
    5634      */
    5635     function isIterateeCall(value, index, object) {
    5636       if (!isObject(object)) {
    5637         return false;
    5638       }
    5639       var type = typeof index;
    5640       if (type == 'number') {
    5641         var length = getLength(object),
    5642             prereq = isLength(length) && isIndex(index, length);
    5643       } else {
    5644         prereq = type == 'string' && index in object;
    5645       }
    5646       if (prereq) {
    5647         var other = object[index];
    5648         return value === value ? (value === other) : (other !== other);
    5649       }
    5650       return false;
    5651     }
    5652 
    5653     /**
    5654      * Checks if `value` is a property name and not a property path.
    5655      *
    5656      * @private
    5657      * @param {*} value The value to check.
    5658      * @param {Object} [object] The object to query keys on.
    5659      * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
    5660      */
    5661     function isKey(value, object) {
    5662       var type = typeof value;
    5663       if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {
    5664         return true;
    5665       }
    5666       if (isArray(value)) {
    5667         return false;
    5668       }
    5669       var result = !reIsDeepProp.test(value);
    5670       return result || (object != null && value in toObject(object));
    5671     }
    5672 
    5673     /**
    5674      * Checks if `func` has a lazy counterpart.
    5675      *
    5676      * @private
    5677      * @param {Function} func The function to check.
    5678      * @returns {boolean} Returns `true` if `func` has a lazy counterpart, else `false`.
    5679      */
    5680     function isLaziable(func) {
    5681       var funcName = getFuncName(func);
    5682       return !!funcName && func === lodash[funcName] && funcName in LazyWrapper.prototype;
    5683     }
    5684 
    5685     /**
    5686      * Checks if `value` is a valid array-like length.
    5687      *
    5688      * **Note:** This function is based on [`ToLength`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength).
    5689      *
    5690      * @private
    5691      * @param {*} value The value to check.
    5692      * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
    5693      */
    5694     function isLength(value) {
    5695       return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    5696     }
    5697 
    5698     /**
    5699      * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
    5700      *
    5701      * @private
    5702      * @param {*} value The value to check.
    5703      * @returns {boolean} Returns `true` if `value` if suitable for strict
    5704      *  equality comparisons, else `false`.
    5705      */
    5706     function isStrictComparable(value) {
    5707       return value === value && (value === 0 ? ((1 / value) > 0) : !isObject(value));
    5708     }
    5709 
    5710     /**
    5711      * Merges the function metadata of `source` into `data`.
    5712      *
    5713      * Merging metadata reduces the number of wrappers required to invoke a function.
    5714      * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
    5715      * may be applied regardless of execution order. Methods like `_.ary` and `_.rearg`
    5716      * augment function arguments, making the order in which they are executed important,
    5717      * preventing the merging of metadata. However, we make an exception for a safe
    5718      * common case where curried functions have `_.ary` and or `_.rearg` applied.
    5719      *
    5720      * @private
    5721      * @param {Array} data The destination metadata.
    5722      * @param {Array} source The source metadata.
    5723      * @returns {Array} Returns `data`.
    5724      */
    5725     function mergeData(data, source) {
    5726       var bitmask = data[1],
    5727           srcBitmask = source[1],
    5728           newBitmask = bitmask | srcBitmask,
    5729           isCommon = newBitmask < ARY_FLAG;
    5730 
    5731       var isCombo =
    5732         (srcBitmask == ARY_FLAG && bitmask == CURRY_FLAG) ||
    5733         (srcBitmask == ARY_FLAG && bitmask == REARG_FLAG && data[7].length <= source[8]) ||
    5734         (srcBitmask == (ARY_FLAG | REARG_FLAG) && bitmask == CURRY_FLAG);
    5735 
    5736       // Exit early if metadata can't be merged.
    5737       if (!(isCommon || isCombo)) {
    5738         return data;
    5739       }
    5740       // Use source `thisArg` if available.
    5741       if (srcBitmask & BIND_FLAG) {
    5742         data[2] = source[2];
    5743         // Set when currying a bound function.
    5744         newBitmask |= (bitmask & BIND_FLAG) ? 0 : CURRY_BOUND_FLAG;
    5745       }
    5746       // Compose partial arguments.
    5747       var value = source[3];
    5748       if (value) {
    5749         var partials = data[3];
    5750         data[3] = partials ? composeArgs(partials, value, source[4]) : arrayCopy(value);
    5751         data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : arrayCopy(source[4]);
    5752       }
    5753       // Compose partial right arguments.
    5754       value = source[5];
    5755       if (value) {
    5756         partials = data[5];
    5757         data[5] = partials ? composeArgsRight(partials, value, source[6]) : arrayCopy(value);
    5758         data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : arrayCopy(source[6]);
    5759       }
    5760       // Use source `argPos` if available.
    5761       value = source[7];
    5762       if (value) {
    5763         data[7] = arrayCopy(value);
    5764       }
    5765       // Use source `ary` if it's smaller.
    5766       if (srcBitmask & ARY_FLAG) {
    5767         data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
    5768       }
    5769       // Use source `arity` if one is not provided.
    5770       if (data[9] == null) {
    5771         data[9] = source[9];
    5772       }
    5773       // Use source `func` and merge bitmasks.
    5774       data[0] = source[0];
    5775       data[1] = newBitmask;
    5776 
    5777       return data;
    5778     }
    5779 
    5780     /**
    5781      * A specialized version of `_.pick` that picks `object` properties specified
    5782      * by `props`.
    5783      *
    5784      * @private
    5785      * @param {Object} object The source object.
    5786      * @param {string[]} props The property names to pick.
    5787      * @returns {Object} Returns the new object.
    5788      */
    5789     function pickByArray(object, props) {
    5790       object = toObject(object);
    5791 
    5792       var index = -1,
    5793           length = props.length,
    5794           result = {};
    5795 
    5796       while (++index < length) {
    5797         var key = props[index];
    5798         if (key in object) {
    5799           result[key] = object[key];
    5800         }
    5801       }
    5802       return result;
    5803     }
    5804 
    5805     /**
    5806      * A specialized version of `_.pick` that picks `object` properties `predicate`
    5807      * returns truthy for.
    5808      *
    5809      * @private
    5810      * @param {Object} object The source object.
    5811      * @param {Function} predicate The function invoked per iteration.
    5812      * @returns {Object} Returns the new object.
    5813      */
    5814     function pickByCallback(object, predicate) {
    5815       var result = {};
    5816       baseForIn(object, function(value, key, object) {
    5817         if (predicate(value, key, object)) {
    5818           result[key] = value;
    5819         }
    5820       });
    5821       return result;
    5822     }
    5823 
    5824     /**
    5825      * Reorder `array` according to the specified indexes where the element at
    5826      * the first index is assigned as the first element, the element at
    5827      * the second index is assigned as the second element, and so on.
    5828      *
    5829      * @private
    5830      * @param {Array} array The array to reorder.
    5831      * @param {Array} indexes The arranged array indexes.
    5832      * @returns {Array} Returns `array`.
    5833      */
    5834     function reorder(array, indexes) {
    5835       var arrLength = array.length,
    5836           length = nativeMin(indexes.length, arrLength),
    5837           oldArray = arrayCopy(array);
    5838 
    5839       while (length--) {
    5840         var index = indexes[length];
    5841         array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
    5842       }
    5843       return array;
    5844     }
    5845 
    5846     /**
    5847      * Sets metadata for `func`.
    5848      *
    5849      * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
    5850      * period of time, it will trip its breaker and transition to an identity function
    5851      * to avoid garbage collection pauses in V8. See [V8 issue 2070](https://code.google.com/p/v8/issues/detail?id=2070)
    5852      * for more details.
    5853      *
    5854      * @private
    5855      * @param {Function} func The function to associate metadata with.
    5856      * @param {*} data The metadata.
    5857      * @returns {Function} Returns `func`.
    5858      */
    5859     var setData = (function() {
    5860       var count = 0,
    5861           lastCalled = 0;
    5862 
    5863       return function(key, value) {
    5864         var stamp = now(),
    5865             remaining = HOT_SPAN - (stamp - lastCalled);
    5866 
    5867         lastCalled = stamp;
    5868         if (remaining > 0) {
    5869           if (++count >= HOT_COUNT) {
    5870             return key;
    5871           }
    5872         } else {
    5873           count = 0;
    5874         }
    5875         return baseSetData(key, value);
    5876       };
    5877     }());
    5878 
    5879     /**
    5880      * A fallback implementation of `_.isPlainObject` which checks if `value`
    5881      * is an object created by the `Object` constructor or has a `[[Prototype]]`
    5882      * of `null`.
    5883      *
    5884      * @private
    5885      * @param {*} value The value to check.
    5886      * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
    5887      */
    5888     function shimIsPlainObject(value) {
    5889       var Ctor,
    5890           support = lodash.support;
    5891 
    5892       // Exit early for non `Object` objects.
    5893       if (!(isObjectLike(value) && objToString.call(value) == objectTag) ||
    5894           (!hasOwnProperty.call(value, 'constructor') &&
    5895             (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {
    5896         return false;
    5897       }
    5898       // IE < 9 iterates inherited properties before own properties. If the first
    5899       // iterated property is an object's own property then there are no inherited
    5900       // enumerable properties.
    5901       var result;
    5902       // In most environments an object's own properties are iterated before
    5903       // its inherited properties. If the last iterated property is an object's
    5904       // own property then there are no inherited enumerable properties.
    5905       baseForIn(value, function(subValue, key) {
    5906         result = key;
    5907       });
    5908       return result === undefined || hasOwnProperty.call(value, result);
    5909     }
    5910 
    5911     /**
    5912      * A fallback implementation of `Object.keys` which creates an array of the
    5913      * own enumerable property names of `object`.
    5914      *
    5915      * @private
    5916      * @param {Object} object The object to query.
    5917      * @returns {Array} Returns the array of property names.
    5918      */
    5919     function shimKeys(object) {
    5920       var props = keysIn(object),
    5921           propsLength = props.length,
    5922           length = propsLength && object.length,
    5923           support = lodash.support;
    5924 
    5925       var allowIndexes = length && isLength(length) &&
    5926         (isArray(object) || (support.nonEnumArgs && isArguments(object)));
    5927 
    5928       var index = -1,
    5929           result = [];
    5930 
    5931       while (++index < propsLength) {
    5932         var key = props[index];
    5933         if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
    5934           result.push(key);
    5935         }
    5936       }
    5937       return result;
    5938     }
    5939 
    5940     /**
    5941      * Converts `value` to an array-like object if it is not one.
    5942      *
    5943      * @private
    5944      * @param {*} value The value to process.
    5945      * @returns {Array|Object} Returns the array-like object.
    5946      */
    5947     function toIterable(value) {
    5948       if (value == null) {
    5949         return [];
    5950       }
    5951       if (!isLength(getLength(value))) {
    5952         return values(value);
    5953       }
    5954       return isObject(value) ? value : Object(value);
    5955     }
    5956 
    5957     /**
    5958      * Converts `value` to an object if it is not one.
    5959      *
    5960      * @private
    5961      * @param {*} value The value to process.
    5962      * @returns {Object} Returns the object.
    5963      */
    5964     function toObject(value) {
    5965       return isObject(value) ? value : Object(value);
    5966     }
    5967 
    5968     /**
    5969      * Converts `value` to property path array if it is not one.
    5970      *
    5971      * @private
    5972      * @param {*} value The value to process.
    5973      * @returns {Array} Returns the property path array.
    5974      */
    5975     function toPath(value) {
    5976       if (isArray(value)) {
    5977         return value;
    5978       }
    5979       var result = [];
    5980       baseToString(value).replace(rePropName, function(match, number, quote, string) {
    5981         result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
    5982       });
    5983       return result;
    5984     }
    5985 
    5986     /**
    5987      * Creates a clone of `wrapper`.
    5988      *
    5989      * @private
    5990      * @param {Object} wrapper The wrapper to clone.
    5991      * @returns {Object} Returns the cloned wrapper.
    5992      */
    5993     function wrapperClone(wrapper) {
    5994       return wrapper instanceof LazyWrapper
    5995         ? wrapper.clone()
    5996         : new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__, arrayCopy(wrapper.__actions__));
    5997     }
    5998 
    5999     /*------------------------------------------------------------------------*/
    6000 
    6001     /**
    6002      * Creates an array of elements split into groups the length of `size`.
    6003      * If `collection` can't be split evenly, the final chunk will be the remaining
    6004      * elements.
    6005      *
    6006      * @static
    6007      * @memberOf _
    6008      * @category Array
    6009      * @param {Array} array The array to process.
    6010      * @param {number} [size=1] The length of each chunk.
    6011      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    6012      * @returns {Array} Returns the new array containing chunks.
    6013      * @example
    6014      *
    6015      * _.chunk(['a', 'b', 'c', 'd'], 2);
    6016      * // => [['a', 'b'], ['c', 'd']]
    6017      *
    6018      * _.chunk(['a', 'b', 'c', 'd'], 3);
    6019      * // => [['a', 'b', 'c'], ['d']]
    6020      */
    6021     function chunk(array, size, guard) {
    6022       if (guard ? isIterateeCall(array, size, guard) : size == null) {
    6023         size = 1;
    6024       } else {
    6025         size = nativeMax(+size || 1, 1);
    6026       }
    6027       var index = 0,
    6028           length = array ? array.length : 0,
    6029           resIndex = -1,
    6030           result = Array(ceil(length / size));
    6031 
    6032       while (index < length) {
    6033         result[++resIndex] = baseSlice(array, index, (index += size));
    6034       }
    6035       return result;
    6036     }
    6037 
    6038     /**
    6039      * Creates an array with all falsey values removed. The values `false`, `null`,
    6040      * `0`, `""`, `undefined`, and `NaN` are falsey.
    6041      *
    6042      * @static
    6043      * @memberOf _
    6044      * @category Array
    6045      * @param {Array} array The array to compact.
    6046      * @returns {Array} Returns the new array of filtered values.
    6047      * @example
    6048      *
    6049      * _.compact([0, 1, false, 2, '', 3]);
    6050      * // => [1, 2, 3]
    6051      */
    6052     function compact(array) {
    6053       var index = -1,
    6054           length = array ? array.length : 0,
    6055           resIndex = -1,
    6056           result = [];
    6057 
    6058       while (++index < length) {
    6059         var value = array[index];
    6060         if (value) {
    6061           result[++resIndex] = value;
    6062         }
    6063       }
    6064       return result;
    6065     }
    6066 
    6067     /**
    6068      * Creates an array excluding all values of the provided arrays using
    6069      * `SameValueZero` for equality comparisons.
    6070      *
    6071      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    6072      * comparisons are like strict equality comparisons, e.g. `===`, except that
    6073      * `NaN` matches `NaN`.
    6074      *
    6075      * @static
    6076      * @memberOf _
    6077      * @category Array
    6078      * @param {Array} array The array to inspect.
    6079      * @param {...Array} [values] The arrays of values to exclude.
    6080      * @returns {Array} Returns the new array of filtered values.
    6081      * @example
    6082      *
    6083      * _.difference([1, 2, 3], [4, 2]);
    6084      * // => [1, 3]
    6085      */
    6086     var difference = restParam(function(array, values) {
    6087       return (isArray(array) || isArguments(array))
    6088         ? baseDifference(array, baseFlatten(values, false, true))
    6089         : [];
    6090     });
    6091 
    6092     /**
    6093      * Creates a slice of `array` with `n` elements dropped from the beginning.
    6094      *
    6095      * @static
    6096      * @memberOf _
    6097      * @category Array
    6098      * @param {Array} array The array to query.
    6099      * @param {number} [n=1] The number of elements to drop.
    6100      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    6101      * @returns {Array} Returns the slice of `array`.
    6102      * @example
    6103      *
    6104      * _.drop([1, 2, 3]);
    6105      * // => [2, 3]
    6106      *
    6107      * _.drop([1, 2, 3], 2);
    6108      * // => [3]
    6109      *
    6110      * _.drop([1, 2, 3], 5);
    6111      * // => []
    6112      *
    6113      * _.drop([1, 2, 3], 0);
    6114      * // => [1, 2, 3]
    6115      */
    6116     function drop(array, n, guard) {
    6117       var length = array ? array.length : 0;
    6118       if (!length) {
    6119         return [];
    6120       }
    6121       if (guard ? isIterateeCall(array, n, guard) : n == null) {
    6122         n = 1;
    6123       }
    6124       return baseSlice(array, n < 0 ? 0 : n);
    6125     }
    6126 
    6127     /**
    6128      * Creates a slice of `array` with `n` elements dropped from the end.
    6129      *
    6130      * @static
    6131      * @memberOf _
    6132      * @category Array
    6133      * @param {Array} array The array to query.
    6134      * @param {number} [n=1] The number of elements to drop.
    6135      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    6136      * @returns {Array} Returns the slice of `array`.
    6137      * @example
    6138      *
    6139      * _.dropRight([1, 2, 3]);
    6140      * // => [1, 2]
    6141      *
    6142      * _.dropRight([1, 2, 3], 2);
    6143      * // => [1]
    6144      *
    6145      * _.dropRight([1, 2, 3], 5);
    6146      * // => []
    6147      *
    6148      * _.dropRight([1, 2, 3], 0);
    6149      * // => [1, 2, 3]
    6150      */
    6151     function dropRight(array, n, guard) {
    6152       var length = array ? array.length : 0;
    6153       if (!length) {
    6154         return [];
    6155       }
    6156       if (guard ? isIterateeCall(array, n, guard) : n == null) {
    6157         n = 1;
    6158       }
    6159       n = length - (+n || 0);
    6160       return baseSlice(array, 0, n < 0 ? 0 : n);
    6161     }
    6162 
    6163     /**
    6164      * Creates a slice of `array` excluding elements dropped from the end.
    6165      * Elements are dropped until `predicate` returns falsey. The predicate is
    6166      * bound to `thisArg` and invoked with three arguments: (value, index, array).
    6167      *
    6168      * If a property name is provided for `predicate` the created `_.property`
    6169      * style callback returns the property value of the given element.
    6170      *
    6171      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    6172      * style callback returns `true` for elements that have a matching property
    6173      * value, else `false`.
    6174      *
    6175      * If an object is provided for `predicate` the created `_.matches` style
    6176      * callback returns `true` for elements that match the properties of the given
    6177      * object, else `false`.
    6178      *
    6179      * @static
    6180      * @memberOf _
    6181      * @category Array
    6182      * @param {Array} array The array to query.
    6183      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    6184      *  per iteration.
    6185      * @param {*} [thisArg] The `this` binding of `predicate`.
    6186      * @returns {Array} Returns the slice of `array`.
    6187      * @example
    6188      *
    6189      * _.dropRightWhile([1, 2, 3], function(n) {
    6190      *   return n > 1;
    6191      * });
    6192      * // => [1]
    6193      *
    6194      * var users = [
    6195      *   { 'user': 'barney',  'active': true },
    6196      *   { 'user': 'fred',    'active': false },
    6197      *   { 'user': 'pebbles', 'active': false }
    6198      * ];
    6199      *
    6200      * // using the `_.matches` callback shorthand
    6201      * _.pluck(_.dropRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user');
    6202      * // => ['barney', 'fred']
    6203      *
    6204      * // using the `_.matchesProperty` callback shorthand
    6205      * _.pluck(_.dropRightWhile(users, 'active', false), 'user');
    6206      * // => ['barney']
    6207      *
    6208      * // using the `_.property` callback shorthand
    6209      * _.pluck(_.dropRightWhile(users, 'active'), 'user');
    6210      * // => ['barney', 'fred', 'pebbles']
    6211      */
    6212     function dropRightWhile(array, predicate, thisArg) {
    6213       return (array && array.length)
    6214         ? baseWhile(array, getCallback(predicate, thisArg, 3), true, true)
    6215         : [];
    6216     }
    6217 
    6218     /**
    6219      * Creates a slice of `array` excluding elements dropped from the beginning.
    6220      * Elements are dropped until `predicate` returns falsey. The predicate is
    6221      * bound to `thisArg` and invoked with three arguments: (value, index, array).
    6222      *
    6223      * If a property name is provided for `predicate` the created `_.property`
    6224      * style callback returns the property value of the given element.
    6225      *
    6226      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    6227      * style callback returns `true` for elements that have a matching property
    6228      * value, else `false`.
    6229      *
    6230      * If an object is provided for `predicate` the created `_.matches` style
    6231      * callback returns `true` for elements that have the properties of the given
    6232      * object, else `false`.
    6233      *
    6234      * @static
    6235      * @memberOf _
    6236      * @category Array
    6237      * @param {Array} array The array to query.
    6238      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    6239      *  per iteration.
    6240      * @param {*} [thisArg] The `this` binding of `predicate`.
    6241      * @returns {Array} Returns the slice of `array`.
    6242      * @example
    6243      *
    6244      * _.dropWhile([1, 2, 3], function(n) {
    6245      *   return n < 3;
    6246      * });
    6247      * // => [3]
    6248      *
    6249      * var users = [
    6250      *   { 'user': 'barney',  'active': false },
    6251      *   { 'user': 'fred',    'active': false },
    6252      *   { 'user': 'pebbles', 'active': true }
    6253      * ];
    6254      *
    6255      * // using the `_.matches` callback shorthand
    6256      * _.pluck(_.dropWhile(users, { 'user': 'barney', 'active': false }), 'user');
    6257      * // => ['fred', 'pebbles']
    6258      *
    6259      * // using the `_.matchesProperty` callback shorthand
    6260      * _.pluck(_.dropWhile(users, 'active', false), 'user');
    6261      * // => ['pebbles']
    6262      *
    6263      * // using the `_.property` callback shorthand
    6264      * _.pluck(_.dropWhile(users, 'active'), 'user');
    6265      * // => ['barney', 'fred', 'pebbles']
    6266      */
    6267     function dropWhile(array, predicate, thisArg) {
    6268       return (array && array.length)
    6269         ? baseWhile(array, getCallback(predicate, thisArg, 3), true)
    6270         : [];
    6271     }
    6272 
    6273     /**
    6274      * Fills elements of `array` with `value` from `start` up to, but not
    6275      * including, `end`.
    6276      *
    6277      * **Note:** This method mutates `array`.
    6278      *
    6279      * @static
    6280      * @memberOf _
    6281      * @category Array
    6282      * @param {Array} array The array to fill.
    6283      * @param {*} value The value to fill `array` with.
    6284      * @param {number} [start=0] The start position.
    6285      * @param {number} [end=array.length] The end position.
    6286      * @returns {Array} Returns `array`.
    6287      * @example
    6288      *
    6289      * var array = [1, 2, 3];
    6290      *
    6291      * _.fill(array, 'a');
    6292      * console.log(array);
    6293      * // => ['a', 'a', 'a']
    6294      *
    6295      * _.fill(Array(3), 2);
    6296      * // => [2, 2, 2]
    6297      *
    6298      * _.fill([4, 6, 8], '*', 1, 2);
    6299      * // => [4, '*', 8]
    6300      */
    6301     function fill(array, value, start, end) {
    6302       var length = array ? array.length : 0;
    6303       if (!length) {
    6304         return [];
    6305       }
    6306       if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
    6307         start = 0;
    6308         end = length;
    6309       }
    6310       return baseFill(array, value, start, end);
    6311     }
    6312 
    6313     /**
    6314      * This method is like `_.find` except that it returns the index of the first
    6315      * element `predicate` returns truthy for instead of the element itself.
    6316      *
    6317      * If a property name is provided for `predicate` the created `_.property`
    6318      * style callback returns the property value of the given element.
    6319      *
    6320      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    6321      * style callback returns `true` for elements that have a matching property
    6322      * value, else `false`.
    6323      *
    6324      * If an object is provided for `predicate` the created `_.matches` style
    6325      * callback returns `true` for elements that have the properties of the given
    6326      * object, else `false`.
    6327      *
    6328      * @static
    6329      * @memberOf _
    6330      * @category Array
    6331      * @param {Array} array The array to search.
    6332      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    6333      *  per iteration.
    6334      * @param {*} [thisArg] The `this` binding of `predicate`.
    6335      * @returns {number} Returns the index of the found element, else `-1`.
    6336      * @example
    6337      *
    6338      * var users = [
    6339      *   { 'user': 'barney',  'active': false },
    6340      *   { 'user': 'fred',    'active': false },
    6341      *   { 'user': 'pebbles', 'active': true }
    6342      * ];
    6343      *
    6344      * _.findIndex(users, function(chr) {
    6345      *   return chr.user == 'barney';
    6346      * });
    6347      * // => 0
    6348      *
    6349      * // using the `_.matches` callback shorthand
    6350      * _.findIndex(users, { 'user': 'fred', 'active': false });
    6351      * // => 1
    6352      *
    6353      * // using the `_.matchesProperty` callback shorthand
    6354      * _.findIndex(users, 'active', false);
    6355      * // => 0
    6356      *
    6357      * // using the `_.property` callback shorthand
    6358      * _.findIndex(users, 'active');
    6359      * // => 2
    6360      */
    6361     var findIndex = createFindIndex();
    6362 
    6363     /**
    6364      * This method is like `_.findIndex` except that it iterates over elements
    6365      * of `collection` from right to left.
    6366      *
    6367      * If a property name is provided for `predicate` the created `_.property`
    6368      * style callback returns the property value of the given element.
    6369      *
    6370      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    6371      * style callback returns `true` for elements that have a matching property
    6372      * value, else `false`.
    6373      *
    6374      * If an object is provided for `predicate` the created `_.matches` style
    6375      * callback returns `true` for elements that have the properties of the given
    6376      * object, else `false`.
    6377      *
    6378      * @static
    6379      * @memberOf _
    6380      * @category Array
    6381      * @param {Array} array The array to search.
    6382      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    6383      *  per iteration.
    6384      * @param {*} [thisArg] The `this` binding of `predicate`.
    6385      * @returns {number} Returns the index of the found element, else `-1`.
    6386      * @example
    6387      *
    6388      * var users = [
    6389      *   { 'user': 'barney',  'active': true },
    6390      *   { 'user': 'fred',    'active': false },
    6391      *   { 'user': 'pebbles', 'active': false }
    6392      * ];
    6393      *
    6394      * _.findLastIndex(users, function(chr) {
    6395      *   return chr.user == 'pebbles';
    6396      * });
    6397      * // => 2
    6398      *
    6399      * // using the `_.matches` callback shorthand
    6400      * _.findLastIndex(users, { 'user': 'barney', 'active': true });
    6401      * // => 0
    6402      *
    6403      * // using the `_.matchesProperty` callback shorthand
    6404      * _.findLastIndex(users, 'active', false);
    6405      * // => 2
    6406      *
    6407      * // using the `_.property` callback shorthand
    6408      * _.findLastIndex(users, 'active');
    6409      * // => 0
    6410      */
    6411     var findLastIndex = createFindIndex(true);
    6412 
    6413     /**
    6414      * Gets the first element of `array`.
    6415      *
    6416      * @static
    6417      * @memberOf _
    6418      * @alias head
    6419      * @category Array
    6420      * @param {Array} array The array to query.
    6421      * @returns {*} Returns the first element of `array`.
    6422      * @example
    6423      *
    6424      * _.first([1, 2, 3]);
    6425      * // => 1
    6426      *
    6427      * _.first([]);
    6428      * // => undefined
    6429      */
    6430     function first(array) {
    6431       return array ? array[0] : undefined;
    6432     }
    6433 
    6434     /**
    6435      * Flattens a nested array. If `isDeep` is `true` the array is recursively
    6436      * flattened, otherwise it is only flattened a single level.
    6437      *
    6438      * @static
    6439      * @memberOf _
    6440      * @category Array
    6441      * @param {Array} array The array to flatten.
    6442      * @param {boolean} [isDeep] Specify a deep flatten.
    6443      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    6444      * @returns {Array} Returns the new flattened array.
    6445      * @example
    6446      *
    6447      * _.flatten([1, [2, 3, [4]]]);
    6448      * // => [1, 2, 3, [4]]
    6449      *
    6450      * // using `isDeep`
    6451      * _.flatten([1, [2, 3, [4]]], true);
    6452      * // => [1, 2, 3, 4]
    6453      */
    6454     function flatten(array, isDeep, guard) {
    6455       var length = array ? array.length : 0;
    6456       if (guard && isIterateeCall(array, isDeep, guard)) {
    6457         isDeep = false;
    6458       }
    6459       return length ? baseFlatten(array, isDeep) : [];
    6460     }
    6461 
    6462     /**
    6463      * Recursively flattens a nested array.
    6464      *
    6465      * @static
    6466      * @memberOf _
    6467      * @category Array
    6468      * @param {Array} array The array to recursively flatten.
    6469      * @returns {Array} Returns the new flattened array.
    6470      * @example
    6471      *
    6472      * _.flattenDeep([1, [2, 3, [4]]]);
    6473      * // => [1, 2, 3, 4]
    6474      */
    6475     function flattenDeep(array) {
    6476       var length = array ? array.length : 0;
    6477       return length ? baseFlatten(array, true) : [];
    6478     }
    6479 
    6480     /**
    6481      * Gets the index at which the first occurrence of `value` is found in `array`
    6482      * using `SameValueZero` for equality comparisons. If `fromIndex` is negative,
    6483      * it is used as the offset from the end of `array`. If `array` is sorted
    6484      * providing `true` for `fromIndex` performs a faster binary search.
    6485      *
    6486      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    6487      * comparisons are like strict equality comparisons, e.g. `===`, except that
    6488      * `NaN` matches `NaN`.
    6489      *
    6490      * @static
    6491      * @memberOf _
    6492      * @category Array
    6493      * @param {Array} array The array to search.
    6494      * @param {*} value The value to search for.
    6495      * @param {boolean|number} [fromIndex=0] The index to search from or `true`
    6496      *  to perform a binary search on a sorted array.
    6497      * @returns {number} Returns the index of the matched value, else `-1`.
    6498      * @example
    6499      *
    6500      * _.indexOf([1, 2, 1, 2], 2);
    6501      * // => 1
    6502      *
    6503      * // using `fromIndex`
    6504      * _.indexOf([1, 2, 1, 2], 2, 2);
    6505      * // => 3
    6506      *
    6507      * // performing a binary search
    6508      * _.indexOf([1, 1, 2, 2], 2, true);
    6509      * // => 2
    6510      */
    6511     function indexOf(array, value, fromIndex) {
    6512       var length = array ? array.length : 0;
    6513       if (!length) {
    6514         return -1;
    6515       }
    6516       if (typeof fromIndex == 'number') {
    6517         fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex;
    6518       } else if (fromIndex) {
    6519         var index = binaryIndex(array, value),
    6520             other = array[index];
    6521 
    6522         if (value === value ? (value === other) : (other !== other)) {
    6523           return index;
    6524         }
    6525         return -1;
    6526       }
    6527       return baseIndexOf(array, value, fromIndex || 0);
    6528     }
    6529 
    6530     /**
    6531      * Gets all but the last element of `array`.
    6532      *
    6533      * @static
    6534      * @memberOf _
    6535      * @category Array
    6536      * @param {Array} array The array to query.
    6537      * @returns {Array} Returns the slice of `array`.
    6538      * @example
    6539      *
    6540      * _.initial([1, 2, 3]);
    6541      * // => [1, 2]
    6542      */
    6543     function initial(array) {
    6544       return dropRight(array, 1);
    6545     }
    6546 
    6547     /**
    6548      * Creates an array of unique values in all provided arrays using `SameValueZero`
    6549      * for equality comparisons.
    6550      *
    6551      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    6552      * comparisons are like strict equality comparisons, e.g. `===`, except that
    6553      * `NaN` matches `NaN`.
    6554      *
    6555      * @static
    6556      * @memberOf _
    6557      * @category Array
    6558      * @param {...Array} [arrays] The arrays to inspect.
    6559      * @returns {Array} Returns the new array of shared values.
    6560      * @example
    6561      * _.intersection([1, 2], [4, 2], [2, 1]);
    6562      * // => [2]
    6563      */
    6564     function intersection() {
    6565       var args = [],
    6566           argsIndex = -1,
    6567           argsLength = arguments.length,
    6568           caches = [],
    6569           indexOf = getIndexOf(),
    6570           isCommon = indexOf == baseIndexOf,
    6571           result = [];
    6572 
    6573       while (++argsIndex < argsLength) {
    6574         var value = arguments[argsIndex];
    6575         if (isArray(value) || isArguments(value)) {
    6576           args.push(value);
    6577           caches.push((isCommon && value.length >= 120) ? createCache(argsIndex && value) : null);
    6578         }
    6579       }
    6580       argsLength = args.length;
    6581       if (argsLength < 2) {
    6582         return result;
    6583       }
    6584       var array = args[0],
    6585           index = -1,
    6586           length = array ? array.length : 0,
    6587           seen = caches[0];
    6588 
    6589       outer:
    6590       while (++index < length) {
    6591         value = array[index];
    6592         if ((seen ? cacheIndexOf(seen, value) : indexOf(result, value, 0)) < 0) {
    6593           argsIndex = argsLength;
    6594           while (--argsIndex) {
    6595             var cache = caches[argsIndex];
    6596             if ((cache ? cacheIndexOf(cache, value) : indexOf(args[argsIndex], value, 0)) < 0) {
    6597               continue outer;
    6598             }
    6599           }
    6600           if (seen) {
    6601             seen.push(value);
    6602           }
    6603           result.push(value);
    6604         }
    6605       }
    6606       return result;
    6607     }
    6608 
    6609     /**
    6610      * Gets the last element of `array`.
    6611      *
    6612      * @static
    6613      * @memberOf _
    6614      * @category Array
    6615      * @param {Array} array The array to query.
    6616      * @returns {*} Returns the last element of `array`.
    6617      * @example
    6618      *
    6619      * _.last([1, 2, 3]);
    6620      * // => 3
    6621      */
    6622     function last(array) {
    6623       var length = array ? array.length : 0;
    6624       return length ? array[length - 1] : undefined;
    6625     }
    6626 
    6627     /**
    6628      * This method is like `_.indexOf` except that it iterates over elements of
    6629      * `array` from right to left.
    6630      *
    6631      * @static
    6632      * @memberOf _
    6633      * @category Array
    6634      * @param {Array} array The array to search.
    6635      * @param {*} value The value to search for.
    6636      * @param {boolean|number} [fromIndex=array.length-1] The index to search from
    6637      *  or `true` to perform a binary search on a sorted array.
    6638      * @returns {number} Returns the index of the matched value, else `-1`.
    6639      * @example
    6640      *
    6641      * _.lastIndexOf([1, 2, 1, 2], 2);
    6642      * // => 3
    6643      *
    6644      * // using `fromIndex`
    6645      * _.lastIndexOf([1, 2, 1, 2], 2, 2);
    6646      * // => 1
    6647      *
    6648      * // performing a binary search
    6649      * _.lastIndexOf([1, 1, 2, 2], 2, true);
    6650      * // => 3
    6651      */
    6652     function lastIndexOf(array, value, fromIndex) {
    6653       var length = array ? array.length : 0;
    6654       if (!length) {
    6655         return -1;
    6656       }
    6657       var index = length;
    6658       if (typeof fromIndex == 'number') {
    6659         index = (fromIndex < 0 ? nativeMax(length + fromIndex, 0) : nativeMin(fromIndex || 0, length - 1)) + 1;
    6660       } else if (fromIndex) {
    6661         index = binaryIndex(array, value, true) - 1;
    6662         var other = array[index];
    6663         if (value === value ? (value === other) : (other !== other)) {
    6664           return index;
    6665         }
    6666         return -1;
    6667       }
    6668       if (value !== value) {
    6669         return indexOfNaN(array, index, true);
    6670       }
    6671       while (index--) {
    6672         if (array[index] === value) {
    6673           return index;
    6674         }
    6675       }
    6676       return -1;
    6677     }
    6678 
    6679     /**
    6680      * Removes all provided values from `array` using `SameValueZero` for equality
    6681      * comparisons.
    6682      *
    6683      * **Notes:**
    6684      *  - Unlike `_.without`, this method mutates `array`
    6685      *  - [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    6686      *    comparisons are like strict equality comparisons, e.g. `===`, except
    6687      *    that `NaN` matches `NaN`
    6688      *
    6689      * @static
    6690      * @memberOf _
    6691      * @category Array
    6692      * @param {Array} array The array to modify.
    6693      * @param {...*} [values] The values to remove.
    6694      * @returns {Array} Returns `array`.
    6695      * @example
    6696      *
    6697      * var array = [1, 2, 3, 1, 2, 3];
    6698      *
    6699      * _.pull(array, 2, 3);
    6700      * console.log(array);
    6701      * // => [1, 1]
    6702      */
    6703     function pull() {
    6704       var args = arguments,
    6705           array = args[0];
    6706 
    6707       if (!(array && array.length)) {
    6708         return array;
    6709       }
    6710       var index = 0,
    6711           indexOf = getIndexOf(),
    6712           length = args.length;
    6713 
    6714       while (++index < length) {
    6715         var fromIndex = 0,
    6716             value = args[index];
    6717 
    6718         while ((fromIndex = indexOf(array, value, fromIndex)) > -1) {
    6719           splice.call(array, fromIndex, 1);
    6720         }
    6721       }
    6722       return array;
    6723     }
    6724 
    6725     /**
    6726      * Removes elements from `array` corresponding to the given indexes and returns
    6727      * an array of the removed elements. Indexes may be specified as an array of
    6728      * indexes or as individual arguments.
    6729      *
    6730      * **Note:** Unlike `_.at`, this method mutates `array`.
    6731      *
    6732      * @static
    6733      * @memberOf _
    6734      * @category Array
    6735      * @param {Array} array The array to modify.
    6736      * @param {...(number|number[])} [indexes] The indexes of elements to remove,
    6737      *  specified as individual indexes or arrays of indexes.
    6738      * @returns {Array} Returns the new array of removed elements.
    6739      * @example
    6740      *
    6741      * var array = [5, 10, 15, 20];
    6742      * var evens = _.pullAt(array, 1, 3);
    6743      *
    6744      * console.log(array);
    6745      * // => [5, 15]
    6746      *
    6747      * console.log(evens);
    6748      * // => [10, 20]
    6749      */
    6750     var pullAt = restParam(function(array, indexes) {
    6751       array || (array = []);
    6752       indexes = baseFlatten(indexes);
    6753 
    6754       var result = baseAt(array, indexes);
    6755       basePullAt(array, indexes.sort(baseCompareAscending));
    6756       return result;
    6757     });
    6758 
    6759     /**
    6760      * Removes all elements from `array` that `predicate` returns truthy for
    6761      * and returns an array of the removed elements. The predicate is bound to
    6762      * `thisArg` and invoked with three arguments: (value, index, array).
    6763      *
    6764      * If a property name is provided for `predicate` the created `_.property`
    6765      * style callback returns the property value of the given element.
    6766      *
    6767      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    6768      * style callback returns `true` for elements that have a matching property
    6769      * value, else `false`.
    6770      *
    6771      * If an object is provided for `predicate` the created `_.matches` style
    6772      * callback returns `true` for elements that have the properties of the given
    6773      * object, else `false`.
    6774      *
    6775      * **Note:** Unlike `_.filter`, this method mutates `array`.
    6776      *
    6777      * @static
    6778      * @memberOf _
    6779      * @category Array
    6780      * @param {Array} array The array to modify.
    6781      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    6782      *  per iteration.
    6783      * @param {*} [thisArg] The `this` binding of `predicate`.
    6784      * @returns {Array} Returns the new array of removed elements.
    6785      * @example
    6786      *
    6787      * var array = [1, 2, 3, 4];
    6788      * var evens = _.remove(array, function(n) {
    6789      *   return n % 2 == 0;
    6790      * });
    6791      *
    6792      * console.log(array);
    6793      * // => [1, 3]
    6794      *
    6795      * console.log(evens);
    6796      * // => [2, 4]
    6797      */
    6798     function remove(array, predicate, thisArg) {
    6799       var result = [];
    6800       if (!(array && array.length)) {
    6801         return result;
    6802       }
    6803       var index = -1,
    6804           indexes = [],
    6805           length = array.length;
    6806 
    6807       predicate = getCallback(predicate, thisArg, 3);
    6808       while (++index < length) {
    6809         var value = array[index];
    6810         if (predicate(value, index, array)) {
    6811           result.push(value);
    6812           indexes.push(index);
    6813         }
    6814       }
    6815       basePullAt(array, indexes);
    6816       return result;
    6817     }
    6818 
    6819     /**
    6820      * Gets all but the first element of `array`.
    6821      *
    6822      * @static
    6823      * @memberOf _
    6824      * @alias tail
    6825      * @category Array
    6826      * @param {Array} array The array to query.
    6827      * @returns {Array} Returns the slice of `array`.
    6828      * @example
    6829      *
    6830      * _.rest([1, 2, 3]);
    6831      * // => [2, 3]
    6832      */
    6833     function rest(array) {
    6834       return drop(array, 1);
    6835     }
    6836 
    6837     /**
    6838      * Creates a slice of `array` from `start` up to, but not including, `end`.
    6839      *
    6840      * **Note:** This method is used instead of `Array#slice` to support node
    6841      * lists in IE < 9 and to ensure dense arrays are returned.
    6842      *
    6843      * @static
    6844      * @memberOf _
    6845      * @category Array
    6846      * @param {Array} array The array to slice.
    6847      * @param {number} [start=0] The start position.
    6848      * @param {number} [end=array.length] The end position.
    6849      * @returns {Array} Returns the slice of `array`.
    6850      */
    6851     function slice(array, start, end) {
    6852       var length = array ? array.length : 0;
    6853       if (!length) {
    6854         return [];
    6855       }
    6856       if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
    6857         start = 0;
    6858         end = length;
    6859       }
    6860       return baseSlice(array, start, end);
    6861     }
    6862 
    6863     /**
    6864      * Uses a binary search to determine the lowest index at which `value` should
    6865      * be inserted into `array` in order to maintain its sort order. If an iteratee
    6866      * function is provided it is invoked for `value` and each element of `array`
    6867      * to compute their sort ranking. The iteratee is bound to `thisArg` and
    6868      * invoked with one argument; (value).
    6869      *
    6870      * If a property name is provided for `iteratee` the created `_.property`
    6871      * style callback returns the property value of the given element.
    6872      *
    6873      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    6874      * style callback returns `true` for elements that have a matching property
    6875      * value, else `false`.
    6876      *
    6877      * If an object is provided for `iteratee` the created `_.matches` style
    6878      * callback returns `true` for elements that have the properties of the given
    6879      * object, else `false`.
    6880      *
    6881      * @static
    6882      * @memberOf _
    6883      * @category Array
    6884      * @param {Array} array The sorted array to inspect.
    6885      * @param {*} value The value to evaluate.
    6886      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    6887      *  per iteration.
    6888      * @param {*} [thisArg] The `this` binding of `iteratee`.
    6889      * @returns {number} Returns the index at which `value` should be inserted
    6890      *  into `array`.
    6891      * @example
    6892      *
    6893      * _.sortedIndex([30, 50], 40);
    6894      * // => 1
    6895      *
    6896      * _.sortedIndex([4, 4, 5, 5], 5);
    6897      * // => 2
    6898      *
    6899      * var dict = { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } };
    6900      *
    6901      * // using an iteratee function
    6902      * _.sortedIndex(['thirty', 'fifty'], 'forty', function(word) {
    6903      *   return this.data[word];
    6904      * }, dict);
    6905      * // => 1
    6906      *
    6907      * // using the `_.property` callback shorthand
    6908      * _.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
    6909      * // => 1
    6910      */
    6911     var sortedIndex = createSortedIndex();
    6912 
    6913     /**
    6914      * This method is like `_.sortedIndex` except that it returns the highest
    6915      * index at which `value` should be inserted into `array` in order to
    6916      * maintain its sort order.
    6917      *
    6918      * @static
    6919      * @memberOf _
    6920      * @category Array
    6921      * @param {Array} array The sorted array to inspect.
    6922      * @param {*} value The value to evaluate.
    6923      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    6924      *  per iteration.
    6925      * @param {*} [thisArg] The `this` binding of `iteratee`.
    6926      * @returns {number} Returns the index at which `value` should be inserted
    6927      *  into `array`.
    6928      * @example
    6929      *
    6930      * _.sortedLastIndex([4, 4, 5, 5], 5);
    6931      * // => 4
    6932      */
    6933     var sortedLastIndex = createSortedIndex(true);
    6934 
    6935     /**
    6936      * Creates a slice of `array` with `n` elements taken from the beginning.
    6937      *
    6938      * @static
    6939      * @memberOf _
    6940      * @category Array
    6941      * @param {Array} array The array to query.
    6942      * @param {number} [n=1] The number of elements to take.
    6943      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    6944      * @returns {Array} Returns the slice of `array`.
    6945      * @example
    6946      *
    6947      * _.take([1, 2, 3]);
    6948      * // => [1]
    6949      *
    6950      * _.take([1, 2, 3], 2);
    6951      * // => [1, 2]
    6952      *
    6953      * _.take([1, 2, 3], 5);
    6954      * // => [1, 2, 3]
    6955      *
    6956      * _.take([1, 2, 3], 0);
    6957      * // => []
    6958      */
    6959     function take(array, n, guard) {
    6960       var length = array ? array.length : 0;
    6961       if (!length) {
    6962         return [];
    6963       }
    6964       if (guard ? isIterateeCall(array, n, guard) : n == null) {
    6965         n = 1;
    6966       }
    6967       return baseSlice(array, 0, n < 0 ? 0 : n);
    6968     }
    6969 
    6970     /**
    6971      * Creates a slice of `array` with `n` elements taken from the end.
    6972      *
    6973      * @static
    6974      * @memberOf _
    6975      * @category Array
    6976      * @param {Array} array The array to query.
    6977      * @param {number} [n=1] The number of elements to take.
    6978      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    6979      * @returns {Array} Returns the slice of `array`.
    6980      * @example
    6981      *
    6982      * _.takeRight([1, 2, 3]);
    6983      * // => [3]
    6984      *
    6985      * _.takeRight([1, 2, 3], 2);
    6986      * // => [2, 3]
    6987      *
    6988      * _.takeRight([1, 2, 3], 5);
    6989      * // => [1, 2, 3]
    6990      *
    6991      * _.takeRight([1, 2, 3], 0);
    6992      * // => []
    6993      */
    6994     function takeRight(array, n, guard) {
    6995       var length = array ? array.length : 0;
    6996       if (!length) {
    6997         return [];
    6998       }
    6999       if (guard ? isIterateeCall(array, n, guard) : n == null) {
    7000         n = 1;
    7001       }
    7002       n = length - (+n || 0);
    7003       return baseSlice(array, n < 0 ? 0 : n);
    7004     }
    7005 
    7006     /**
    7007      * Creates a slice of `array` with elements taken from the end. Elements are
    7008      * taken until `predicate` returns falsey. The predicate is bound to `thisArg`
    7009      * and invoked with three arguments: (value, index, array).
    7010      *
    7011      * If a property name is provided for `predicate` the created `_.property`
    7012      * style callback returns the property value of the given element.
    7013      *
    7014      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7015      * style callback returns `true` for elements that have a matching property
    7016      * value, else `false`.
    7017      *
    7018      * If an object is provided for `predicate` the created `_.matches` style
    7019      * callback returns `true` for elements that have the properties of the given
    7020      * object, else `false`.
    7021      *
    7022      * @static
    7023      * @memberOf _
    7024      * @category Array
    7025      * @param {Array} array The array to query.
    7026      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    7027      *  per iteration.
    7028      * @param {*} [thisArg] The `this` binding of `predicate`.
    7029      * @returns {Array} Returns the slice of `array`.
    7030      * @example
    7031      *
    7032      * _.takeRightWhile([1, 2, 3], function(n) {
    7033      *   return n > 1;
    7034      * });
    7035      * // => [2, 3]
    7036      *
    7037      * var users = [
    7038      *   { 'user': 'barney',  'active': true },
    7039      *   { 'user': 'fred',    'active': false },
    7040      *   { 'user': 'pebbles', 'active': false }
    7041      * ];
    7042      *
    7043      * // using the `_.matches` callback shorthand
    7044      * _.pluck(_.takeRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user');
    7045      * // => ['pebbles']
    7046      *
    7047      * // using the `_.matchesProperty` callback shorthand
    7048      * _.pluck(_.takeRightWhile(users, 'active', false), 'user');
    7049      * // => ['fred', 'pebbles']
    7050      *
    7051      * // using the `_.property` callback shorthand
    7052      * _.pluck(_.takeRightWhile(users, 'active'), 'user');
    7053      * // => []
    7054      */
    7055     function takeRightWhile(array, predicate, thisArg) {
    7056       return (array && array.length)
    7057         ? baseWhile(array, getCallback(predicate, thisArg, 3), false, true)
    7058         : [];
    7059     }
    7060 
    7061     /**
    7062      * Creates a slice of `array` with elements taken from the beginning. Elements
    7063      * are taken until `predicate` returns falsey. The predicate is bound to
    7064      * `thisArg` and invoked with three arguments: (value, index, array).
    7065      *
    7066      * If a property name is provided for `predicate` the created `_.property`
    7067      * style callback returns the property value of the given element.
    7068      *
    7069      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7070      * style callback returns `true` for elements that have a matching property
    7071      * value, else `false`.
    7072      *
    7073      * If an object is provided for `predicate` the created `_.matches` style
    7074      * callback returns `true` for elements that have the properties of the given
    7075      * object, else `false`.
    7076      *
    7077      * @static
    7078      * @memberOf _
    7079      * @category Array
    7080      * @param {Array} array The array to query.
    7081      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    7082      *  per iteration.
    7083      * @param {*} [thisArg] The `this` binding of `predicate`.
    7084      * @returns {Array} Returns the slice of `array`.
    7085      * @example
    7086      *
    7087      * _.takeWhile([1, 2, 3], function(n) {
    7088      *   return n < 3;
    7089      * });
    7090      * // => [1, 2]
    7091      *
    7092      * var users = [
    7093      *   { 'user': 'barney',  'active': false },
    7094      *   { 'user': 'fred',    'active': false},
    7095      *   { 'user': 'pebbles', 'active': true }
    7096      * ];
    7097      *
    7098      * // using the `_.matches` callback shorthand
    7099      * _.pluck(_.takeWhile(users, { 'user': 'barney', 'active': false }), 'user');
    7100      * // => ['barney']
    7101      *
    7102      * // using the `_.matchesProperty` callback shorthand
    7103      * _.pluck(_.takeWhile(users, 'active', false), 'user');
    7104      * // => ['barney', 'fred']
    7105      *
    7106      * // using the `_.property` callback shorthand
    7107      * _.pluck(_.takeWhile(users, 'active'), 'user');
    7108      * // => []
    7109      */
    7110     function takeWhile(array, predicate, thisArg) {
    7111       return (array && array.length)
    7112         ? baseWhile(array, getCallback(predicate, thisArg, 3))
    7113         : [];
    7114     }
    7115 
    7116     /**
    7117      * Creates an array of unique values, in order, of the provided arrays using
    7118      * `SameValueZero` for equality comparisons.
    7119      *
    7120      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    7121      * comparisons are like strict equality comparisons, e.g. `===`, except that
    7122      * `NaN` matches `NaN`.
    7123      *
    7124      * @static
    7125      * @memberOf _
    7126      * @category Array
    7127      * @param {...Array} [arrays] The arrays to inspect.
    7128      * @returns {Array} Returns the new array of combined values.
    7129      * @example
    7130      *
    7131      * _.union([1, 2], [4, 2], [2, 1]);
    7132      * // => [1, 2, 4]
    7133      */
    7134     var union = restParam(function(arrays) {
    7135       return baseUniq(baseFlatten(arrays, false, true));
    7136     });
    7137 
    7138     /**
    7139      * Creates a duplicate-free version of an array, using `SameValueZero` for
    7140      * equality comparisons, in which only the first occurence of each element
    7141      * is kept. Providing `true` for `isSorted` performs a faster search algorithm
    7142      * for sorted arrays. If an iteratee function is provided it is invoked for
    7143      * each element in the array to generate the criterion by which uniqueness
    7144      * is computed. The `iteratee` is bound to `thisArg` and invoked with three
    7145      * arguments: (value, index, array).
    7146      *
    7147      * If a property name is provided for `iteratee` the created `_.property`
    7148      * style callback returns the property value of the given element.
    7149      *
    7150      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7151      * style callback returns `true` for elements that have a matching property
    7152      * value, else `false`.
    7153      *
    7154      * If an object is provided for `iteratee` the created `_.matches` style
    7155      * callback returns `true` for elements that have the properties of the given
    7156      * object, else `false`.
    7157      *
    7158      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    7159      * comparisons are like strict equality comparisons, e.g. `===`, except that
    7160      * `NaN` matches `NaN`.
    7161      *
    7162      * @static
    7163      * @memberOf _
    7164      * @alias unique
    7165      * @category Array
    7166      * @param {Array} array The array to inspect.
    7167      * @param {boolean} [isSorted] Specify the array is sorted.
    7168      * @param {Function|Object|string} [iteratee] The function invoked per iteration.
    7169      * @param {*} [thisArg] The `this` binding of `iteratee`.
    7170      * @returns {Array} Returns the new duplicate-value-free array.
    7171      * @example
    7172      *
    7173      * _.uniq([2, 1, 2]);
    7174      * // => [2, 1]
    7175      *
    7176      * // using `isSorted`
    7177      * _.uniq([1, 1, 2], true);
    7178      * // => [1, 2]
    7179      *
    7180      * // using an iteratee function
    7181      * _.uniq([1, 2.5, 1.5, 2], function(n) {
    7182      *   return this.floor(n);
    7183      * }, Math);
    7184      * // => [1, 2.5]
    7185      *
    7186      * // using the `_.property` callback shorthand
    7187      * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
    7188      * // => [{ 'x': 1 }, { 'x': 2 }]
    7189      */
    7190     function uniq(array, isSorted, iteratee, thisArg) {
    7191       var length = array ? array.length : 0;
    7192       if (!length) {
    7193         return [];
    7194       }
    7195       if (isSorted != null && typeof isSorted != 'boolean') {
    7196         thisArg = iteratee;
    7197         iteratee = isIterateeCall(array, isSorted, thisArg) ? null : isSorted;
    7198         isSorted = false;
    7199       }
    7200       var func = getCallback();
    7201       if (!(func === baseCallback && iteratee == null)) {
    7202         iteratee = func(iteratee, thisArg, 3);
    7203       }
    7204       return (isSorted && getIndexOf() == baseIndexOf)
    7205         ? sortedUniq(array, iteratee)
    7206         : baseUniq(array, iteratee);
    7207     }
    7208 
    7209     /**
    7210      * This method is like `_.zip` except that it accepts an array of grouped
    7211      * elements and creates an array regrouping the elements to their pre-`_.zip`
    7212      * configuration.
    7213      *
    7214      * @static
    7215      * @memberOf _
    7216      * @category Array
    7217      * @param {Array} array The array of grouped elements to process.
    7218      * @returns {Array} Returns the new array of regrouped elements.
    7219      * @example
    7220      *
    7221      * var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
    7222      * // => [['fred', 30, true], ['barney', 40, false]]
    7223      *
    7224      * _.unzip(zipped);
    7225      * // => [['fred', 'barney'], [30, 40], [true, false]]
    7226      */
    7227     function unzip(array) {
    7228       var index = -1,
    7229           length = (array && array.length && arrayMax(arrayMap(array, getLength))) >>> 0,
    7230           result = Array(length);
    7231 
    7232       while (++index < length) {
    7233         result[index] = arrayMap(array, baseProperty(index));
    7234       }
    7235       return result;
    7236     }
    7237 
    7238     /**
    7239      * Creates an array excluding all provided values using `SameValueZero` for
    7240      * equality comparisons.
    7241      *
    7242      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    7243      * comparisons are like strict equality comparisons, e.g. `===`, except that
    7244      * `NaN` matches `NaN`.
    7245      *
    7246      * @static
    7247      * @memberOf _
    7248      * @category Array
    7249      * @param {Array} array The array to filter.
    7250      * @param {...*} [values] The values to exclude.
    7251      * @returns {Array} Returns the new array of filtered values.
    7252      * @example
    7253      *
    7254      * _.without([1, 2, 1, 3], 1, 2);
    7255      * // => [3]
    7256      */
    7257     var without = restParam(function(array, values) {
    7258       return (isArray(array) || isArguments(array))
    7259         ? baseDifference(array, values)
    7260         : [];
    7261     });
    7262 
    7263     /**
    7264      * Creates an array that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
    7265      * of the provided arrays.
    7266      *
    7267      * @static
    7268      * @memberOf _
    7269      * @category Array
    7270      * @param {...Array} [arrays] The arrays to inspect.
    7271      * @returns {Array} Returns the new array of values.
    7272      * @example
    7273      *
    7274      * _.xor([1, 2], [4, 2]);
    7275      * // => [1, 4]
    7276      */
    7277     function xor() {
    7278       var index = -1,
    7279           length = arguments.length;
    7280 
    7281       while (++index < length) {
    7282         var array = arguments[index];
    7283         if (isArray(array) || isArguments(array)) {
    7284           var result = result
    7285             ? baseDifference(result, array).concat(baseDifference(array, result))
    7286             : array;
    7287         }
    7288       }
    7289       return result ? baseUniq(result) : [];
    7290     }
    7291 
    7292     /**
    7293      * Creates an array of grouped elements, the first of which contains the first
    7294      * elements of the given arrays, the second of which contains the second elements
    7295      * of the given arrays, and so on.
    7296      *
    7297      * @static
    7298      * @memberOf _
    7299      * @category Array
    7300      * @param {...Array} [arrays] The arrays to process.
    7301      * @returns {Array} Returns the new array of grouped elements.
    7302      * @example
    7303      *
    7304      * _.zip(['fred', 'barney'], [30, 40], [true, false]);
    7305      * // => [['fred', 30, true], ['barney', 40, false]]
    7306      */
    7307     var zip = restParam(unzip);
    7308 
    7309     /**
    7310      * The inverse of `_.pairs`; this method returns an object composed from arrays
    7311      * of property names and values. Provide either a single two dimensional array,
    7312      * e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names
    7313      * and one of corresponding values.
    7314      *
    7315      * @static
    7316      * @memberOf _
    7317      * @alias object
    7318      * @category Array
    7319      * @param {Array} props The property names.
    7320      * @param {Array} [values=[]] The property values.
    7321      * @returns {Object} Returns the new object.
    7322      * @example
    7323      *
    7324      * _.zipObject([['fred', 30], ['barney', 40]]);
    7325      * // => { 'fred': 30, 'barney': 40 }
    7326      *
    7327      * _.zipObject(['fred', 'barney'], [30, 40]);
    7328      * // => { 'fred': 30, 'barney': 40 }
    7329      */
    7330     function zipObject(props, values) {
    7331       var index = -1,
    7332           length = props ? props.length : 0,
    7333           result = {};
    7334 
    7335       if (length && !values && !isArray(props[0])) {
    7336         values = [];
    7337       }
    7338       while (++index < length) {
    7339         var key = props[index];
    7340         if (values) {
    7341           result[key] = values[index];
    7342         } else if (key) {
    7343           result[key[0]] = key[1];
    7344         }
    7345       }
    7346       return result;
    7347     }
    7348 
    7349     /*------------------------------------------------------------------------*/
    7350 
    7351     /**
    7352      * Creates a `lodash` object that wraps `value` with explicit method
    7353      * chaining enabled.
    7354      *
    7355      * @static
    7356      * @memberOf _
    7357      * @category Chain
    7358      * @param {*} value The value to wrap.
    7359      * @returns {Object} Returns the new `lodash` wrapper instance.
    7360      * @example
    7361      *
    7362      * var users = [
    7363      *   { 'user': 'barney',  'age': 36 },
    7364      *   { 'user': 'fred',    'age': 40 },
    7365      *   { 'user': 'pebbles', 'age': 1 }
    7366      * ];
    7367      *
    7368      * var youngest = _.chain(users)
    7369      *   .sortBy('age')
    7370      *   .map(function(chr) {
    7371      *     return chr.user + ' is ' + chr.age;
    7372      *   })
    7373      *   .first()
    7374      *   .value();
    7375      * // => 'pebbles is 1'
    7376      */
    7377     function chain(value) {
    7378       var result = lodash(value);
    7379       result.__chain__ = true;
    7380       return result;
    7381     }
    7382 
    7383     /**
    7384      * This method invokes `interceptor` and returns `value`. The interceptor is
    7385      * bound to `thisArg` and invoked with one argument; (value). The purpose of
    7386      * this method is to "tap into" a method chain in order to perform operations
    7387      * on intermediate results within the chain.
    7388      *
    7389      * @static
    7390      * @memberOf _
    7391      * @category Chain
    7392      * @param {*} value The value to provide to `interceptor`.
    7393      * @param {Function} interceptor The function to invoke.
    7394      * @param {*} [thisArg] The `this` binding of `interceptor`.
    7395      * @returns {*} Returns `value`.
    7396      * @example
    7397      *
    7398      * _([1, 2, 3])
    7399      *  .tap(function(array) {
    7400      *    array.pop();
    7401      *  })
    7402      *  .reverse()
    7403      *  .value();
    7404      * // => [2, 1]
    7405      */
    7406     function tap(value, interceptor, thisArg) {
    7407       interceptor.call(thisArg, value);
    7408       return value;
    7409     }
    7410 
    7411     /**
    7412      * This method is like `_.tap` except that it returns the result of `interceptor`.
    7413      *
    7414      * @static
    7415      * @memberOf _
    7416      * @category Chain
    7417      * @param {*} value The value to provide to `interceptor`.
    7418      * @param {Function} interceptor The function to invoke.
    7419      * @param {*} [thisArg] The `this` binding of `interceptor`.
    7420      * @returns {*} Returns the result of `interceptor`.
    7421      * @example
    7422      *
    7423      * _('  abc  ')
    7424      *  .chain()
    7425      *  .trim()
    7426      *  .thru(function(value) {
    7427      *    return [value];
    7428      *  })
    7429      *  .value();
    7430      * // => ['abc']
    7431      */
    7432     function thru(value, interceptor, thisArg) {
    7433       return interceptor.call(thisArg, value);
    7434     }
    7435 
    7436     /**
    7437      * Enables explicit method chaining on the wrapper object.
    7438      *
    7439      * @name chain
    7440      * @memberOf _
    7441      * @category Chain
    7442      * @returns {Object} Returns the new `lodash` wrapper instance.
    7443      * @example
    7444      *
    7445      * var users = [
    7446      *   { 'user': 'barney', 'age': 36 },
    7447      *   { 'user': 'fred',   'age': 40 }
    7448      * ];
    7449      *
    7450      * // without explicit chaining
    7451      * _(users).first();
    7452      * // => { 'user': 'barney', 'age': 36 }
    7453      *
    7454      * // with explicit chaining
    7455      * _(users).chain()
    7456      *   .first()
    7457      *   .pick('user')
    7458      *   .value();
    7459      * // => { 'user': 'barney' }
    7460      */
    7461     function wrapperChain() {
    7462       return chain(this);
    7463     }
    7464 
    7465     /**
    7466      * Executes the chained sequence and returns the wrapped result.
    7467      *
    7468      * @name commit
    7469      * @memberOf _
    7470      * @category Chain
    7471      * @returns {Object} Returns the new `lodash` wrapper instance.
    7472      * @example
    7473      *
    7474      * var array = [1, 2];
    7475      * var wrapper = _(array).push(3);
    7476      *
    7477      * console.log(array);
    7478      * // => [1, 2]
    7479      *
    7480      * wrapper = wrapper.commit();
    7481      * console.log(array);
    7482      * // => [1, 2, 3]
    7483      *
    7484      * wrapper.last();
    7485      * // => 3
    7486      *
    7487      * console.log(array);
    7488      * // => [1, 2, 3]
    7489      */
    7490     function wrapperCommit() {
    7491       return new LodashWrapper(this.value(), this.__chain__);
    7492     }
    7493 
    7494     /**
    7495      * Creates a clone of the chained sequence planting `value` as the wrapped value.
    7496      *
    7497      * @name plant
    7498      * @memberOf _
    7499      * @category Chain
    7500      * @returns {Object} Returns the new `lodash` wrapper instance.
    7501      * @example
    7502      *
    7503      * var array = [1, 2];
    7504      * var wrapper = _(array).map(function(value) {
    7505      *   return Math.pow(value, 2);
    7506      * });
    7507      *
    7508      * var other = [3, 4];
    7509      * var otherWrapper = wrapper.plant(other);
    7510      *
    7511      * otherWrapper.value();
    7512      * // => [9, 16]
    7513      *
    7514      * wrapper.value();
    7515      * // => [1, 4]
    7516      */
    7517     function wrapperPlant(value) {
    7518       var result,
    7519           parent = this;
    7520 
    7521       while (parent instanceof baseLodash) {
    7522         var clone = wrapperClone(parent);
    7523         if (result) {
    7524           previous.__wrapped__ = clone;
    7525         } else {
    7526           result = clone;
    7527         }
    7528         var previous = clone;
    7529         parent = parent.__wrapped__;
    7530       }
    7531       previous.__wrapped__ = value;
    7532       return result;
    7533     }
    7534 
    7535     /**
    7536      * Reverses the wrapped array so the first element becomes the last, the
    7537      * second element becomes the second to last, and so on.
    7538      *
    7539      * **Note:** This method mutates the wrapped array.
    7540      *
    7541      * @name reverse
    7542      * @memberOf _
    7543      * @category Chain
    7544      * @returns {Object} Returns the new reversed `lodash` wrapper instance.
    7545      * @example
    7546      *
    7547      * var array = [1, 2, 3];
    7548      *
    7549      * _(array).reverse().value()
    7550      * // => [3, 2, 1]
    7551      *
    7552      * console.log(array);
    7553      * // => [3, 2, 1]
    7554      */
    7555     function wrapperReverse() {
    7556       var value = this.__wrapped__;
    7557       if (value instanceof LazyWrapper) {
    7558         if (this.__actions__.length) {
    7559           value = new LazyWrapper(this);
    7560         }
    7561         return new LodashWrapper(value.reverse(), this.__chain__);
    7562       }
    7563       return this.thru(function(value) {
    7564         return value.reverse();
    7565       });
    7566     }
    7567 
    7568     /**
    7569      * Produces the result of coercing the unwrapped value to a string.
    7570      *
    7571      * @name toString
    7572      * @memberOf _
    7573      * @category Chain
    7574      * @returns {string} Returns the coerced string value.
    7575      * @example
    7576      *
    7577      * _([1, 2, 3]).toString();
    7578      * // => '1,2,3'
    7579      */
    7580     function wrapperToString() {
    7581       return (this.value() + '');
    7582     }
    7583 
    7584     /**
    7585      * Executes the chained sequence to extract the unwrapped value.
    7586      *
    7587      * @name value
    7588      * @memberOf _
    7589      * @alias run, toJSON, valueOf
    7590      * @category Chain
    7591      * @returns {*} Returns the resolved unwrapped value.
    7592      * @example
    7593      *
    7594      * _([1, 2, 3]).value();
    7595      * // => [1, 2, 3]
    7596      */
    7597     function wrapperValue() {
    7598       return baseWrapperValue(this.__wrapped__, this.__actions__);
    7599     }
    7600 
    7601     /*------------------------------------------------------------------------*/
    7602 
    7603     /**
    7604      * Creates an array of elements corresponding to the given keys, or indexes,
    7605      * of `collection`. Keys may be specified as individual arguments or as arrays
    7606      * of keys.
    7607      *
    7608      * @static
    7609      * @memberOf _
    7610      * @category Collection
    7611      * @param {Array|Object|string} collection The collection to iterate over.
    7612      * @param {...(number|number[]|string|string[])} [props] The property names
    7613      *  or indexes of elements to pick, specified individually or in arrays.
    7614      * @returns {Array} Returns the new array of picked elements.
    7615      * @example
    7616      *
    7617      * _.at(['a', 'b', 'c'], [0, 2]);
    7618      * // => ['a', 'c']
    7619      *
    7620      * _.at(['barney', 'fred', 'pebbles'], 0, 2);
    7621      * // => ['barney', 'pebbles']
    7622      */
    7623     var at = restParam(function(collection, props) {
    7624       var length = collection ? getLength(collection) : 0;
    7625       if (isLength(length)) {
    7626         collection = toIterable(collection);
    7627       }
    7628       return baseAt(collection, baseFlatten(props));
    7629     });
    7630 
    7631     /**
    7632      * Creates an object composed of keys generated from the results of running
    7633      * each element of `collection` through `iteratee`. The corresponding value
    7634      * of each key is the number of times the key was returned by `iteratee`.
    7635      * The `iteratee` is bound to `thisArg` and invoked with three arguments:
    7636      * (value, index|key, collection).
    7637      *
    7638      * If a property name is provided for `iteratee` the created `_.property`
    7639      * style callback returns the property value of the given element.
    7640      *
    7641      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7642      * style callback returns `true` for elements that have a matching property
    7643      * value, else `false`.
    7644      *
    7645      * If an object is provided for `iteratee` the created `_.matches` style
    7646      * callback returns `true` for elements that have the properties of the given
    7647      * object, else `false`.
    7648      *
    7649      * @static
    7650      * @memberOf _
    7651      * @category Collection
    7652      * @param {Array|Object|string} collection The collection to iterate over.
    7653      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    7654      *  per iteration.
    7655      * @param {*} [thisArg] The `this` binding of `iteratee`.
    7656      * @returns {Object} Returns the composed aggregate object.
    7657      * @example
    7658      *
    7659      * _.countBy([4.3, 6.1, 6.4], function(n) {
    7660      *   return Math.floor(n);
    7661      * });
    7662      * // => { '4': 1, '6': 2 }
    7663      *
    7664      * _.countBy([4.3, 6.1, 6.4], function(n) {
    7665      *   return this.floor(n);
    7666      * }, Math);
    7667      * // => { '4': 1, '6': 2 }
    7668      *
    7669      * _.countBy(['one', 'two', 'three'], 'length');
    7670      * // => { '3': 2, '5': 1 }
    7671      */
    7672     var countBy = createAggregator(function(result, value, key) {
    7673       hasOwnProperty.call(result, key) ? ++result[key] : (result[key] = 1);
    7674     });
    7675 
    7676     /**
    7677      * Checks if `predicate` returns truthy for **all** elements of `collection`.
    7678      * The predicate is bound to `thisArg` and invoked with three arguments:
    7679      * (value, index|key, collection).
    7680      *
    7681      * If a property name is provided for `predicate` the created `_.property`
    7682      * style callback returns the property value of the given element.
    7683      *
    7684      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7685      * style callback returns `true` for elements that have a matching property
    7686      * value, else `false`.
    7687      *
    7688      * If an object is provided for `predicate` the created `_.matches` style
    7689      * callback returns `true` for elements that have the properties of the given
    7690      * object, else `false`.
    7691      *
    7692      * @static
    7693      * @memberOf _
    7694      * @alias all
    7695      * @category Collection
    7696      * @param {Array|Object|string} collection The collection to iterate over.
    7697      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    7698      *  per iteration.
    7699      * @param {*} [thisArg] The `this` binding of `predicate`.
    7700      * @returns {boolean} Returns `true` if all elements pass the predicate check,
    7701      *  else `false`.
    7702      * @example
    7703      *
    7704      * _.every([true, 1, null, 'yes'], Boolean);
    7705      * // => false
    7706      *
    7707      * var users = [
    7708      *   { 'user': 'barney', 'active': false },
    7709      *   { 'user': 'fred',   'active': false }
    7710      * ];
    7711      *
    7712      * // using the `_.matches` callback shorthand
    7713      * _.every(users, { 'user': 'barney', 'active': false });
    7714      * // => false
    7715      *
    7716      * // using the `_.matchesProperty` callback shorthand
    7717      * _.every(users, 'active', false);
    7718      * // => true
    7719      *
    7720      * // using the `_.property` callback shorthand
    7721      * _.every(users, 'active');
    7722      * // => false
    7723      */
    7724     function every(collection, predicate, thisArg) {
    7725       var func = isArray(collection) ? arrayEvery : baseEvery;
    7726       if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
    7727         predicate = null;
    7728       }
    7729       if (typeof predicate != 'function' || thisArg !== undefined) {
    7730         predicate = getCallback(predicate, thisArg, 3);
    7731       }
    7732       return func(collection, predicate);
    7733     }
    7734 
    7735     /**
    7736      * Iterates over elements of `collection`, returning an array of all elements
    7737      * `predicate` returns truthy for. The predicate is bound to `thisArg` and
    7738      * invoked with three arguments: (value, index|key, collection).
    7739      *
    7740      * If a property name is provided for `predicate` the created `_.property`
    7741      * style callback returns the property value of the given element.
    7742      *
    7743      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7744      * style callback returns `true` for elements that have a matching property
    7745      * value, else `false`.
    7746      *
    7747      * If an object is provided for `predicate` the created `_.matches` style
    7748      * callback returns `true` for elements that have the properties of the given
    7749      * object, else `false`.
    7750      *
    7751      * @static
    7752      * @memberOf _
    7753      * @alias select
    7754      * @category Collection
    7755      * @param {Array|Object|string} collection The collection to iterate over.
    7756      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    7757      *  per iteration.
    7758      * @param {*} [thisArg] The `this` binding of `predicate`.
    7759      * @returns {Array} Returns the new filtered array.
    7760      * @example
    7761      *
    7762      * _.filter([4, 5, 6], function(n) {
    7763      *   return n % 2 == 0;
    7764      * });
    7765      * // => [4, 6]
    7766      *
    7767      * var users = [
    7768      *   { 'user': 'barney', 'age': 36, 'active': true },
    7769      *   { 'user': 'fred',   'age': 40, 'active': false }
    7770      * ];
    7771      *
    7772      * // using the `_.matches` callback shorthand
    7773      * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');
    7774      * // => ['barney']
    7775      *
    7776      * // using the `_.matchesProperty` callback shorthand
    7777      * _.pluck(_.filter(users, 'active', false), 'user');
    7778      * // => ['fred']
    7779      *
    7780      * // using the `_.property` callback shorthand
    7781      * _.pluck(_.filter(users, 'active'), 'user');
    7782      * // => ['barney']
    7783      */
    7784     function filter(collection, predicate, thisArg) {
    7785       var func = isArray(collection) ? arrayFilter : baseFilter;
    7786       predicate = getCallback(predicate, thisArg, 3);
    7787       return func(collection, predicate);
    7788     }
    7789 
    7790     /**
    7791      * Iterates over elements of `collection`, returning the first element
    7792      * `predicate` returns truthy for. The predicate is bound to `thisArg` and
    7793      * invoked with three arguments: (value, index|key, collection).
    7794      *
    7795      * If a property name is provided for `predicate` the created `_.property`
    7796      * style callback returns the property value of the given element.
    7797      *
    7798      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7799      * style callback returns `true` for elements that have a matching property
    7800      * value, else `false`.
    7801      *
    7802      * If an object is provided for `predicate` the created `_.matches` style
    7803      * callback returns `true` for elements that have the properties of the given
    7804      * object, else `false`.
    7805      *
    7806      * @static
    7807      * @memberOf _
    7808      * @alias detect
    7809      * @category Collection
    7810      * @param {Array|Object|string} collection The collection to search.
    7811      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    7812      *  per iteration.
    7813      * @param {*} [thisArg] The `this` binding of `predicate`.
    7814      * @returns {*} Returns the matched element, else `undefined`.
    7815      * @example
    7816      *
    7817      * var users = [
    7818      *   { 'user': 'barney',  'age': 36, 'active': true },
    7819      *   { 'user': 'fred',    'age': 40, 'active': false },
    7820      *   { 'user': 'pebbles', 'age': 1,  'active': true }
    7821      * ];
    7822      *
    7823      * _.result(_.find(users, function(chr) {
    7824      *   return chr.age < 40;
    7825      * }), 'user');
    7826      * // => 'barney'
    7827      *
    7828      * // using the `_.matches` callback shorthand
    7829      * _.result(_.find(users, { 'age': 1, 'active': true }), 'user');
    7830      * // => 'pebbles'
    7831      *
    7832      * // using the `_.matchesProperty` callback shorthand
    7833      * _.result(_.find(users, 'active', false), 'user');
    7834      * // => 'fred'
    7835      *
    7836      * // using the `_.property` callback shorthand
    7837      * _.result(_.find(users, 'active'), 'user');
    7838      * // => 'barney'
    7839      */
    7840     var find = createFind(baseEach);
    7841 
    7842     /**
    7843      * This method is like `_.find` except that it iterates over elements of
    7844      * `collection` from right to left.
    7845      *
    7846      * @static
    7847      * @memberOf _
    7848      * @category Collection
    7849      * @param {Array|Object|string} collection The collection to search.
    7850      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    7851      *  per iteration.
    7852      * @param {*} [thisArg] The `this` binding of `predicate`.
    7853      * @returns {*} Returns the matched element, else `undefined`.
    7854      * @example
    7855      *
    7856      * _.findLast([1, 2, 3, 4], function(n) {
    7857      *   return n % 2 == 1;
    7858      * });
    7859      * // => 3
    7860      */
    7861     var findLast = createFind(baseEachRight, true);
    7862 
    7863     /**
    7864      * Performs a deep comparison between each element in `collection` and the
    7865      * source object, returning the first element that has equivalent property
    7866      * values.
    7867      *
    7868      * **Note:** This method supports comparing arrays, booleans, `Date` objects,
    7869      * numbers, `Object` objects, regexes, and strings. Objects are compared by
    7870      * their own, not inherited, enumerable properties. For comparing a single
    7871      * own or inherited property value see `_.matchesProperty`.
    7872      *
    7873      * @static
    7874      * @memberOf _
    7875      * @category Collection
    7876      * @param {Array|Object|string} collection The collection to search.
    7877      * @param {Object} source The object of property values to match.
    7878      * @returns {*} Returns the matched element, else `undefined`.
    7879      * @example
    7880      *
    7881      * var users = [
    7882      *   { 'user': 'barney', 'age': 36, 'active': true },
    7883      *   { 'user': 'fred',   'age': 40, 'active': false }
    7884      * ];
    7885      *
    7886      * _.result(_.findWhere(users, { 'age': 36, 'active': true }), 'user');
    7887      * // => 'barney'
    7888      *
    7889      * _.result(_.findWhere(users, { 'age': 40, 'active': false }), 'user');
    7890      * // => 'fred'
    7891      */
    7892     function findWhere(collection, source) {
    7893       return find(collection, baseMatches(source));
    7894     }
    7895 
    7896     /**
    7897      * Iterates over elements of `collection` invoking `iteratee` for each element.
    7898      * The `iteratee` is bound to `thisArg` and invoked with three arguments:
    7899      * (value, index|key, collection). Iteratee functions may exit iteration early
    7900      * by explicitly returning `false`.
    7901      *
    7902      * **Note:** As with other "Collections" methods, objects with a "length" property
    7903      * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`
    7904      * may be used for object iteration.
    7905      *
    7906      * @static
    7907      * @memberOf _
    7908      * @alias each
    7909      * @category Collection
    7910      * @param {Array|Object|string} collection The collection to iterate over.
    7911      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    7912      * @param {*} [thisArg] The `this` binding of `iteratee`.
    7913      * @returns {Array|Object|string} Returns `collection`.
    7914      * @example
    7915      *
    7916      * _([1, 2]).forEach(function(n) {
    7917      *   console.log(n);
    7918      * }).value();
    7919      * // => logs each value from left to right and returns the array
    7920      *
    7921      * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {
    7922      *   console.log(n, key);
    7923      * });
    7924      * // => logs each value-key pair and returns the object (iteration order is not guaranteed)
    7925      */
    7926     var forEach = createForEach(arrayEach, baseEach);
    7927 
    7928     /**
    7929      * This method is like `_.forEach` except that it iterates over elements of
    7930      * `collection` from right to left.
    7931      *
    7932      * @static
    7933      * @memberOf _
    7934      * @alias eachRight
    7935      * @category Collection
    7936      * @param {Array|Object|string} collection The collection to iterate over.
    7937      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    7938      * @param {*} [thisArg] The `this` binding of `iteratee`.
    7939      * @returns {Array|Object|string} Returns `collection`.
    7940      * @example
    7941      *
    7942      * _([1, 2]).forEachRight(function(n) {
    7943      *   console.log(n);
    7944      * }).value();
    7945      * // => logs each value from right to left and returns the array
    7946      */
    7947     var forEachRight = createForEach(arrayEachRight, baseEachRight);
    7948 
    7949     /**
    7950      * Creates an object composed of keys generated from the results of running
    7951      * each element of `collection` through `iteratee`. The corresponding value
    7952      * of each key is an array of the elements responsible for generating the key.
    7953      * The `iteratee` is bound to `thisArg` and invoked with three arguments:
    7954      * (value, index|key, collection).
    7955      *
    7956      * If a property name is provided for `iteratee` the created `_.property`
    7957      * style callback returns the property value of the given element.
    7958      *
    7959      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    7960      * style callback returns `true` for elements that have a matching property
    7961      * value, else `false`.
    7962      *
    7963      * If an object is provided for `iteratee` the created `_.matches` style
    7964      * callback returns `true` for elements that have the properties of the given
    7965      * object, else `false`.
    7966      *
    7967      * @static
    7968      * @memberOf _
    7969      * @category Collection
    7970      * @param {Array|Object|string} collection The collection to iterate over.
    7971      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    7972      *  per iteration.
    7973      * @param {*} [thisArg] The `this` binding of `iteratee`.
    7974      * @returns {Object} Returns the composed aggregate object.
    7975      * @example
    7976      *
    7977      * _.groupBy([4.2, 6.1, 6.4], function(n) {
    7978      *   return Math.floor(n);
    7979      * });
    7980      * // => { '4': [4.2], '6': [6.1, 6.4] }
    7981      *
    7982      * _.groupBy([4.2, 6.1, 6.4], function(n) {
    7983      *   return this.floor(n);
    7984      * }, Math);
    7985      * // => { '4': [4.2], '6': [6.1, 6.4] }
    7986      *
    7987      * // using the `_.property` callback shorthand
    7988      * _.groupBy(['one', 'two', 'three'], 'length');
    7989      * // => { '3': ['one', 'two'], '5': ['three'] }
    7990      */
    7991     var groupBy = createAggregator(function(result, value, key) {
    7992       if (hasOwnProperty.call(result, key)) {
    7993         result[key].push(value);
    7994       } else {
    7995         result[key] = [value];
    7996       }
    7997     });
    7998 
    7999     /**
    8000      * Checks if `value` is in `collection` using `SameValueZero` for equality
    8001      * comparisons. If `fromIndex` is negative, it is used as the offset from
    8002      * the end of `collection`.
    8003      *
    8004      * **Note:** [`SameValueZero`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero)
    8005      * comparisons are like strict equality comparisons, e.g. `===`, except that
    8006      * `NaN` matches `NaN`.
    8007      *
    8008      * @static
    8009      * @memberOf _
    8010      * @alias contains, include
    8011      * @category Collection
    8012      * @param {Array|Object|string} collection The collection to search.
    8013      * @param {*} target The value to search for.
    8014      * @param {number} [fromIndex=0] The index to search from.
    8015      * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`.
    8016      * @returns {boolean} Returns `true` if a matching element is found, else `false`.
    8017      * @example
    8018      *
    8019      * _.includes([1, 2, 3], 1);
    8020      * // => true
    8021      *
    8022      * _.includes([1, 2, 3], 1, 2);
    8023      * // => false
    8024      *
    8025      * _.includes({ 'user': 'fred', 'age': 40 }, 'fred');
    8026      * // => true
    8027      *
    8028      * _.includes('pebbles', 'eb');
    8029      * // => true
    8030      */
    8031     function includes(collection, target, fromIndex, guard) {
    8032       var length = collection ? getLength(collection) : 0;
    8033       if (!isLength(length)) {
    8034         collection = values(collection);
    8035         length = collection.length;
    8036       }
    8037       if (!length) {
    8038         return false;
    8039       }
    8040       if (typeof fromIndex != 'number' || (guard && isIterateeCall(target, fromIndex, guard))) {
    8041         fromIndex = 0;
    8042       } else {
    8043         fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0);
    8044       }
    8045       return (typeof collection == 'string' || !isArray(collection) && isString(collection))
    8046         ? (fromIndex < length && collection.indexOf(target, fromIndex) > -1)
    8047         : (getIndexOf(collection, target, fromIndex) > -1);
    8048     }
    8049 
    8050     /**
    8051      * Creates an object composed of keys generated from the results of running
    8052      * each element of `collection` through `iteratee`. The corresponding value
    8053      * of each key is the last element responsible for generating the key. The
    8054      * iteratee function is bound to `thisArg` and invoked with three arguments:
    8055      * (value, index|key, collection).
    8056      *
    8057      * If a property name is provided for `iteratee` the created `_.property`
    8058      * style callback returns the property value of the given element.
    8059      *
    8060      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    8061      * style callback returns `true` for elements that have a matching property
    8062      * value, else `false`.
    8063      *
    8064      * If an object is provided for `iteratee` the created `_.matches` style
    8065      * callback returns `true` for elements that have the properties of the given
    8066      * object, else `false`.
    8067      *
    8068      * @static
    8069      * @memberOf _
    8070      * @category Collection
    8071      * @param {Array|Object|string} collection The collection to iterate over.
    8072      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    8073      *  per iteration.
    8074      * @param {*} [thisArg] The `this` binding of `iteratee`.
    8075      * @returns {Object} Returns the composed aggregate object.
    8076      * @example
    8077      *
    8078      * var keyData = [
    8079      *   { 'dir': 'left', 'code': 97 },
    8080      *   { 'dir': 'right', 'code': 100 }
    8081      * ];
    8082      *
    8083      * _.indexBy(keyData, 'dir');
    8084      * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
    8085      *
    8086      * _.indexBy(keyData, function(object) {
    8087      *   return String.fromCharCode(object.code);
    8088      * });
    8089      * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
    8090      *
    8091      * _.indexBy(keyData, function(object) {
    8092      *   return this.fromCharCode(object.code);
    8093      * }, String);
    8094      * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
    8095      */
    8096     var indexBy = createAggregator(function(result, value, key) {
    8097       result[key] = value;
    8098     });
    8099 
    8100     /**
    8101      * Invokes the method at `path` on each element in `collection`, returning
    8102      * an array of the results of each invoked method. Any additional arguments
    8103      * are provided to each invoked method. If `methodName` is a function it is
    8104      * invoked for, and `this` bound to, each element in `collection`.
    8105      *
    8106      * @static
    8107      * @memberOf _
    8108      * @category Collection
    8109      * @param {Array|Object|string} collection The collection to iterate over.
    8110      * @param {Array|Function|string} path The path of the method to invoke or
    8111      *  the function invoked per iteration.
    8112      * @param {...*} [args] The arguments to invoke the method with.
    8113      * @returns {Array} Returns the array of results.
    8114      * @example
    8115      *
    8116      * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
    8117      * // => [[1, 5, 7], [1, 2, 3]]
    8118      *
    8119      * _.invoke([123, 456], String.prototype.split, '');
    8120      * // => [['1', '2', '3'], ['4', '5', '6']]
    8121      */
    8122     var invoke = restParam(function(collection, path, args) {
    8123       var index = -1,
    8124           isFunc = typeof path == 'function',
    8125           isProp = isKey(path),
    8126           length = getLength(collection),
    8127           result = isLength(length) ? Array(length) : [];
    8128 
    8129       baseEach(collection, function(value) {
    8130         var func = isFunc ? path : (isProp && value != null && value[path]);
    8131         result[++index] = func ? func.apply(value, args) : invokePath(value, path, args);
    8132       });
    8133       return result;
    8134     });
    8135 
    8136     /**
    8137      * Creates an array of values by running each element in `collection` through
    8138      * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three
    8139      * arguments: (value, index|key, collection).
    8140      *
    8141      * If a property name is provided for `iteratee` the created `_.property`
    8142      * style callback returns the property value of the given element.
    8143      *
    8144      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    8145      * style callback returns `true` for elements that have a matching property
    8146      * value, else `false`.
    8147      *
    8148      * If an object is provided for `iteratee` the created `_.matches` style
    8149      * callback returns `true` for elements that have the properties of the given
    8150      * object, else `false`.
    8151      *
    8152      * Many lodash methods are guarded to work as interatees for methods like
    8153      * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
    8154      *
    8155      * The guarded methods are:
    8156      * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`, `drop`,
    8157      * `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`, `parseInt`,
    8158      * `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`, `trimLeft`,
    8159      * `trimRight`, `trunc`, `random`, `range`, `sample`, `some`, `uniq`, and `words`
    8160      *
    8161      * @static
    8162      * @memberOf _
    8163      * @alias collect
    8164      * @category Collection
    8165      * @param {Array|Object|string} collection The collection to iterate over.
    8166      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    8167      *  per iteration.
    8168      * @param {*} [thisArg] The `this` binding of `iteratee`.
    8169      * @returns {Array} Returns the new mapped array.
    8170      * @example
    8171      *
    8172      * function timesThree(n) {
    8173      *   return n * 3;
    8174      * }
    8175      *
    8176      * _.map([1, 2], timesThree);
    8177      * // => [3, 6]
    8178      *
    8179      * _.map({ 'a': 1, 'b': 2 }, timesThree);
    8180      * // => [3, 6] (iteration order is not guaranteed)
    8181      *
    8182      * var users = [
    8183      *   { 'user': 'barney' },
    8184      *   { 'user': 'fred' }
    8185      * ];
    8186      *
    8187      * // using the `_.property` callback shorthand
    8188      * _.map(users, 'user');
    8189      * // => ['barney', 'fred']
    8190      */
    8191     function map(collection, iteratee, thisArg) {
    8192       var func = isArray(collection) ? arrayMap : baseMap;
    8193       iteratee = getCallback(iteratee, thisArg, 3);
    8194       return func(collection, iteratee);
    8195     }
    8196 
    8197     /**
    8198      * Creates an array of elements split into two groups, the first of which
    8199      * contains elements `predicate` returns truthy for, while the second of which
    8200      * contains elements `predicate` returns falsey for. The predicate is bound
    8201      * to `thisArg` and invoked with three arguments: (value, index|key, collection).
    8202      *
    8203      * If a property name is provided for `predicate` the created `_.property`
    8204      * style callback returns the property value of the given element.
    8205      *
    8206      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    8207      * style callback returns `true` for elements that have a matching property
    8208      * value, else `false`.
    8209      *
    8210      * If an object is provided for `predicate` the created `_.matches` style
    8211      * callback returns `true` for elements that have the properties of the given
    8212      * object, else `false`.
    8213      *
    8214      * @static
    8215      * @memberOf _
    8216      * @category Collection
    8217      * @param {Array|Object|string} collection The collection to iterate over.
    8218      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    8219      *  per iteration.
    8220      * @param {*} [thisArg] The `this` binding of `predicate`.
    8221      * @returns {Array} Returns the array of grouped elements.
    8222      * @example
    8223      *
    8224      * _.partition([1, 2, 3], function(n) {
    8225      *   return n % 2;
    8226      * });
    8227      * // => [[1, 3], [2]]
    8228      *
    8229      * _.partition([1.2, 2.3, 3.4], function(n) {
    8230      *   return this.floor(n) % 2;
    8231      * }, Math);
    8232      * // => [[1.2, 3.4], [2.3]]
    8233      *
    8234      * var users = [
    8235      *   { 'user': 'barney',  'age': 36, 'active': false },
    8236      *   { 'user': 'fred',    'age': 40, 'active': true },
    8237      *   { 'user': 'pebbles', 'age': 1,  'active': false }
    8238      * ];
    8239      *
    8240      * var mapper = function(array) {
    8241      *   return _.pluck(array, 'user');
    8242      * };
    8243      *
    8244      * // using the `_.matches` callback shorthand
    8245      * _.map(_.partition(users, { 'age': 1, 'active': false }), mapper);
    8246      * // => [['pebbles'], ['barney', 'fred']]
    8247      *
    8248      * // using the `_.matchesProperty` callback shorthand
    8249      * _.map(_.partition(users, 'active', false), mapper);
    8250      * // => [['barney', 'pebbles'], ['fred']]
    8251      *
    8252      * // using the `_.property` callback shorthand
    8253      * _.map(_.partition(users, 'active'), mapper);
    8254      * // => [['fred'], ['barney', 'pebbles']]
    8255      */
    8256     var partition = createAggregator(function(result, value, key) {
    8257       result[key ? 0 : 1].push(value);
    8258     }, function() { return [[], []]; });
    8259 
    8260     /**
    8261      * Gets the property value of `path` from all elements in `collection`.
    8262      *
    8263      * @static
    8264      * @memberOf _
    8265      * @category Collection
    8266      * @param {Array|Object|string} collection The collection to iterate over.
    8267      * @param {Array|string} path The path of the property to pluck.
    8268      * @returns {Array} Returns the property values.
    8269      * @example
    8270      *
    8271      * var users = [
    8272      *   { 'user': 'barney', 'age': 36 },
    8273      *   { 'user': 'fred',   'age': 40 }
    8274      * ];
    8275      *
    8276      * _.pluck(users, 'user');
    8277      * // => ['barney', 'fred']
    8278      *
    8279      * var userIndex = _.indexBy(users, 'user');
    8280      * _.pluck(userIndex, 'age');
    8281      * // => [36, 40] (iteration order is not guaranteed)
    8282      */
    8283     function pluck(collection, path) {
    8284       return map(collection, property(path));
    8285     }
    8286 
    8287     /**
    8288      * Reduces `collection` to a value which is the accumulated result of running
    8289      * each element in `collection` through `iteratee`, where each successive
    8290      * invocation is supplied the return value of the previous. If `accumulator`
    8291      * is not provided the first element of `collection` is used as the initial
    8292      * value. The `iteratee` is bound to `thisArg` and invoked with four arguments:
    8293      * (accumulator, value, index|key, collection).
    8294      *
    8295      * Many lodash methods are guarded to work as interatees for methods like
    8296      * `_.reduce`, `_.reduceRight`, and `_.transform`.
    8297      *
    8298      * The guarded methods are:
    8299      * `assign`, `defaults`, `includes`, `merge`, `sortByAll`, and `sortByOrder`
    8300      *
    8301      * @static
    8302      * @memberOf _
    8303      * @alias foldl, inject
    8304      * @category Collection
    8305      * @param {Array|Object|string} collection The collection to iterate over.
    8306      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    8307      * @param {*} [accumulator] The initial value.
    8308      * @param {*} [thisArg] The `this` binding of `iteratee`.
    8309      * @returns {*} Returns the accumulated value.
    8310      * @example
    8311      *
    8312      * _.reduce([1, 2], function(total, n) {
    8313      *   return total + n;
    8314      * });
    8315      * // => 3
    8316      *
    8317      * _.reduce({ 'a': 1, 'b': 2 }, function(result, n, key) {
    8318      *   result[key] = n * 3;
    8319      *   return result;
    8320      * }, {});
    8321      * // => { 'a': 3, 'b': 6 } (iteration order is not guaranteed)
    8322      */
    8323     var reduce = createReduce(arrayReduce, baseEach);
    8324 
    8325     /**
    8326      * This method is like `_.reduce` except that it iterates over elements of
    8327      * `collection` from right to left.
    8328      *
    8329      * @static
    8330      * @memberOf _
    8331      * @alias foldr
    8332      * @category Collection
    8333      * @param {Array|Object|string} collection The collection to iterate over.
    8334      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    8335      * @param {*} [accumulator] The initial value.
    8336      * @param {*} [thisArg] The `this` binding of `iteratee`.
    8337      * @returns {*} Returns the accumulated value.
    8338      * @example
    8339      *
    8340      * var array = [[0, 1], [2, 3], [4, 5]];
    8341      *
    8342      * _.reduceRight(array, function(flattened, other) {
    8343      *   return flattened.concat(other);
    8344      * }, []);
    8345      * // => [4, 5, 2, 3, 0, 1]
    8346      */
    8347     var reduceRight =  createReduce(arrayReduceRight, baseEachRight);
    8348 
    8349     /**
    8350      * The opposite of `_.filter`; this method returns the elements of `collection`
    8351      * that `predicate` does **not** return truthy for.
    8352      *
    8353      * If a property name is provided for `predicate` the created `_.property`
    8354      * style callback returns the property value of the given element.
    8355      *
    8356      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    8357      * style callback returns `true` for elements that have a matching property
    8358      * value, else `false`.
    8359      *
    8360      * If an object is provided for `predicate` the created `_.matches` style
    8361      * callback returns `true` for elements that have the properties of the given
    8362      * object, else `false`.
    8363      *
    8364      * @static
    8365      * @memberOf _
    8366      * @category Collection
    8367      * @param {Array|Object|string} collection The collection to iterate over.
    8368      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    8369      *  per iteration.
    8370      * @param {*} [thisArg] The `this` binding of `predicate`.
    8371      * @returns {Array} Returns the new filtered array.
    8372      * @example
    8373      *
    8374      * _.reject([1, 2, 3, 4], function(n) {
    8375      *   return n % 2 == 0;
    8376      * });
    8377      * // => [1, 3]
    8378      *
    8379      * var users = [
    8380      *   { 'user': 'barney', 'age': 36, 'active': false },
    8381      *   { 'user': 'fred',   'age': 40, 'active': true }
    8382      * ];
    8383      *
    8384      * // using the `_.matches` callback shorthand
    8385      * _.pluck(_.reject(users, { 'age': 40, 'active': true }), 'user');
    8386      * // => ['barney']
    8387      *
    8388      * // using the `_.matchesProperty` callback shorthand
    8389      * _.pluck(_.reject(users, 'active', false), 'user');
    8390      * // => ['fred']
    8391      *
    8392      * // using the `_.property` callback shorthand
    8393      * _.pluck(_.reject(users, 'active'), 'user');
    8394      * // => ['barney']
    8395      */
    8396     function reject(collection, predicate, thisArg) {
    8397       var func = isArray(collection) ? arrayFilter : baseFilter;
    8398       predicate = getCallback(predicate, thisArg, 3);
    8399       return func(collection, function(value, index, collection) {
    8400         return !predicate(value, index, collection);
    8401       });
    8402     }
    8403 
    8404     /**
    8405      * Gets a random element or `n` random elements from a collection.
    8406      *
    8407      * @static
    8408      * @memberOf _
    8409      * @category Collection
    8410      * @param {Array|Object|string} collection The collection to sample.
    8411      * @param {number} [n] The number of elements to sample.
    8412      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    8413      * @returns {*} Returns the random sample(s).
    8414      * @example
    8415      *
    8416      * _.sample([1, 2, 3, 4]);
    8417      * // => 2
    8418      *
    8419      * _.sample([1, 2, 3, 4], 2);
    8420      * // => [3, 1]
    8421      */
    8422     function sample(collection, n, guard) {
    8423       if (guard ? isIterateeCall(collection, n, guard) : n == null) {
    8424         collection = toIterable(collection);
    8425         var length = collection.length;
    8426         return length > 0 ? collection[baseRandom(0, length - 1)] : undefined;
    8427       }
    8428       var result = shuffle(collection);
    8429       result.length = nativeMin(n < 0 ? 0 : (+n || 0), result.length);
    8430       return result;
    8431     }
    8432 
    8433     /**
    8434      * Creates an array of shuffled values, using a version of the
    8435      * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
    8436      *
    8437      * @static
    8438      * @memberOf _
    8439      * @category Collection
    8440      * @param {Array|Object|string} collection The collection to shuffle.
    8441      * @returns {Array} Returns the new shuffled array.
    8442      * @example
    8443      *
    8444      * _.shuffle([1, 2, 3, 4]);
    8445      * // => [4, 1, 3, 2]
    8446      */
    8447     function shuffle(collection) {
    8448       collection = toIterable(collection);
    8449 
    8450       var index = -1,
    8451           length = collection.length,
    8452           result = Array(length);
    8453 
    8454       while (++index < length) {
    8455         var rand = baseRandom(0, index);
    8456         if (index != rand) {
    8457           result[index] = result[rand];
    8458         }
    8459         result[rand] = collection[index];
    8460       }
    8461       return result;
    8462     }
    8463 
    8464     /**
    8465      * Gets the size of `collection` by returning its length for array-like
    8466      * values or the number of own enumerable properties for objects.
    8467      *
    8468      * @static
    8469      * @memberOf _
    8470      * @category Collection
    8471      * @param {Array|Object|string} collection The collection to inspect.
    8472      * @returns {number} Returns the size of `collection`.
    8473      * @example
    8474      *
    8475      * _.size([1, 2, 3]);
    8476      * // => 3
    8477      *
    8478      * _.size({ 'a': 1, 'b': 2 });
    8479      * // => 2
    8480      *
    8481      * _.size('pebbles');
    8482      * // => 7
    8483      */
    8484     function size(collection) {
    8485       var length = collection ? getLength(collection) : 0;
    8486       return isLength(length) ? length : keys(collection).length;
    8487     }
    8488 
    8489     /**
    8490      * Checks if `predicate` returns truthy for **any** element of `collection`.
    8491      * The function returns as soon as it finds a passing value and does not iterate
    8492      * over the entire collection. The predicate is bound to `thisArg` and invoked
    8493      * with three arguments: (value, index|key, collection).
    8494      *
    8495      * If a property name is provided for `predicate` the created `_.property`
    8496      * style callback returns the property value of the given element.
    8497      *
    8498      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    8499      * style callback returns `true` for elements that have a matching property
    8500      * value, else `false`.
    8501      *
    8502      * If an object is provided for `predicate` the created `_.matches` style
    8503      * callback returns `true` for elements that have the properties of the given
    8504      * object, else `false`.
    8505      *
    8506      * @static
    8507      * @memberOf _
    8508      * @alias any
    8509      * @category Collection
    8510      * @param {Array|Object|string} collection The collection to iterate over.
    8511      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    8512      *  per iteration.
    8513      * @param {*} [thisArg] The `this` binding of `predicate`.
    8514      * @returns {boolean} Returns `true` if any element passes the predicate check,
    8515      *  else `false`.
    8516      * @example
    8517      *
    8518      * _.some([null, 0, 'yes', false], Boolean);
    8519      * // => true
    8520      *
    8521      * var users = [
    8522      *   { 'user': 'barney', 'active': true },
    8523      *   { 'user': 'fred',   'active': false }
    8524      * ];
    8525      *
    8526      * // using the `_.matches` callback shorthand
    8527      * _.some(users, { 'user': 'barney', 'active': false });
    8528      * // => false
    8529      *
    8530      * // using the `_.matchesProperty` callback shorthand
    8531      * _.some(users, 'active', false);
    8532      * // => true
    8533      *
    8534      * // using the `_.property` callback shorthand
    8535      * _.some(users, 'active');
    8536      * // => true
    8537      */
    8538     function some(collection, predicate, thisArg) {
    8539       var func = isArray(collection) ? arraySome : baseSome;
    8540       if (thisArg && isIterateeCall(collection, predicate, thisArg)) {
    8541         predicate = null;
    8542       }
    8543       if (typeof predicate != 'function' || thisArg !== undefined) {
    8544         predicate = getCallback(predicate, thisArg, 3);
    8545       }
    8546       return func(collection, predicate);
    8547     }
    8548 
    8549     /**
    8550      * Creates an array of elements, sorted in ascending order by the results of
    8551      * running each element in a collection through `iteratee`. This method performs
    8552      * a stable sort, that is, it preserves the original sort order of equal elements.
    8553      * The `iteratee` is bound to `thisArg` and invoked with three arguments:
    8554      * (value, index|key, collection).
    8555      *
    8556      * If a property name is provided for `iteratee` the created `_.property`
    8557      * style callback returns the property value of the given element.
    8558      *
    8559      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    8560      * style callback returns `true` for elements that have a matching property
    8561      * value, else `false`.
    8562      *
    8563      * If an object is provided for `iteratee` the created `_.matches` style
    8564      * callback returns `true` for elements that have the properties of the given
    8565      * object, else `false`.
    8566      *
    8567      * @static
    8568      * @memberOf _
    8569      * @category Collection
    8570      * @param {Array|Object|string} collection The collection to iterate over.
    8571      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    8572      *  per iteration.
    8573      * @param {*} [thisArg] The `this` binding of `iteratee`.
    8574      * @returns {Array} Returns the new sorted array.
    8575      * @example
    8576      *
    8577      * _.sortBy([1, 2, 3], function(n) {
    8578      *   return Math.sin(n);
    8579      * });
    8580      * // => [3, 1, 2]
    8581      *
    8582      * _.sortBy([1, 2, 3], function(n) {
    8583      *   return this.sin(n);
    8584      * }, Math);
    8585      * // => [3, 1, 2]
    8586      *
    8587      * var users = [
    8588      *   { 'user': 'fred' },
    8589      *   { 'user': 'pebbles' },
    8590      *   { 'user': 'barney' }
    8591      * ];
    8592      *
    8593      * // using the `_.property` callback shorthand
    8594      * _.pluck(_.sortBy(users, 'user'), 'user');
    8595      * // => ['barney', 'fred', 'pebbles']
    8596      */
    8597     function sortBy(collection, iteratee, thisArg) {
    8598       if (collection == null) {
    8599         return [];
    8600       }
    8601       if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {
    8602         iteratee = null;
    8603       }
    8604       var index = -1;
    8605       iteratee = getCallback(iteratee, thisArg, 3);
    8606 
    8607       var result = baseMap(collection, function(value, key, collection) {
    8608         return { 'criteria': iteratee(value, key, collection), 'index': ++index, 'value': value };
    8609       });
    8610       return baseSortBy(result, compareAscending);
    8611     }
    8612 
    8613     /**
    8614      * This method is like `_.sortBy` except that it can sort by multiple iteratees
    8615      * or property names.
    8616      *
    8617      * If a property name is provided for an iteratee the created `_.property`
    8618      * style callback returns the property value of the given element.
    8619      *
    8620      * If an object is provided for an iteratee the created `_.matches` style
    8621      * callback returns `true` for elements that have the properties of the given
    8622      * object, else `false`.
    8623      *
    8624      * @static
    8625      * @memberOf _
    8626      * @category Collection
    8627      * @param {Array|Object|string} collection The collection to iterate over.
    8628      * @param {...(Function|Function[]|Object|Object[]|string|string[])} iteratees
    8629      *  The iteratees to sort by, specified as individual values or arrays of values.
    8630      * @returns {Array} Returns the new sorted array.
    8631      * @example
    8632      *
    8633      * var users = [
    8634      *   { 'user': 'fred',   'age': 48 },
    8635      *   { 'user': 'barney', 'age': 36 },
    8636      *   { 'user': 'fred',   'age': 42 },
    8637      *   { 'user': 'barney', 'age': 34 }
    8638      * ];
    8639      *
    8640      * _.map(_.sortByAll(users, ['user', 'age']), _.values);
    8641      * // => [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]]
    8642      *
    8643      * _.map(_.sortByAll(users, 'user', function(chr) {
    8644      *   return Math.floor(chr.age / 10);
    8645      * }), _.values);
    8646      * // => [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
    8647      */
    8648     var sortByAll = restParam(function(collection, iteratees) {
    8649       if (collection == null) {
    8650         return [];
    8651       }
    8652       var guard = iteratees[2];
    8653       if (guard && isIterateeCall(iteratees[0], iteratees[1], guard)) {
    8654         iteratees.length = 1;
    8655       }
    8656       return baseSortByOrder(collection, baseFlatten(iteratees), []);
    8657     });
    8658 
    8659     /**
    8660      * This method is like `_.sortByAll` except that it allows specifying the
    8661      * sort orders of the iteratees to sort by. A truthy value in `orders` will
    8662      * sort the corresponding property name in ascending order while a falsey
    8663      * value will sort it in descending order.
    8664      *
    8665      * If a property name is provided for an iteratee the created `_.property`
    8666      * style callback returns the property value of the given element.
    8667      *
    8668      * If an object is provided for an iteratee the created `_.matches` style
    8669      * callback returns `true` for elements that have the properties of the given
    8670      * object, else `false`.
    8671      *
    8672      * @static
    8673      * @memberOf _
    8674      * @category Collection
    8675      * @param {Array|Object|string} collection The collection to iterate over.
    8676      * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
    8677      * @param {boolean[]} orders The sort orders of `iteratees`.
    8678      * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`.
    8679      * @returns {Array} Returns the new sorted array.
    8680      * @example
    8681      *
    8682      * var users = [
    8683      *   { 'user': 'fred',   'age': 48 },
    8684      *   { 'user': 'barney', 'age': 34 },
    8685      *   { 'user': 'fred',   'age': 42 },
    8686      *   { 'user': 'barney', 'age': 36 }
    8687      * ];
    8688      *
    8689      * // sort by `user` in ascending order and by `age` in descending order
    8690      * _.map(_.sortByOrder(users, ['user', 'age'], [true, false]), _.values);
    8691      * // => [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
    8692      */
    8693     function sortByOrder(collection, iteratees, orders, guard) {
    8694       if (collection == null) {
    8695         return [];
    8696       }
    8697       if (guard && isIterateeCall(iteratees, orders, guard)) {
    8698         orders = null;
    8699       }
    8700       if (!isArray(iteratees)) {
    8701         iteratees = iteratees == null ? [] : [iteratees];
    8702       }
    8703       if (!isArray(orders)) {
    8704         orders = orders == null ? [] : [orders];
    8705       }
    8706       return baseSortByOrder(collection, iteratees, orders);
    8707     }
    8708 
    8709     /**
    8710      * Performs a deep comparison between each element in `collection` and the
    8711      * source object, returning an array of all elements that have equivalent
    8712      * property values.
    8713      *
    8714      * **Note:** This method supports comparing arrays, booleans, `Date` objects,
    8715      * numbers, `Object` objects, regexes, and strings. Objects are compared by
    8716      * their own, not inherited, enumerable properties. For comparing a single
    8717      * own or inherited property value see `_.matchesProperty`.
    8718      *
    8719      * @static
    8720      * @memberOf _
    8721      * @category Collection
    8722      * @param {Array|Object|string} collection The collection to search.
    8723      * @param {Object} source The object of property values to match.
    8724      * @returns {Array} Returns the new filtered array.
    8725      * @example
    8726      *
    8727      * var users = [
    8728      *   { 'user': 'barney', 'age': 36, 'active': false, 'pets': ['hoppy'] },
    8729      *   { 'user': 'fred',   'age': 40, 'active': true, 'pets': ['baby puss', 'dino'] }
    8730      * ];
    8731      *
    8732      * _.pluck(_.where(users, { 'age': 36, 'active': false }), 'user');
    8733      * // => ['barney']
    8734      *
    8735      * _.pluck(_.where(users, { 'pets': ['dino'] }), 'user');
    8736      * // => ['fred']
    8737      */
    8738     function where(collection, source) {
    8739       return filter(collection, baseMatches(source));
    8740     }
    8741 
    8742     /*------------------------------------------------------------------------*/
    8743 
    8744     /**
    8745      * Gets the number of milliseconds that have elapsed since the Unix epoch
    8746      * (1 January 1970 00:00:00 UTC).
    8747      *
    8748      * @static
    8749      * @memberOf _
    8750      * @category Date
    8751      * @example
    8752      *
    8753      * _.defer(function(stamp) {
    8754      *   console.log(_.now() - stamp);
    8755      * }, _.now());
    8756      * // => logs the number of milliseconds it took for the deferred function to be invoked
    8757      */
    8758     var now = nativeNow || function() {
    8759       return new Date().getTime();
    8760     };
    8761 
    8762     /*------------------------------------------------------------------------*/
    8763 
    8764     /**
    8765      * The opposite of `_.before`; this method creates a function that invokes
    8766      * `func` once it is called `n` or more times.
    8767      *
    8768      * @static
    8769      * @memberOf _
    8770      * @category Function
    8771      * @param {number} n The number of calls before `func` is invoked.
    8772      * @param {Function} func The function to restrict.
    8773      * @returns {Function} Returns the new restricted function.
    8774      * @example
    8775      *
    8776      * var saves = ['profile', 'settings'];
    8777      *
    8778      * var done = _.after(saves.length, function() {
    8779      *   console.log('done saving!');
    8780      * });
    8781      *
    8782      * _.forEach(saves, function(type) {
    8783      *   asyncSave({ 'type': type, 'complete': done });
    8784      * });
    8785      * // => logs 'done saving!' after the two async saves have completed
    8786      */
    8787     function after(n, func) {
    8788       if (typeof func != 'function') {
    8789         if (typeof n == 'function') {
    8790           var temp = n;
    8791           n = func;
    8792           func = temp;
    8793         } else {
    8794           throw new TypeError(FUNC_ERROR_TEXT);
    8795         }
    8796       }
    8797       n = nativeIsFinite(n = +n) ? n : 0;
    8798       return function() {
    8799         if (--n < 1) {
    8800           return func.apply(this, arguments);
    8801         }
    8802       };
    8803     }
    8804 
    8805     /**
    8806      * Creates a function that accepts up to `n` arguments ignoring any
    8807      * additional arguments.
    8808      *
    8809      * @static
    8810      * @memberOf _
    8811      * @category Function
    8812      * @param {Function} func The function to cap arguments for.
    8813      * @param {number} [n=func.length] The arity cap.
    8814      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    8815      * @returns {Function} Returns the new function.
    8816      * @example
    8817      *
    8818      * _.map(['6', '8', '10'], _.ary(parseInt, 1));
    8819      * // => [6, 8, 10]
    8820      */
    8821     function ary(func, n, guard) {
    8822       if (guard && isIterateeCall(func, n, guard)) {
    8823         n = null;
    8824       }
    8825       n = (func && n == null) ? func.length : nativeMax(+n || 0, 0);
    8826       return createWrapper(func, ARY_FLAG, null, null, null, null, n);
    8827     }
    8828 
    8829     /**
    8830      * Creates a function that invokes `func`, with the `this` binding and arguments
    8831      * of the created function, while it is called less than `n` times. Subsequent
    8832      * calls to the created function return the result of the last `func` invocation.
    8833      *
    8834      * @static
    8835      * @memberOf _
    8836      * @category Function
    8837      * @param {number} n The number of calls at which `func` is no longer invoked.
    8838      * @param {Function} func The function to restrict.
    8839      * @returns {Function} Returns the new restricted function.
    8840      * @example
    8841      *
    8842      * jQuery('#add').on('click', _.before(5, addContactToList));
    8843      * // => allows adding up to 4 contacts to the list
    8844      */
    8845     function before(n, func) {
    8846       var result;
    8847       if (typeof func != 'function') {
    8848         if (typeof n == 'function') {
    8849           var temp = n;
    8850           n = func;
    8851           func = temp;
    8852         } else {
    8853           throw new TypeError(FUNC_ERROR_TEXT);
    8854         }
    8855       }
    8856       return function() {
    8857         if (--n > 0) {
    8858           result = func.apply(this, arguments);
    8859         }
    8860         if (n <= 1) {
    8861           func = null;
    8862         }
    8863         return result;
    8864       };
    8865     }
    8866 
    8867     /**
    8868      * Creates a function that invokes `func` with the `this` binding of `thisArg`
    8869      * and prepends any additional `_.bind` arguments to those provided to the
    8870      * bound function.
    8871      *
    8872      * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
    8873      * may be used as a placeholder for partially applied arguments.
    8874      *
    8875      * **Note:** Unlike native `Function#bind` this method does not set the "length"
    8876      * property of bound functions.
    8877      *
    8878      * @static
    8879      * @memberOf _
    8880      * @category Function
    8881      * @param {Function} func The function to bind.
    8882      * @param {*} thisArg The `this` binding of `func`.
    8883      * @param {...*} [partials] The arguments to be partially applied.
    8884      * @returns {Function} Returns the new bound function.
    8885      * @example
    8886      *
    8887      * var greet = function(greeting, punctuation) {
    8888      *   return greeting + ' ' + this.user + punctuation;
    8889      * };
    8890      *
    8891      * var object = { 'user': 'fred' };
    8892      *
    8893      * var bound = _.bind(greet, object, 'hi');
    8894      * bound('!');
    8895      * // => 'hi fred!'
    8896      *
    8897      * // using placeholders
    8898      * var bound = _.bind(greet, object, _, '!');
    8899      * bound('hi');
    8900      * // => 'hi fred!'
    8901      */
    8902     var bind = restParam(function(func, thisArg, partials) {
    8903       var bitmask = BIND_FLAG;
    8904       if (partials.length) {
    8905         var holders = replaceHolders(partials, bind.placeholder);
    8906         bitmask |= PARTIAL_FLAG;
    8907       }
    8908       return createWrapper(func, bitmask, thisArg, partials, holders);
    8909     });
    8910 
    8911     /**
    8912      * Binds methods of an object to the object itself, overwriting the existing
    8913      * method. Method names may be specified as individual arguments or as arrays
    8914      * of method names. If no method names are provided all enumerable function
    8915      * properties, own and inherited, of `object` are bound.
    8916      *
    8917      * **Note:** This method does not set the "length" property of bound functions.
    8918      *
    8919      * @static
    8920      * @memberOf _
    8921      * @category Function
    8922      * @param {Object} object The object to bind and assign the bound methods to.
    8923      * @param {...(string|string[])} [methodNames] The object method names to bind,
    8924      *  specified as individual method names or arrays of method names.
    8925      * @returns {Object} Returns `object`.
    8926      * @example
    8927      *
    8928      * var view = {
    8929      *   'label': 'docs',
    8930      *   'onClick': function() {
    8931      *     console.log('clicked ' + this.label);
    8932      *   }
    8933      * };
    8934      *
    8935      * _.bindAll(view);
    8936      * jQuery('#docs').on('click', view.onClick);
    8937      * // => logs 'clicked docs' when the element is clicked
    8938      */
    8939     var bindAll = restParam(function(object, methodNames) {
    8940       methodNames = methodNames.length ? baseFlatten(methodNames) : functions(object);
    8941 
    8942       var index = -1,
    8943           length = methodNames.length;
    8944 
    8945       while (++index < length) {
    8946         var key = methodNames[index];
    8947         object[key] = createWrapper(object[key], BIND_FLAG, object);
    8948       }
    8949       return object;
    8950     });
    8951 
    8952     /**
    8953      * Creates a function that invokes the method at `object[key]` and prepends
    8954      * any additional `_.bindKey` arguments to those provided to the bound function.
    8955      *
    8956      * This method differs from `_.bind` by allowing bound functions to reference
    8957      * methods that may be redefined or don't yet exist.
    8958      * See [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
    8959      * for more details.
    8960      *
    8961      * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
    8962      * builds, may be used as a placeholder for partially applied arguments.
    8963      *
    8964      * @static
    8965      * @memberOf _
    8966      * @category Function
    8967      * @param {Object} object The object the method belongs to.
    8968      * @param {string} key The key of the method.
    8969      * @param {...*} [partials] The arguments to be partially applied.
    8970      * @returns {Function} Returns the new bound function.
    8971      * @example
    8972      *
    8973      * var object = {
    8974      *   'user': 'fred',
    8975      *   'greet': function(greeting, punctuation) {
    8976      *     return greeting + ' ' + this.user + punctuation;
    8977      *   }
    8978      * };
    8979      *
    8980      * var bound = _.bindKey(object, 'greet', 'hi');
    8981      * bound('!');
    8982      * // => 'hi fred!'
    8983      *
    8984      * object.greet = function(greeting, punctuation) {
    8985      *   return greeting + 'ya ' + this.user + punctuation;
    8986      * };
    8987      *
    8988      * bound('!');
    8989      * // => 'hiya fred!'
    8990      *
    8991      * // using placeholders
    8992      * var bound = _.bindKey(object, 'greet', _, '!');
    8993      * bound('hi');
    8994      * // => 'hiya fred!'
    8995      */
    8996     var bindKey = restParam(function(object, key, partials) {
    8997       var bitmask = BIND_FLAG | BIND_KEY_FLAG;
    8998       if (partials.length) {
    8999         var holders = replaceHolders(partials, bindKey.placeholder);
    9000         bitmask |= PARTIAL_FLAG;
    9001       }
    9002       return createWrapper(key, bitmask, object, partials, holders);
    9003     });
    9004 
    9005     /**
    9006      * Creates a function that accepts one or more arguments of `func` that when
    9007      * called either invokes `func` returning its result, if all `func` arguments
    9008      * have been provided, or returns a function that accepts one or more of the
    9009      * remaining `func` arguments, and so on. The arity of `func` may be specified
    9010      * if `func.length` is not sufficient.
    9011      *
    9012      * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
    9013      * may be used as a placeholder for provided arguments.
    9014      *
    9015      * **Note:** This method does not set the "length" property of curried functions.
    9016      *
    9017      * @static
    9018      * @memberOf _
    9019      * @category Function
    9020      * @param {Function} func The function to curry.
    9021      * @param {number} [arity=func.length] The arity of `func`.
    9022      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    9023      * @returns {Function} Returns the new curried function.
    9024      * @example
    9025      *
    9026      * var abc = function(a, b, c) {
    9027      *   return [a, b, c];
    9028      * };
    9029      *
    9030      * var curried = _.curry(abc);
    9031      *
    9032      * curried(1)(2)(3);
    9033      * // => [1, 2, 3]
    9034      *
    9035      * curried(1, 2)(3);
    9036      * // => [1, 2, 3]
    9037      *
    9038      * curried(1, 2, 3);
    9039      * // => [1, 2, 3]
    9040      *
    9041      * // using placeholders
    9042      * curried(1)(_, 3)(2);
    9043      * // => [1, 2, 3]
    9044      */
    9045     var curry = createCurry(CURRY_FLAG);
    9046 
    9047     /**
    9048      * This method is like `_.curry` except that arguments are applied to `func`
    9049      * in the manner of `_.partialRight` instead of `_.partial`.
    9050      *
    9051      * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
    9052      * builds, may be used as a placeholder for provided arguments.
    9053      *
    9054      * **Note:** This method does not set the "length" property of curried functions.
    9055      *
    9056      * @static
    9057      * @memberOf _
    9058      * @category Function
    9059      * @param {Function} func The function to curry.
    9060      * @param {number} [arity=func.length] The arity of `func`.
    9061      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    9062      * @returns {Function} Returns the new curried function.
    9063      * @example
    9064      *
    9065      * var abc = function(a, b, c) {
    9066      *   return [a, b, c];
    9067      * };
    9068      *
    9069      * var curried = _.curryRight(abc);
    9070      *
    9071      * curried(3)(2)(1);
    9072      * // => [1, 2, 3]
    9073      *
    9074      * curried(2, 3)(1);
    9075      * // => [1, 2, 3]
    9076      *
    9077      * curried(1, 2, 3);
    9078      * // => [1, 2, 3]
    9079      *
    9080      * // using placeholders
    9081      * curried(3)(1, _)(2);
    9082      * // => [1, 2, 3]
    9083      */
    9084     var curryRight = createCurry(CURRY_RIGHT_FLAG);
    9085 
    9086     /**
    9087      * Creates a function that delays invoking `func` until after `wait` milliseconds
    9088      * have elapsed since the last time it was invoked. The created function comes
    9089      * with a `cancel` method to cancel delayed invocations. Provide an options
    9090      * object to indicate that `func` should be invoked on the leading and/or
    9091      * trailing edge of the `wait` timeout. Subsequent calls to the debounced
    9092      * function return the result of the last `func` invocation.
    9093      *
    9094      * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
    9095      * on the trailing edge of the timeout only if the the debounced function is
    9096      * invoked more than once during the `wait` timeout.
    9097      *
    9098      * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
    9099      * for details over the differences between `_.debounce` and `_.throttle`.
    9100      *
    9101      * @static
    9102      * @memberOf _
    9103      * @category Function
    9104      * @param {Function} func The function to debounce.
    9105      * @param {number} [wait=0] The number of milliseconds to delay.
    9106      * @param {Object} [options] The options object.
    9107      * @param {boolean} [options.leading=false] Specify invoking on the leading
    9108      *  edge of the timeout.
    9109      * @param {number} [options.maxWait] The maximum time `func` is allowed to be
    9110      *  delayed before it is invoked.
    9111      * @param {boolean} [options.trailing=true] Specify invoking on the trailing
    9112      *  edge of the timeout.
    9113      * @returns {Function} Returns the new debounced function.
    9114      * @example
    9115      *
    9116      * // avoid costly calculations while the window size is in flux
    9117      * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
    9118      *
    9119      * // invoke `sendMail` when the click event is fired, debouncing subsequent calls
    9120      * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
    9121      *   'leading': true,
    9122      *   'trailing': false
    9123      * }));
    9124      *
    9125      * // ensure `batchLog` is invoked once after 1 second of debounced calls
    9126      * var source = new EventSource('/stream');
    9127      * jQuery(source).on('message', _.debounce(batchLog, 250, {
    9128      *   'maxWait': 1000
    9129      * }));
    9130      *
    9131      * // cancel a debounced call
    9132      * var todoChanges = _.debounce(batchLog, 1000);
    9133      * Object.observe(models.todo, todoChanges);
    9134      *
    9135      * Object.observe(models, function(changes) {
    9136      *   if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {
    9137      *     todoChanges.cancel();
    9138      *   }
    9139      * }, ['delete']);
    9140      *
    9141      * // ...at some point `models.todo` is changed
    9142      * models.todo.completed = true;
    9143      *
    9144      * // ...before 1 second has passed `models.todo` is deleted
    9145      * // which cancels the debounced `todoChanges` call
    9146      * delete models.todo;
    9147      */
    9148     function debounce(func, wait, options) {
    9149       var args,
    9150           maxTimeoutId,
    9151           result,
    9152           stamp,
    9153           thisArg,
    9154           timeoutId,
    9155           trailingCall,
    9156           lastCalled = 0,
    9157           maxWait = false,
    9158           trailing = true;
    9159 
    9160       if (typeof func != 'function') {
    9161         throw new TypeError(FUNC_ERROR_TEXT);
    9162       }
    9163       wait = wait < 0 ? 0 : (+wait || 0);
    9164       if (options === true) {
    9165         var leading = true;
    9166         trailing = false;
    9167       } else if (isObject(options)) {
    9168         leading = options.leading;
    9169         maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
    9170         trailing = 'trailing' in options ? options.trailing : trailing;
    9171       }
    9172 
    9173       function cancel() {
    9174         if (timeoutId) {
    9175           clearTimeout(timeoutId);
    9176         }
    9177         if (maxTimeoutId) {
    9178           clearTimeout(maxTimeoutId);
    9179         }
    9180         maxTimeoutId = timeoutId = trailingCall = undefined;
    9181       }
    9182 
    9183       function delayed() {
    9184         var remaining = wait - (now() - stamp);
    9185         if (remaining <= 0 || remaining > wait) {
    9186           if (maxTimeoutId) {
    9187             clearTimeout(maxTimeoutId);
    9188           }
    9189           var isCalled = trailingCall;
    9190           maxTimeoutId = timeoutId = trailingCall = undefined;
    9191           if (isCalled) {
    9192             lastCalled = now();
    9193             result = func.apply(thisArg, args);
    9194             if (!timeoutId && !maxTimeoutId) {
    9195               args = thisArg = null;
    9196             }
    9197           }
    9198         } else {
    9199           timeoutId = setTimeout(delayed, remaining);
    9200         }
    9201       }
    9202 
    9203       function maxDelayed() {
    9204         if (timeoutId) {
    9205           clearTimeout(timeoutId);
    9206         }
    9207         maxTimeoutId = timeoutId = trailingCall = undefined;
    9208         if (trailing || (maxWait !== wait)) {
    9209           lastCalled = now();
    9210           result = func.apply(thisArg, args);
    9211           if (!timeoutId && !maxTimeoutId) {
    9212             args = thisArg = null;
    9213           }
    9214         }
    9215       }
    9216 
    9217       function debounced() {
    9218         args = arguments;
    9219         stamp = now();
    9220         thisArg = this;
    9221         trailingCall = trailing && (timeoutId || !leading);
    9222 
    9223         if (maxWait === false) {
    9224           var leadingCall = leading && !timeoutId;
    9225         } else {
    9226           if (!maxTimeoutId && !leading) {
    9227             lastCalled = stamp;
    9228           }
    9229           var remaining = maxWait - (stamp - lastCalled),
    9230               isCalled = remaining <= 0 || remaining > maxWait;
    9231 
    9232           if (isCalled) {
    9233             if (maxTimeoutId) {
    9234               maxTimeoutId = clearTimeout(maxTimeoutId);
    9235             }
    9236             lastCalled = stamp;
    9237             result = func.apply(thisArg, args);
    9238           }
    9239           else if (!maxTimeoutId) {
    9240             maxTimeoutId = setTimeout(maxDelayed, remaining);
    9241           }
    9242         }
    9243         if (isCalled && timeoutId) {
    9244           timeoutId = clearTimeout(timeoutId);
    9245         }
    9246         else if (!timeoutId && wait !== maxWait) {
    9247           timeoutId = setTimeout(delayed, wait);
    9248         }
    9249         if (leadingCall) {
    9250           isCalled = true;
    9251           result = func.apply(thisArg, args);
    9252         }
    9253         if (isCalled && !timeoutId && !maxTimeoutId) {
    9254           args = thisArg = null;
    9255         }
    9256         return result;
    9257       }
    9258       debounced.cancel = cancel;
    9259       return debounced;
    9260     }
    9261 
    9262     /**
    9263      * Defers invoking the `func` until the current call stack has cleared. Any
    9264      * additional arguments are provided to `func` when it is invoked.
    9265      *
    9266      * @static
    9267      * @memberOf _
    9268      * @category Function
    9269      * @param {Function} func The function to defer.
    9270      * @param {...*} [args] The arguments to invoke the function with.
    9271      * @returns {number} Returns the timer id.
    9272      * @example
    9273      *
    9274      * _.defer(function(text) {
    9275      *   console.log(text);
    9276      * }, 'deferred');
    9277      * // logs 'deferred' after one or more milliseconds
    9278      */
    9279     var defer = restParam(function(func, args) {
    9280       return baseDelay(func, 1, args);
    9281     });
    9282 
    9283     /**
    9284      * Invokes `func` after `wait` milliseconds. Any additional arguments are
    9285      * provided to `func` when it is invoked.
    9286      *
    9287      * @static
    9288      * @memberOf _
    9289      * @category Function
    9290      * @param {Function} func The function to delay.
    9291      * @param {number} wait The number of milliseconds to delay invocation.
    9292      * @param {...*} [args] The arguments to invoke the function with.
    9293      * @returns {number} Returns the timer id.
    9294      * @example
    9295      *
    9296      * _.delay(function(text) {
    9297      *   console.log(text);
    9298      * }, 1000, 'later');
    9299      * // => logs 'later' after one second
    9300      */
    9301     var delay = restParam(function(func, wait, args) {
    9302       return baseDelay(func, wait, args);
    9303     });
    9304 
    9305     /**
    9306      * Creates a function that returns the result of invoking the provided
    9307      * functions with the `this` binding of the created function, where each
    9308      * successive invocation is supplied the return value of the previous.
    9309      *
    9310      * @static
    9311      * @memberOf _
    9312      * @category Function
    9313      * @param {...Function} [funcs] Functions to invoke.
    9314      * @returns {Function} Returns the new function.
    9315      * @example
    9316      *
    9317      * function square(n) {
    9318      *   return n * n;
    9319      * }
    9320      *
    9321      * var addSquare = _.flow(_.add, square);
    9322      * addSquare(1, 2);
    9323      * // => 9
    9324      */
    9325     var flow = createFlow();
    9326 
    9327     /**
    9328      * This method is like `_.flow` except that it creates a function that
    9329      * invokes the provided functions from right to left.
    9330      *
    9331      * @static
    9332      * @memberOf _
    9333      * @alias backflow, compose
    9334      * @category Function
    9335      * @param {...Function} [funcs] Functions to invoke.
    9336      * @returns {Function} Returns the new function.
    9337      * @example
    9338      *
    9339      * function square(n) {
    9340      *   return n * n;
    9341      * }
    9342      *
    9343      * var addSquare = _.flowRight(square, _.add);
    9344      * addSquare(1, 2);
    9345      * // => 9
    9346      */
    9347     var flowRight = createFlow(true);
    9348 
    9349     /**
    9350      * Creates a function that memoizes the result of `func`. If `resolver` is
    9351      * provided it determines the cache key for storing the result based on the
    9352      * arguments provided to the memoized function. By default, the first argument
    9353      * provided to the memoized function is coerced to a string and used as the
    9354      * cache key. The `func` is invoked with the `this` binding of the memoized
    9355      * function.
    9356      *
    9357      * **Note:** The cache is exposed as the `cache` property on the memoized
    9358      * function. Its creation may be customized by replacing the `_.memoize.Cache`
    9359      * constructor with one whose instances implement the [`Map`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-properties-of-the-map-prototype-object)
    9360      * method interface of `get`, `has`, and `set`.
    9361      *
    9362      * @static
    9363      * @memberOf _
    9364      * @category Function
    9365      * @param {Function} func The function to have its output memoized.
    9366      * @param {Function} [resolver] The function to resolve the cache key.
    9367      * @returns {Function} Returns the new memoizing function.
    9368      * @example
    9369      *
    9370      * var upperCase = _.memoize(function(string) {
    9371      *   return string.toUpperCase();
    9372      * });
    9373      *
    9374      * upperCase('fred');
    9375      * // => 'FRED'
    9376      *
    9377      * // modifying the result cache
    9378      * upperCase.cache.set('fred', 'BARNEY');
    9379      * upperCase('fred');
    9380      * // => 'BARNEY'
    9381      *
    9382      * // replacing `_.memoize.Cache`
    9383      * var object = { 'user': 'fred' };
    9384      * var other = { 'user': 'barney' };
    9385      * var identity = _.memoize(_.identity);
    9386      *
    9387      * identity(object);
    9388      * // => { 'user': 'fred' }
    9389      * identity(other);
    9390      * // => { 'user': 'fred' }
    9391      *
    9392      * _.memoize.Cache = WeakMap;
    9393      * var identity = _.memoize(_.identity);
    9394      *
    9395      * identity(object);
    9396      * // => { 'user': 'fred' }
    9397      * identity(other);
    9398      * // => { 'user': 'barney' }
    9399      */
    9400     function memoize(func, resolver) {
    9401       if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
    9402         throw new TypeError(FUNC_ERROR_TEXT);
    9403       }
    9404       var memoized = function() {
    9405         var args = arguments,
    9406             cache = memoized.cache,
    9407             key = resolver ? resolver.apply(this, args) : args[0];
    9408 
    9409         if (cache.has(key)) {
    9410           return cache.get(key);
    9411         }
    9412         var result = func.apply(this, args);
    9413         cache.set(key, result);
    9414         return result;
    9415       };
    9416       memoized.cache = new memoize.Cache;
    9417       return memoized;
    9418     }
    9419 
    9420     /**
    9421      * Creates a function that negates the result of the predicate `func`. The
    9422      * `func` predicate is invoked with the `this` binding and arguments of the
    9423      * created function.
    9424      *
    9425      * @static
    9426      * @memberOf _
    9427      * @category Function
    9428      * @param {Function} predicate The predicate to negate.
    9429      * @returns {Function} Returns the new function.
    9430      * @example
    9431      *
    9432      * function isEven(n) {
    9433      *   return n % 2 == 0;
    9434      * }
    9435      *
    9436      * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
    9437      * // => [1, 3, 5]
    9438      */
    9439     function negate(predicate) {
    9440       if (typeof predicate != 'function') {
    9441         throw new TypeError(FUNC_ERROR_TEXT);
    9442       }
    9443       return function() {
    9444         return !predicate.apply(this, arguments);
    9445       };
    9446     }
    9447 
    9448     /**
    9449      * Creates a function that is restricted to invoking `func` once. Repeat calls
    9450      * to the function return the value of the first call. The `func` is invoked
    9451      * with the `this` binding and arguments of the created function.
    9452      *
    9453      * @static
    9454      * @memberOf _
    9455      * @category Function
    9456      * @param {Function} func The function to restrict.
    9457      * @returns {Function} Returns the new restricted function.
    9458      * @example
    9459      *
    9460      * var initialize = _.once(createApplication);
    9461      * initialize();
    9462      * initialize();
    9463      * // `initialize` invokes `createApplication` once
    9464      */
    9465     function once(func) {
    9466       return before(2, func);
    9467     }
    9468 
    9469     /**
    9470      * Creates a function that invokes `func` with `partial` arguments prepended
    9471      * to those provided to the new function. This method is like `_.bind` except
    9472      * it does **not** alter the `this` binding.
    9473      *
    9474      * The `_.partial.placeholder` value, which defaults to `_` in monolithic
    9475      * builds, may be used as a placeholder for partially applied arguments.
    9476      *
    9477      * **Note:** This method does not set the "length" property of partially
    9478      * applied functions.
    9479      *
    9480      * @static
    9481      * @memberOf _
    9482      * @category Function
    9483      * @param {Function} func The function to partially apply arguments to.
    9484      * @param {...*} [partials] The arguments to be partially applied.
    9485      * @returns {Function} Returns the new partially applied function.
    9486      * @example
    9487      *
    9488      * var greet = function(greeting, name) {
    9489      *   return greeting + ' ' + name;
    9490      * };
    9491      *
    9492      * var sayHelloTo = _.partial(greet, 'hello');
    9493      * sayHelloTo('fred');
    9494      * // => 'hello fred'
    9495      *
    9496      * // using placeholders
    9497      * var greetFred = _.partial(greet, _, 'fred');
    9498      * greetFred('hi');
    9499      * // => 'hi fred'
    9500      */
    9501     var partial = createPartial(PARTIAL_FLAG);
    9502 
    9503     /**
    9504      * This method is like `_.partial` except that partially applied arguments
    9505      * are appended to those provided to the new function.
    9506      *
    9507      * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
    9508      * builds, may be used as a placeholder for partially applied arguments.
    9509      *
    9510      * **Note:** This method does not set the "length" property of partially
    9511      * applied functions.
    9512      *
    9513      * @static
    9514      * @memberOf _
    9515      * @category Function
    9516      * @param {Function} func The function to partially apply arguments to.
    9517      * @param {...*} [partials] The arguments to be partially applied.
    9518      * @returns {Function} Returns the new partially applied function.
    9519      * @example
    9520      *
    9521      * var greet = function(greeting, name) {
    9522      *   return greeting + ' ' + name;
    9523      * };
    9524      *
    9525      * var greetFred = _.partialRight(greet, 'fred');
    9526      * greetFred('hi');
    9527      * // => 'hi fred'
    9528      *
    9529      * // using placeholders
    9530      * var sayHelloTo = _.partialRight(greet, 'hello', _);
    9531      * sayHelloTo('fred');
    9532      * // => 'hello fred'
    9533      */
    9534     var partialRight = createPartial(PARTIAL_RIGHT_FLAG);
    9535 
    9536     /**
    9537      * Creates a function that invokes `func` with arguments arranged according
    9538      * to the specified indexes where the argument value at the first index is
    9539      * provided as the first argument, the argument value at the second index is
    9540      * provided as the second argument, and so on.
    9541      *
    9542      * @static
    9543      * @memberOf _
    9544      * @category Function
    9545      * @param {Function} func The function to rearrange arguments for.
    9546      * @param {...(number|number[])} indexes The arranged argument indexes,
    9547      *  specified as individual indexes or arrays of indexes.
    9548      * @returns {Function} Returns the new function.
    9549      * @example
    9550      *
    9551      * var rearged = _.rearg(function(a, b, c) {
    9552      *   return [a, b, c];
    9553      * }, 2, 0, 1);
    9554      *
    9555      * rearged('b', 'c', 'a')
    9556      * // => ['a', 'b', 'c']
    9557      *
    9558      * var map = _.rearg(_.map, [1, 0]);
    9559      * map(function(n) {
    9560      *   return n * 3;
    9561      * }, [1, 2, 3]);
    9562      * // => [3, 6, 9]
    9563      */
    9564     var rearg = restParam(function(func, indexes) {
    9565       return createWrapper(func, REARG_FLAG, null, null, null, baseFlatten(indexes));
    9566     });
    9567 
    9568     /**
    9569      * Creates a function that invokes `func` with the `this` binding of the
    9570      * created function and arguments from `start` and beyond provided as an array.
    9571      *
    9572      * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters).
    9573      *
    9574      * @static
    9575      * @memberOf _
    9576      * @category Function
    9577      * @param {Function} func The function to apply a rest parameter to.
    9578      * @param {number} [start=func.length-1] The start position of the rest parameter.
    9579      * @returns {Function} Returns the new function.
    9580      * @example
    9581      *
    9582      * var say = _.restParam(function(what, names) {
    9583      *   return what + ' ' + _.initial(names).join(', ') +
    9584      *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
    9585      * });
    9586      *
    9587      * say('hello', 'fred', 'barney', 'pebbles');
    9588      * // => 'hello fred, barney, & pebbles'
    9589      */
    9590     function restParam(func, start) {
    9591       if (typeof func != 'function') {
    9592         throw new TypeError(FUNC_ERROR_TEXT);
    9593       }
    9594       start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);
    9595       return function() {
    9596         var args = arguments,
    9597             index = -1,
    9598             length = nativeMax(args.length - start, 0),
    9599             rest = Array(length);
    9600 
    9601         while (++index < length) {
    9602           rest[index] = args[start + index];
    9603         }
    9604         switch (start) {
    9605           case 0: return func.call(this, rest);
    9606           case 1: return func.call(this, args[0], rest);
    9607           case 2: return func.call(this, args[0], args[1], rest);
    9608         }
    9609         var otherArgs = Array(start + 1);
    9610         index = -1;
    9611         while (++index < start) {
    9612           otherArgs[index] = args[index];
    9613         }
    9614         otherArgs[start] = rest;
    9615         return func.apply(this, otherArgs);
    9616       };
    9617     }
    9618 
    9619     /**
    9620      * Creates a function that invokes `func` with the `this` binding of the created
    9621      * function and an array of arguments much like [`Function#apply`](https://es5.github.io/#x15.3.4.3).
    9622      *
    9623      * **Note:** This method is based on the [spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator).
    9624      *
    9625      * @static
    9626      * @memberOf _
    9627      * @category Function
    9628      * @param {Function} func The function to spread arguments over.
    9629      * @returns {Function} Returns the new function.
    9630      * @example
    9631      *
    9632      * var say = _.spread(function(who, what) {
    9633      *   return who + ' says ' + what;
    9634      * });
    9635      *
    9636      * say(['fred', 'hello']);
    9637      * // => 'fred says hello'
    9638      *
    9639      * // with a Promise
    9640      * var numbers = Promise.all([
    9641      *   Promise.resolve(40),
    9642      *   Promise.resolve(36)
    9643      * ]);
    9644      *
    9645      * numbers.then(_.spread(function(x, y) {
    9646      *   return x + y;
    9647      * }));
    9648      * // => a Promise of 76
    9649      */
    9650     function spread(func) {
    9651       if (typeof func != 'function') {
    9652         throw new TypeError(FUNC_ERROR_TEXT);
    9653       }
    9654       return function(array) {
    9655         return func.apply(this, array);
    9656       };
    9657     }
    9658 
    9659     /**
    9660      * Creates a function that only invokes `func` at most once per every `wait`
    9661      * milliseconds. The created function comes with a `cancel` method to cancel
    9662      * delayed invocations. Provide an options object to indicate that `func`
    9663      * should be invoked on the leading and/or trailing edge of the `wait` timeout.
    9664      * Subsequent calls to the throttled function return the result of the last
    9665      * `func` call.
    9666      *
    9667      * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
    9668      * on the trailing edge of the timeout only if the the throttled function is
    9669      * invoked more than once during the `wait` timeout.
    9670      *
    9671      * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
    9672      * for details over the differences between `_.throttle` and `_.debounce`.
    9673      *
    9674      * @static
    9675      * @memberOf _
    9676      * @category Function
    9677      * @param {Function} func The function to throttle.
    9678      * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
    9679      * @param {Object} [options] The options object.
    9680      * @param {boolean} [options.leading=true] Specify invoking on the leading
    9681      *  edge of the timeout.
    9682      * @param {boolean} [options.trailing=true] Specify invoking on the trailing
    9683      *  edge of the timeout.
    9684      * @returns {Function} Returns the new throttled function.
    9685      * @example
    9686      *
    9687      * // avoid excessively updating the position while scrolling
    9688      * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
    9689      *
    9690      * // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes
    9691      * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
    9692      *   'trailing': false
    9693      * }));
    9694      *
    9695      * // cancel a trailing throttled call
    9696      * jQuery(window).on('popstate', throttled.cancel);
    9697      */
    9698     function throttle(func, wait, options) {
    9699       var leading = true,
    9700           trailing = true;
    9701 
    9702       if (typeof func != 'function') {
    9703         throw new TypeError(FUNC_ERROR_TEXT);
    9704       }
    9705       if (options === false) {
    9706         leading = false;
    9707       } else if (isObject(options)) {
    9708         leading = 'leading' in options ? !!options.leading : leading;
    9709         trailing = 'trailing' in options ? !!options.trailing : trailing;
    9710       }
    9711       debounceOptions.leading = leading;
    9712       debounceOptions.maxWait = +wait;
    9713       debounceOptions.trailing = trailing;
    9714       return debounce(func, wait, debounceOptions);
    9715     }
    9716 
    9717     /**
    9718      * Creates a function that provides `value` to the wrapper function as its
    9719      * first argument. Any additional arguments provided to the function are
    9720      * appended to those provided to the wrapper function. The wrapper is invoked
    9721      * with the `this` binding of the created function.
    9722      *
    9723      * @static
    9724      * @memberOf _
    9725      * @category Function
    9726      * @param {*} value The value to wrap.
    9727      * @param {Function} wrapper The wrapper function.
    9728      * @returns {Function} Returns the new function.
    9729      * @example
    9730      *
    9731      * var p = _.wrap(_.escape, function(func, text) {
    9732      *   return '<p>' + func(text) + '</p>';
    9733      * });
    9734      *
    9735      * p('fred, barney, & pebbles');
    9736      * // => '<p>fred, barney, &amp; pebbles</p>'
    9737      */
    9738     function wrap(value, wrapper) {
    9739       wrapper = wrapper == null ? identity : wrapper;
    9740       return createWrapper(wrapper, PARTIAL_FLAG, null, [value], []);
    9741     }
    9742 
    9743     /*------------------------------------------------------------------------*/
    9744 
    9745     /**
    9746      * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned,
    9747      * otherwise they are assigned by reference. If `customizer` is provided it is
    9748      * invoked to produce the cloned values. If `customizer` returns `undefined`
    9749      * cloning is handled by the method instead. The `customizer` is bound to
    9750      * `thisArg` and invoked with two argument; (value [, index|key, object]).
    9751      *
    9752      * **Note:** This method is loosely based on the
    9753      * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).
    9754      * The enumerable properties of `arguments` objects and objects created by
    9755      * constructors other than `Object` are cloned to plain `Object` objects. An
    9756      * empty object is returned for uncloneable values such as functions, DOM nodes,
    9757      * Maps, Sets, and WeakMaps.
    9758      *
    9759      * @static
    9760      * @memberOf _
    9761      * @category Lang
    9762      * @param {*} value The value to clone.
    9763      * @param {boolean} [isDeep] Specify a deep clone.
    9764      * @param {Function} [customizer] The function to customize cloning values.
    9765      * @param {*} [thisArg] The `this` binding of `customizer`.
    9766      * @returns {*} Returns the cloned value.
    9767      * @example
    9768      *
    9769      * var users = [
    9770      *   { 'user': 'barney' },
    9771      *   { 'user': 'fred' }
    9772      * ];
    9773      *
    9774      * var shallow = _.clone(users);
    9775      * shallow[0] === users[0];
    9776      * // => true
    9777      *
    9778      * var deep = _.clone(users, true);
    9779      * deep[0] === users[0];
    9780      * // => false
    9781      *
    9782      * // using a customizer callback
    9783      * var el = _.clone(document.body, function(value) {
    9784      *   if (_.isElement(value)) {
    9785      *     return value.cloneNode(false);
    9786      *   }
    9787      * });
    9788      *
    9789      * el === document.body
    9790      * // => false
    9791      * el.nodeName
    9792      * // => BODY
    9793      * el.childNodes.length;
    9794      * // => 0
    9795      */
    9796     function clone(value, isDeep, customizer, thisArg) {
    9797       if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) {
    9798         isDeep = false;
    9799       }
    9800       else if (typeof isDeep == 'function') {
    9801         thisArg = customizer;
    9802         customizer = isDeep;
    9803         isDeep = false;
    9804       }
    9805       customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 1);
    9806       return baseClone(value, isDeep, customizer);
    9807     }
    9808 
    9809     /**
    9810      * Creates a deep clone of `value`. If `customizer` is provided it is invoked
    9811      * to produce the cloned values. If `customizer` returns `undefined` cloning
    9812      * is handled by the method instead. The `customizer` is bound to `thisArg`
    9813      * and invoked with two argument; (value [, index|key, object]).
    9814      *
    9815      * **Note:** This method is loosely based on the
    9816      * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).
    9817      * The enumerable properties of `arguments` objects and objects created by
    9818      * constructors other than `Object` are cloned to plain `Object` objects. An
    9819      * empty object is returned for uncloneable values such as functions, DOM nodes,
    9820      * Maps, Sets, and WeakMaps.
    9821      *
    9822      * @static
    9823      * @memberOf _
    9824      * @category Lang
    9825      * @param {*} value The value to deep clone.
    9826      * @param {Function} [customizer] The function to customize cloning values.
    9827      * @param {*} [thisArg] The `this` binding of `customizer`.
    9828      * @returns {*} Returns the deep cloned value.
    9829      * @example
    9830      *
    9831      * var users = [
    9832      *   { 'user': 'barney' },
    9833      *   { 'user': 'fred' }
    9834      * ];
    9835      *
    9836      * var deep = _.cloneDeep(users);
    9837      * deep[0] === users[0];
    9838      * // => false
    9839      *
    9840      * // using a customizer callback
    9841      * var el = _.cloneDeep(document.body, function(value) {
    9842      *   if (_.isElement(value)) {
    9843      *     return value.cloneNode(true);
    9844      *   }
    9845      * });
    9846      *
    9847      * el === document.body
    9848      * // => false
    9849      * el.nodeName
    9850      * // => BODY
    9851      * el.childNodes.length;
    9852      * // => 20
    9853      */
    9854     function cloneDeep(value, customizer, thisArg) {
    9855       customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 1);
    9856       return baseClone(value, true, customizer);
    9857     }
    9858 
    9859     /**
    9860      * Checks if `value` is classified as an `arguments` object.
    9861      *
    9862      * @static
    9863      * @memberOf _
    9864      * @category Lang
    9865      * @param {*} value The value to check.
    9866      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    9867      * @example
    9868      *
    9869      * _.isArguments(function() { return arguments; }());
    9870      * // => true
    9871      *
    9872      * _.isArguments([1, 2, 3]);
    9873      * // => false
    9874      */
    9875     function isArguments(value) {
    9876       var length = isObjectLike(value) ? value.length : undefined;
    9877       return isLength(length) && objToString.call(value) == argsTag;
    9878     }
    9879 
    9880     /**
    9881      * Checks if `value` is classified as an `Array` object.
    9882      *
    9883      * @static
    9884      * @memberOf _
    9885      * @category Lang
    9886      * @param {*} value The value to check.
    9887      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    9888      * @example
    9889      *
    9890      * _.isArray([1, 2, 3]);
    9891      * // => true
    9892      *
    9893      * _.isArray(function() { return arguments; }());
    9894      * // => false
    9895      */
    9896     var isArray = nativeIsArray || function(value) {
    9897       return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
    9898     };
    9899 
    9900     /**
    9901      * Checks if `value` is classified as a boolean primitive or object.
    9902      *
    9903      * @static
    9904      * @memberOf _
    9905      * @category Lang
    9906      * @param {*} value The value to check.
    9907      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    9908      * @example
    9909      *
    9910      * _.isBoolean(false);
    9911      * // => true
    9912      *
    9913      * _.isBoolean(null);
    9914      * // => false
    9915      */
    9916     function isBoolean(value) {
    9917       return value === true || value === false || (isObjectLike(value) && objToString.call(value) == boolTag);
    9918     }
    9919 
    9920     /**
    9921      * Checks if `value` is classified as a `Date` object.
    9922      *
    9923      * @static
    9924      * @memberOf _
    9925      * @category Lang
    9926      * @param {*} value The value to check.
    9927      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    9928      * @example
    9929      *
    9930      * _.isDate(new Date);
    9931      * // => true
    9932      *
    9933      * _.isDate('Mon April 23 2012');
    9934      * // => false
    9935      */
    9936     function isDate(value) {
    9937       return isObjectLike(value) && objToString.call(value) == dateTag;
    9938     }
    9939 
    9940     /**
    9941      * Checks if `value` is a DOM element.
    9942      *
    9943      * @static
    9944      * @memberOf _
    9945      * @category Lang
    9946      * @param {*} value The value to check.
    9947      * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
    9948      * @example
    9949      *
    9950      * _.isElement(document.body);
    9951      * // => true
    9952      *
    9953      * _.isElement('<body>');
    9954      * // => false
    9955      */
    9956     function isElement(value) {
    9957       return !!value && value.nodeType === 1 && isObjectLike(value) &&
    9958         (objToString.call(value).indexOf('Element') > -1);
    9959     }
    9960     // Fallback for environments without DOM support.
    9961     if (!support.dom) {
    9962       isElement = function(value) {
    9963         return !!value && value.nodeType === 1 && isObjectLike(value) && !isPlainObject(value);
    9964       };
    9965     }
    9966 
    9967     /**
    9968      * Checks if `value` is empty. A value is considered empty unless it is an
    9969      * `arguments` object, array, string, or jQuery-like collection with a length
    9970      * greater than `0` or an object with own enumerable properties.
    9971      *
    9972      * @static
    9973      * @memberOf _
    9974      * @category Lang
    9975      * @param {Array|Object|string} value The value to inspect.
    9976      * @returns {boolean} Returns `true` if `value` is empty, else `false`.
    9977      * @example
    9978      *
    9979      * _.isEmpty(null);
    9980      * // => true
    9981      *
    9982      * _.isEmpty(true);
    9983      * // => true
    9984      *
    9985      * _.isEmpty(1);
    9986      * // => true
    9987      *
    9988      * _.isEmpty([1, 2, 3]);
    9989      * // => false
    9990      *
    9991      * _.isEmpty({ 'a': 1 });
    9992      * // => false
    9993      */
    9994     function isEmpty(value) {
    9995       if (value == null) {
    9996         return true;
    9997       }
    9998       var length = getLength(value);
    9999       if (isLength(length) && (isArray(value) || isString(value) || isArguments(value) ||
    10000           (isObjectLike(value) && isFunction(value.splice)))) {
    10001         return !length;
    10002       }
    10003       return !keys(value).length;
    10004     }
    10005 
    10006     /**
    10007      * Performs a deep comparison between two values to determine if they are
    10008      * equivalent. If `customizer` is provided it is invoked to compare values.
    10009      * If `customizer` returns `undefined` comparisons are handled by the method
    10010      * instead. The `customizer` is bound to `thisArg` and invoked with three
    10011      * arguments: (value, other [, index|key]).
    10012      *
    10013      * **Note:** This method supports comparing arrays, booleans, `Date` objects,
    10014      * numbers, `Object` objects, regexes, and strings. Objects are compared by
    10015      * their own, not inherited, enumerable properties. Functions and DOM nodes
    10016      * are **not** supported. Provide a customizer function to extend support
    10017      * for comparing other values.
    10018      *
    10019      * @static
    10020      * @memberOf _
    10021      * @category Lang
    10022      * @param {*} value The value to compare.
    10023      * @param {*} other The other value to compare.
    10024      * @param {Function} [customizer] The function to customize value comparisons.
    10025      * @param {*} [thisArg] The `this` binding of `customizer`.
    10026      * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
    10027      * @example
    10028      *
    10029      * var object = { 'user': 'fred' };
    10030      * var other = { 'user': 'fred' };
    10031      *
    10032      * object == other;
    10033      * // => false
    10034      *
    10035      * _.isEqual(object, other);
    10036      * // => true
    10037      *
    10038      * // using a customizer callback
    10039      * var array = ['hello', 'goodbye'];
    10040      * var other = ['hi', 'goodbye'];
    10041      *
    10042      * _.isEqual(array, other, function(value, other) {
    10043      *   if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) {
    10044      *     return true;
    10045      *   }
    10046      * });
    10047      * // => true
    10048      */
    10049     function isEqual(value, other, customizer, thisArg) {
    10050       customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 3);
    10051       if (!customizer && isStrictComparable(value) && isStrictComparable(other)) {
    10052         return value === other;
    10053       }
    10054       var result = customizer ? customizer(value, other) : undefined;
    10055       return result === undefined ? baseIsEqual(value, other, customizer) : !!result;
    10056     }
    10057 
    10058     /**
    10059      * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
    10060      * `SyntaxError`, `TypeError`, or `URIError` object.
    10061      *
    10062      * @static
    10063      * @memberOf _
    10064      * @category Lang
    10065      * @param {*} value The value to check.
    10066      * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
    10067      * @example
    10068      *
    10069      * _.isError(new Error);
    10070      * // => true
    10071      *
    10072      * _.isError(Error);
    10073      * // => false
    10074      */
    10075     function isError(value) {
    10076       return isObjectLike(value) && typeof value.message == 'string' && objToString.call(value) == errorTag;
    10077     }
    10078 
    10079     /**
    10080      * Checks if `value` is a finite primitive number.
    10081      *
    10082      * **Note:** This method is based on [`Number.isFinite`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isfinite).
    10083      *
    10084      * @static
    10085      * @memberOf _
    10086      * @category Lang
    10087      * @param {*} value The value to check.
    10088      * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
    10089      * @example
    10090      *
    10091      * _.isFinite(10);
    10092      * // => true
    10093      *
    10094      * _.isFinite('10');
    10095      * // => false
    10096      *
    10097      * _.isFinite(true);
    10098      * // => false
    10099      *
    10100      * _.isFinite(Object(10));
    10101      * // => false
    10102      *
    10103      * _.isFinite(Infinity);
    10104      * // => false
    10105      */
    10106     var isFinite = nativeNumIsFinite || function(value) {
    10107       return typeof value == 'number' && nativeIsFinite(value);
    10108     };
    10109 
    10110     /**
    10111      * Checks if `value` is classified as a `Function` object.
    10112      *
    10113      * @static
    10114      * @memberOf _
    10115      * @category Lang
    10116      * @param {*} value The value to check.
    10117      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    10118      * @example
    10119      *
    10120      * _.isFunction(_);
    10121      * // => true
    10122      *
    10123      * _.isFunction(/abc/);
    10124      * // => false
    10125      */
    10126     var isFunction = !(baseIsFunction(/x/) || (Uint8Array && !baseIsFunction(Uint8Array))) ? baseIsFunction : function(value) {
    10127       // The use of `Object#toString` avoids issues with the `typeof` operator
    10128       // in older versions of Chrome and Safari which return 'function' for regexes
    10129       // and Safari 8 equivalents which return 'object' for typed array constructors.
    10130       return objToString.call(value) == funcTag;
    10131     };
    10132 
    10133     /**
    10134      * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
    10135      * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
    10136      *
    10137      * @static
    10138      * @memberOf _
    10139      * @category Lang
    10140      * @param {*} value The value to check.
    10141      * @returns {boolean} Returns `true` if `value` is an object, else `false`.
    10142      * @example
    10143      *
    10144      * _.isObject({});
    10145      * // => true
    10146      *
    10147      * _.isObject([1, 2, 3]);
    10148      * // => true
    10149      *
    10150      * _.isObject(1);
    10151      * // => false
    10152      */
    10153     function isObject(value) {
    10154       // Avoid a V8 JIT bug in Chrome 19-20.
    10155       // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
    10156       var type = typeof value;
    10157       return type == 'function' || (!!value && type == 'object');
    10158     }
    10159 
    10160     /**
    10161      * Performs a deep comparison between `object` and `source` to determine if
    10162      * `object` contains equivalent property values. If `customizer` is provided
    10163      * it is invoked to compare values. If `customizer` returns `undefined`
    10164      * comparisons are handled by the method instead. The `customizer` is bound
    10165      * to `thisArg` and invoked with three arguments: (value, other, index|key).
    10166      *
    10167      * **Note:** This method supports comparing properties of arrays, booleans,
    10168      * `Date` objects, numbers, `Object` objects, regexes, and strings. Functions
    10169      * and DOM nodes are **not** supported. Provide a customizer function to extend
    10170      * support for comparing other values.
    10171      *
    10172      * @static
    10173      * @memberOf _
    10174      * @category Lang
    10175      * @param {Object} object The object to inspect.
    10176      * @param {Object} source The object of property values to match.
    10177      * @param {Function} [customizer] The function to customize value comparisons.
    10178      * @param {*} [thisArg] The `this` binding of `customizer`.
    10179      * @returns {boolean} Returns `true` if `object` is a match, else `false`.
    10180      * @example
    10181      *
    10182      * var object = { 'user': 'fred', 'age': 40 };
    10183      *
    10184      * _.isMatch(object, { 'age': 40 });
    10185      * // => true
    10186      *
    10187      * _.isMatch(object, { 'age': 36 });
    10188      * // => false
    10189      *
    10190      * // using a customizer callback
    10191      * var object = { 'greeting': 'hello' };
    10192      * var source = { 'greeting': 'hi' };
    10193      *
    10194      * _.isMatch(object, source, function(value, other) {
    10195      *   return _.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/) || undefined;
    10196      * });
    10197      * // => true
    10198      */
    10199     function isMatch(object, source, customizer, thisArg) {
    10200       var props = keys(source),
    10201           length = props.length;
    10202 
    10203       if (!length) {
    10204         return true;
    10205       }
    10206       if (object == null) {
    10207         return false;
    10208       }
    10209       customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 3);
    10210       object = toObject(object);
    10211       if (!customizer && length == 1) {
    10212         var key = props[0],
    10213             value = source[key];
    10214 
    10215         if (isStrictComparable(value)) {
    10216           return value === object[key] && (value !== undefined || (key in object));
    10217         }
    10218       }
    10219       var values = Array(length),
    10220           strictCompareFlags = Array(length);
    10221 
    10222       while (length--) {
    10223         value = values[length] = source[props[length]];
    10224         strictCompareFlags[length] = isStrictComparable(value);
    10225       }
    10226       return baseIsMatch(object, props, values, strictCompareFlags, customizer);
    10227     }
    10228 
    10229     /**
    10230      * Checks if `value` is `NaN`.
    10231      *
    10232      * **Note:** This method is not the same as [`isNaN`](https://es5.github.io/#x15.1.2.4)
    10233      * which returns `true` for `undefined` and other non-numeric values.
    10234      *
    10235      * @static
    10236      * @memberOf _
    10237      * @category Lang
    10238      * @param {*} value The value to check.
    10239      * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
    10240      * @example
    10241      *
    10242      * _.isNaN(NaN);
    10243      * // => true
    10244      *
    10245      * _.isNaN(new Number(NaN));
    10246      * // => true
    10247      *
    10248      * isNaN(undefined);
    10249      * // => true
    10250      *
    10251      * _.isNaN(undefined);
    10252      * // => false
    10253      */
    10254     function isNaN(value) {
    10255       // An `NaN` primitive is the only value that is not equal to itself.
    10256       // Perform the `toStringTag` check first to avoid errors with some host objects in IE.
    10257       return isNumber(value) && value != +value;
    10258     }
    10259 
    10260     /**
    10261      * Checks if `value` is a native function.
    10262      *
    10263      * @static
    10264      * @memberOf _
    10265      * @category Lang
    10266      * @param {*} value The value to check.
    10267      * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
    10268      * @example
    10269      *
    10270      * _.isNative(Array.prototype.push);
    10271      * // => true
    10272      *
    10273      * _.isNative(_);
    10274      * // => false
    10275      */
    10276     function isNative(value) {
    10277       if (value == null) {
    10278         return false;
    10279       }
    10280       if (objToString.call(value) == funcTag) {
    10281         return reIsNative.test(fnToString.call(value));
    10282       }
    10283       return isObjectLike(value) && reIsHostCtor.test(value);
    10284     }
    10285 
    10286     /**
    10287      * Checks if `value` is `null`.
    10288      *
    10289      * @static
    10290      * @memberOf _
    10291      * @category Lang
    10292      * @param {*} value The value to check.
    10293      * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
    10294      * @example
    10295      *
    10296      * _.isNull(null);
    10297      * // => true
    10298      *
    10299      * _.isNull(void 0);
    10300      * // => false
    10301      */
    10302     function isNull(value) {
    10303       return value === null;
    10304     }
    10305 
    10306     /**
    10307      * Checks if `value` is classified as a `Number` primitive or object.
    10308      *
    10309      * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified
    10310      * as numbers, use the `_.isFinite` method.
    10311      *
    10312      * @static
    10313      * @memberOf _
    10314      * @category Lang
    10315      * @param {*} value The value to check.
    10316      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    10317      * @example
    10318      *
    10319      * _.isNumber(8.4);
    10320      * // => true
    10321      *
    10322      * _.isNumber(NaN);
    10323      * // => true
    10324      *
    10325      * _.isNumber('8.4');
    10326      * // => false
    10327      */
    10328     function isNumber(value) {
    10329       return typeof value == 'number' || (isObjectLike(value) && objToString.call(value) == numberTag);
    10330     }
    10331 
    10332     /**
    10333      * Checks if `value` is a plain object, that is, an object created by the
    10334      * `Object` constructor or one with a `[[Prototype]]` of `null`.
    10335      *
    10336      * **Note:** This method assumes objects created by the `Object` constructor
    10337      * have no inherited enumerable properties.
    10338      *
    10339      * @static
    10340      * @memberOf _
    10341      * @category Lang
    10342      * @param {*} value The value to check.
    10343      * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
    10344      * @example
    10345      *
    10346      * function Foo() {
    10347      *   this.a = 1;
    10348      * }
    10349      *
    10350      * _.isPlainObject(new Foo);
    10351      * // => false
    10352      *
    10353      * _.isPlainObject([1, 2, 3]);
    10354      * // => false
    10355      *
    10356      * _.isPlainObject({ 'x': 0, 'y': 0 });
    10357      * // => true
    10358      *
    10359      * _.isPlainObject(Object.create(null));
    10360      * // => true
    10361      */
    10362     var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) {
    10363       if (!(value && objToString.call(value) == objectTag)) {
    10364         return false;
    10365       }
    10366       var valueOf = value.valueOf,
    10367           objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
    10368 
    10369       return objProto
    10370         ? (value == objProto || getPrototypeOf(value) == objProto)
    10371         : shimIsPlainObject(value);
    10372     };
    10373 
    10374     /**
    10375      * Checks if `value` is classified as a `RegExp` object.
    10376      *
    10377      * @static
    10378      * @memberOf _
    10379      * @category Lang
    10380      * @param {*} value The value to check.
    10381      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    10382      * @example
    10383      *
    10384      * _.isRegExp(/abc/);
    10385      * // => true
    10386      *
    10387      * _.isRegExp('/abc/');
    10388      * // => false
    10389      */
    10390     function isRegExp(value) {
    10391       return (isObjectLike(value) && objToString.call(value) == regexpTag) || false;
    10392     }
    10393 
    10394     /**
    10395      * Checks if `value` is classified as a `String` primitive or object.
    10396      *
    10397      * @static
    10398      * @memberOf _
    10399      * @category Lang
    10400      * @param {*} value The value to check.
    10401      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    10402      * @example
    10403      *
    10404      * _.isString('abc');
    10405      * // => true
    10406      *
    10407      * _.isString(1);
    10408      * // => false
    10409      */
    10410     function isString(value) {
    10411       return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);
    10412     }
    10413 
    10414     /**
    10415      * Checks if `value` is classified as a typed array.
    10416      *
    10417      * @static
    10418      * @memberOf _
    10419      * @category Lang
    10420      * @param {*} value The value to check.
    10421      * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
    10422      * @example
    10423      *
    10424      * _.isTypedArray(new Uint8Array);
    10425      * // => true
    10426      *
    10427      * _.isTypedArray([]);
    10428      * // => false
    10429      */
    10430     function isTypedArray(value) {
    10431       return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
    10432     }
    10433 
    10434     /**
    10435      * Checks if `value` is `undefined`.
    10436      *
    10437      * @static
    10438      * @memberOf _
    10439      * @category Lang
    10440      * @param {*} value The value to check.
    10441      * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
    10442      * @example
    10443      *
    10444      * _.isUndefined(void 0);
    10445      * // => true
    10446      *
    10447      * _.isUndefined(null);
    10448      * // => false
    10449      */
    10450     function isUndefined(value) {
    10451       return value === undefined;
    10452     }
    10453 
    10454     /**
    10455      * Converts `value` to an array.
    10456      *
    10457      * @static
    10458      * @memberOf _
    10459      * @category Lang
    10460      * @param {*} value The value to convert.
    10461      * @returns {Array} Returns the converted array.
    10462      * @example
    10463      *
    10464      * (function() {
    10465      *   return _.toArray(arguments).slice(1);
    10466      * }(1, 2, 3));
    10467      * // => [2, 3]
    10468      */
    10469     function toArray(value) {
    10470       var length = value ? getLength(value) : 0;
    10471       if (!isLength(length)) {
    10472         return values(value);
    10473       }
    10474       if (!length) {
    10475         return [];
    10476       }
    10477       return arrayCopy(value);
    10478     }
    10479 
    10480     /**
    10481      * Converts `value` to a plain object flattening inherited enumerable
    10482      * properties of `value` to own properties of the plain object.
    10483      *
    10484      * @static
    10485      * @memberOf _
    10486      * @category Lang
    10487      * @param {*} value The value to convert.
    10488      * @returns {Object} Returns the converted plain object.
    10489      * @example
    10490      *
    10491      * function Foo() {
    10492      *   this.b = 2;
    10493      * }
    10494      *
    10495      * Foo.prototype.c = 3;
    10496      *
    10497      * _.assign({ 'a': 1 }, new Foo);
    10498      * // => { 'a': 1, 'b': 2 }
    10499      *
    10500      * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
    10501      * // => { 'a': 1, 'b': 2, 'c': 3 }
    10502      */
    10503     function toPlainObject(value) {
    10504       return baseCopy(value, keysIn(value));
    10505     }
    10506 
    10507     /*------------------------------------------------------------------------*/
    10508 
    10509     /**
    10510      * Assigns own enumerable properties of source object(s) to the destination
    10511      * object. Subsequent sources overwrite property assignments of previous sources.
    10512      * If `customizer` is provided it is invoked to produce the assigned values.
    10513      * The `customizer` is bound to `thisArg` and invoked with five arguments:
    10514      * (objectValue, sourceValue, key, object, source).
    10515      *
    10516      * **Note:** This method mutates `object` and is based on
    10517      * [`Object.assign`](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign).
    10518      *
    10519      *
    10520      * @static
    10521      * @memberOf _
    10522      * @alias extend
    10523      * @category Object
    10524      * @param {Object} object The destination object.
    10525      * @param {...Object} [sources] The source objects.
    10526      * @param {Function} [customizer] The function to customize assigned values.
    10527      * @param {*} [thisArg] The `this` binding of `customizer`.
    10528      * @returns {Object} Returns `object`.
    10529      * @example
    10530      *
    10531      * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });
    10532      * // => { 'user': 'fred', 'age': 40 }
    10533      *
    10534      * // using a customizer callback
    10535      * var defaults = _.partialRight(_.assign, function(value, other) {
    10536      *   return _.isUndefined(value) ? other : value;
    10537      * });
    10538      *
    10539      * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
    10540      * // => { 'user': 'barney', 'age': 36 }
    10541      */
    10542     var assign = createAssigner(function(object, source, customizer) {
    10543       return customizer
    10544         ? assignWith(object, source, customizer)
    10545         : baseAssign(object, source);
    10546     });
    10547 
    10548     /**
    10549      * Creates an object that inherits from the given `prototype` object. If a
    10550      * `properties` object is provided its own enumerable properties are assigned
    10551      * to the created object.
    10552      *
    10553      * @static
    10554      * @memberOf _
    10555      * @category Object
    10556      * @param {Object} prototype The object to inherit from.
    10557      * @param {Object} [properties] The properties to assign to the object.
    10558      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    10559      * @returns {Object} Returns the new object.
    10560      * @example
    10561      *
    10562      * function Shape() {
    10563      *   this.x = 0;
    10564      *   this.y = 0;
    10565      * }
    10566      *
    10567      * function Circle() {
    10568      *   Shape.call(this);
    10569      * }
    10570      *
    10571      * Circle.prototype = _.create(Shape.prototype, {
    10572      *   'constructor': Circle
    10573      * });
    10574      *
    10575      * var circle = new Circle;
    10576      * circle instanceof Circle;
    10577      * // => true
    10578      *
    10579      * circle instanceof Shape;
    10580      * // => true
    10581      */
    10582     function create(prototype, properties, guard) {
    10583       var result = baseCreate(prototype);
    10584       if (guard && isIterateeCall(prototype, properties, guard)) {
    10585         properties = null;
    10586       }
    10587       return properties ? baseAssign(result, properties) : result;
    10588     }
    10589 
    10590     /**
    10591      * Assigns own enumerable properties of source object(s) to the destination
    10592      * object for all destination properties that resolve to `undefined`. Once a
    10593      * property is set, additional values of the same property are ignored.
    10594      *
    10595      * **Note:** This method mutates `object`.
    10596      *
    10597      * @static
    10598      * @memberOf _
    10599      * @category Object
    10600      * @param {Object} object The destination object.
    10601      * @param {...Object} [sources] The source objects.
    10602      * @returns {Object} Returns `object`.
    10603      * @example
    10604      *
    10605      * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });
    10606      * // => { 'user': 'barney', 'age': 36 }
    10607      */
    10608     var defaults = restParam(function(args) {
    10609       var object = args[0];
    10610       if (object == null) {
    10611         return object;
    10612       }
    10613       args.push(assignDefaults);
    10614       return assign.apply(undefined, args);
    10615     });
    10616 
    10617     /**
    10618      * This method is like `_.find` except that it returns the key of the first
    10619      * element `predicate` returns truthy for instead of the element itself.
    10620      *
    10621      * If a property name is provided for `predicate` the created `_.property`
    10622      * style callback returns the property value of the given element.
    10623      *
    10624      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    10625      * style callback returns `true` for elements that have a matching property
    10626      * value, else `false`.
    10627      *
    10628      * If an object is provided for `predicate` the created `_.matches` style
    10629      * callback returns `true` for elements that have the properties of the given
    10630      * object, else `false`.
    10631      *
    10632      * @static
    10633      * @memberOf _
    10634      * @category Object
    10635      * @param {Object} object The object to search.
    10636      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    10637      *  per iteration.
    10638      * @param {*} [thisArg] The `this` binding of `predicate`.
    10639      * @returns {string|undefined} Returns the key of the matched element, else `undefined`.
    10640      * @example
    10641      *
    10642      * var users = {
    10643      *   'barney':  { 'age': 36, 'active': true },
    10644      *   'fred':    { 'age': 40, 'active': false },
    10645      *   'pebbles': { 'age': 1,  'active': true }
    10646      * };
    10647      *
    10648      * _.findKey(users, function(chr) {
    10649      *   return chr.age < 40;
    10650      * });
    10651      * // => 'barney' (iteration order is not guaranteed)
    10652      *
    10653      * // using the `_.matches` callback shorthand
    10654      * _.findKey(users, { 'age': 1, 'active': true });
    10655      * // => 'pebbles'
    10656      *
    10657      * // using the `_.matchesProperty` callback shorthand
    10658      * _.findKey(users, 'active', false);
    10659      * // => 'fred'
    10660      *
    10661      * // using the `_.property` callback shorthand
    10662      * _.findKey(users, 'active');
    10663      * // => 'barney'
    10664      */
    10665     var findKey = createFindKey(baseForOwn);
    10666 
    10667     /**
    10668      * This method is like `_.findKey` except that it iterates over elements of
    10669      * a collection in the opposite order.
    10670      *
    10671      * If a property name is provided for `predicate` the created `_.property`
    10672      * style callback returns the property value of the given element.
    10673      *
    10674      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    10675      * style callback returns `true` for elements that have a matching property
    10676      * value, else `false`.
    10677      *
    10678      * If an object is provided for `predicate` the created `_.matches` style
    10679      * callback returns `true` for elements that have the properties of the given
    10680      * object, else `false`.
    10681      *
    10682      * @static
    10683      * @memberOf _
    10684      * @category Object
    10685      * @param {Object} object The object to search.
    10686      * @param {Function|Object|string} [predicate=_.identity] The function invoked
    10687      *  per iteration.
    10688      * @param {*} [thisArg] The `this` binding of `predicate`.
    10689      * @returns {string|undefined} Returns the key of the matched element, else `undefined`.
    10690      * @example
    10691      *
    10692      * var users = {
    10693      *   'barney':  { 'age': 36, 'active': true },
    10694      *   'fred':    { 'age': 40, 'active': false },
    10695      *   'pebbles': { 'age': 1,  'active': true }
    10696      * };
    10697      *
    10698      * _.findLastKey(users, function(chr) {
    10699      *   return chr.age < 40;
    10700      * });
    10701      * // => returns `pebbles` assuming `_.findKey` returns `barney`
    10702      *
    10703      * // using the `_.matches` callback shorthand
    10704      * _.findLastKey(users, { 'age': 36, 'active': true });
    10705      * // => 'barney'
    10706      *
    10707      * // using the `_.matchesProperty` callback shorthand
    10708      * _.findLastKey(users, 'active', false);
    10709      * // => 'fred'
    10710      *
    10711      * // using the `_.property` callback shorthand
    10712      * _.findLastKey(users, 'active');
    10713      * // => 'pebbles'
    10714      */
    10715     var findLastKey = createFindKey(baseForOwnRight);
    10716 
    10717     /**
    10718      * Iterates over own and inherited enumerable properties of an object invoking
    10719      * `iteratee` for each property. The `iteratee` is bound to `thisArg` and invoked
    10720      * with three arguments: (value, key, object). Iteratee functions may exit
    10721      * iteration early by explicitly returning `false`.
    10722      *
    10723      * @static
    10724      * @memberOf _
    10725      * @category Object
    10726      * @param {Object} object The object to iterate over.
    10727      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    10728      * @param {*} [thisArg] The `this` binding of `iteratee`.
    10729      * @returns {Object} Returns `object`.
    10730      * @example
    10731      *
    10732      * function Foo() {
    10733      *   this.a = 1;
    10734      *   this.b = 2;
    10735      * }
    10736      *
    10737      * Foo.prototype.c = 3;
    10738      *
    10739      * _.forIn(new Foo, function(value, key) {
    10740      *   console.log(key);
    10741      * });
    10742      * // => logs 'a', 'b', and 'c' (iteration order is not guaranteed)
    10743      */
    10744     var forIn = createForIn(baseFor);
    10745 
    10746     /**
    10747      * This method is like `_.forIn` except that it iterates over properties of
    10748      * `object` in the opposite order.
    10749      *
    10750      * @static
    10751      * @memberOf _
    10752      * @category Object
    10753      * @param {Object} object The object to iterate over.
    10754      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    10755      * @param {*} [thisArg] The `this` binding of `iteratee`.
    10756      * @returns {Object} Returns `object`.
    10757      * @example
    10758      *
    10759      * function Foo() {
    10760      *   this.a = 1;
    10761      *   this.b = 2;
    10762      * }
    10763      *
    10764      * Foo.prototype.c = 3;
    10765      *
    10766      * _.forInRight(new Foo, function(value, key) {
    10767      *   console.log(key);
    10768      * });
    10769      * // => logs 'c', 'b', and 'a' assuming `_.forIn ` logs 'a', 'b', and 'c'
    10770      */
    10771     var forInRight = createForIn(baseForRight);
    10772 
    10773     /**
    10774      * Iterates over own enumerable properties of an object invoking `iteratee`
    10775      * for each property. The `iteratee` is bound to `thisArg` and invoked with
    10776      * three arguments: (value, key, object). Iteratee functions may exit iteration
    10777      * early by explicitly returning `false`.
    10778      *
    10779      * @static
    10780      * @memberOf _
    10781      * @category Object
    10782      * @param {Object} object The object to iterate over.
    10783      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    10784      * @param {*} [thisArg] The `this` binding of `iteratee`.
    10785      * @returns {Object} Returns `object`.
    10786      * @example
    10787      *
    10788      * function Foo() {
    10789      *   this.a = 1;
    10790      *   this.b = 2;
    10791      * }
    10792      *
    10793      * Foo.prototype.c = 3;
    10794      *
    10795      * _.forOwn(new Foo, function(value, key) {
    10796      *   console.log(key);
    10797      * });
    10798      * // => logs 'a' and 'b' (iteration order is not guaranteed)
    10799      */
    10800     var forOwn = createForOwn(baseForOwn);
    10801 
    10802     /**
    10803      * This method is like `_.forOwn` except that it iterates over properties of
    10804      * `object` in the opposite order.
    10805      *
    10806      * @static
    10807      * @memberOf _
    10808      * @category Object
    10809      * @param {Object} object The object to iterate over.
    10810      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    10811      * @param {*} [thisArg] The `this` binding of `iteratee`.
    10812      * @returns {Object} Returns `object`.
    10813      * @example
    10814      *
    10815      * function Foo() {
    10816      *   this.a = 1;
    10817      *   this.b = 2;
    10818      * }
    10819      *
    10820      * Foo.prototype.c = 3;
    10821      *
    10822      * _.forOwnRight(new Foo, function(value, key) {
    10823      *   console.log(key);
    10824      * });
    10825      * // => logs 'b' and 'a' assuming `_.forOwn` logs 'a' and 'b'
    10826      */
    10827     var forOwnRight = createForOwn(baseForOwnRight);
    10828 
    10829     /**
    10830      * Creates an array of function property names from all enumerable properties,
    10831      * own and inherited, of `object`.
    10832      *
    10833      * @static
    10834      * @memberOf _
    10835      * @alias methods
    10836      * @category Object
    10837      * @param {Object} object The object to inspect.
    10838      * @returns {Array} Returns the new array of property names.
    10839      * @example
    10840      *
    10841      * _.functions(_);
    10842      * // => ['after', 'ary', 'assign', ...]
    10843      */
    10844     function functions(object) {
    10845       return baseFunctions(object, keysIn(object));
    10846     }
    10847 
    10848     /**
    10849      * Gets the property value of `path` on `object`. If the resolved value is
    10850      * `undefined` the `defaultValue` is used in its place.
    10851      *
    10852      * @static
    10853      * @memberOf _
    10854      * @category Object
    10855      * @param {Object} object The object to query.
    10856      * @param {Array|string} path The path of the property to get.
    10857      * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.
    10858      * @returns {*} Returns the resolved value.
    10859      * @example
    10860      *
    10861      * var object = { 'a': [{ 'b': { 'c': 3 } }] };
    10862      *
    10863      * _.get(object, 'a[0].b.c');
    10864      * // => 3
    10865      *
    10866      * _.get(object, ['a', '0', 'b', 'c']);
    10867      * // => 3
    10868      *
    10869      * _.get(object, 'a.b.c', 'default');
    10870      * // => 'default'
    10871      */
    10872     function get(object, path, defaultValue) {
    10873       var result = object == null ? undefined : baseGet(object, toPath(path), path + '');
    10874       return result === undefined ? defaultValue : result;
    10875     }
    10876 
    10877     /**
    10878      * Checks if `path` is a direct property.
    10879      *
    10880      * @static
    10881      * @memberOf _
    10882      * @category Object
    10883      * @param {Object} object The object to query.
    10884      * @param {Array|string} path The path to check.
    10885      * @returns {boolean} Returns `true` if `path` is a direct property, else `false`.
    10886      * @example
    10887      *
    10888      * var object = { 'a': { 'b': { 'c': 3 } } };
    10889      *
    10890      * _.has(object, 'a');
    10891      * // => true
    10892      *
    10893      * _.has(object, 'a.b.c');
    10894      * // => true
    10895      *
    10896      * _.has(object, ['a', 'b', 'c']);
    10897      * // => true
    10898      */
    10899     function has(object, path) {
    10900       if (object == null) {
    10901         return false;
    10902       }
    10903       var result = hasOwnProperty.call(object, path);
    10904       if (!result && !isKey(path)) {
    10905         path = toPath(path);
    10906         object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
    10907         path = last(path);
    10908         result = object != null && hasOwnProperty.call(object, path);
    10909       }
    10910       return result;
    10911     }
    10912 
    10913     /**
    10914      * Creates an object composed of the inverted keys and values of `object`.
    10915      * If `object` contains duplicate values, subsequent values overwrite property
    10916      * assignments of previous values unless `multiValue` is `true`.
    10917      *
    10918      * @static
    10919      * @memberOf _
    10920      * @category Object
    10921      * @param {Object} object The object to invert.
    10922      * @param {boolean} [multiValue] Allow multiple values per key.
    10923      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    10924      * @returns {Object} Returns the new inverted object.
    10925      * @example
    10926      *
    10927      * var object = { 'a': 1, 'b': 2, 'c': 1 };
    10928      *
    10929      * _.invert(object);
    10930      * // => { '1': 'c', '2': 'b' }
    10931      *
    10932      * // with `multiValue`
    10933      * _.invert(object, true);
    10934      * // => { '1': ['a', 'c'], '2': ['b'] }
    10935      */
    10936     function invert(object, multiValue, guard) {
    10937       if (guard && isIterateeCall(object, multiValue, guard)) {
    10938         multiValue = null;
    10939       }
    10940       var index = -1,
    10941           props = keys(object),
    10942           length = props.length,
    10943           result = {};
    10944 
    10945       while (++index < length) {
    10946         var key = props[index],
    10947             value = object[key];
    10948 
    10949         if (multiValue) {
    10950           if (hasOwnProperty.call(result, value)) {
    10951             result[value].push(key);
    10952           } else {
    10953             result[value] = [key];
    10954           }
    10955         }
    10956         else {
    10957           result[value] = key;
    10958         }
    10959       }
    10960       return result;
    10961     }
    10962 
    10963     /**
    10964      * Creates an array of the own enumerable property names of `object`.
    10965      *
    10966      * **Note:** Non-object values are coerced to objects. See the
    10967      * [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.keys)
    10968      * for more details.
    10969      *
    10970      * @static
    10971      * @memberOf _
    10972      * @category Object
    10973      * @param {Object} object The object to query.
    10974      * @returns {Array} Returns the array of property names.
    10975      * @example
    10976      *
    10977      * function Foo() {
    10978      *   this.a = 1;
    10979      *   this.b = 2;
    10980      * }
    10981      *
    10982      * Foo.prototype.c = 3;
    10983      *
    10984      * _.keys(new Foo);
    10985      * // => ['a', 'b'] (iteration order is not guaranteed)
    10986      *
    10987      * _.keys('hi');
    10988      * // => ['0', '1']
    10989      */
    10990     var keys = !nativeKeys ? shimKeys : function(object) {
    10991       if (object) {
    10992         var Ctor = object.constructor,
    10993             length = object.length;
    10994       }
    10995       if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
    10996           (typeof object != 'function' && isLength(length))) {
    10997         return shimKeys(object);
    10998       }
    10999       return isObject(object) ? nativeKeys(object) : [];
    11000     };
    11001 
    11002     /**
    11003      * Creates an array of the own and inherited enumerable property names of `object`.
    11004      *
    11005      * **Note:** Non-object values are coerced to objects.
    11006      *
    11007      * @static
    11008      * @memberOf _
    11009      * @category Object
    11010      * @param {Object} object The object to query.
    11011      * @returns {Array} Returns the array of property names.
    11012      * @example
    11013      *
    11014      * function Foo() {
    11015      *   this.a = 1;
    11016      *   this.b = 2;
    11017      * }
    11018      *
    11019      * Foo.prototype.c = 3;
    11020      *
    11021      * _.keysIn(new Foo);
    11022      * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
    11023      */
    11024     function keysIn(object) {
    11025       if (object == null) {
    11026         return [];
    11027       }
    11028       if (!isObject(object)) {
    11029         object = Object(object);
    11030       }
    11031       var length = object.length;
    11032       length = (length && isLength(length) &&
    11033         (isArray(object) || (support.nonEnumArgs && isArguments(object))) && length) || 0;
    11034 
    11035       var Ctor = object.constructor,
    11036           index = -1,
    11037           isProto = typeof Ctor == 'function' && Ctor.prototype === object,
    11038           result = Array(length),
    11039           skipIndexes = length > 0;
    11040 
    11041       while (++index < length) {
    11042         result[index] = (index + '');
    11043       }
    11044       for (var key in object) {
    11045         if (!(skipIndexes && isIndex(key, length)) &&
    11046             !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
    11047           result.push(key);
    11048         }
    11049       }
    11050       return result;
    11051     }
    11052 
    11053     /**
    11054      * Creates an object with the same keys as `object` and values generated by
    11055      * running each own enumerable property of `object` through `iteratee`. The
    11056      * iteratee function is bound to `thisArg` and invoked with three arguments:
    11057      * (value, key, object).
    11058      *
    11059      * If a property name is provided for `iteratee` the created `_.property`
    11060      * style callback returns the property value of the given element.
    11061      *
    11062      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    11063      * style callback returns `true` for elements that have a matching property
    11064      * value, else `false`.
    11065      *
    11066      * If an object is provided for `iteratee` the created `_.matches` style
    11067      * callback returns `true` for elements that have the properties of the given
    11068      * object, else `false`.
    11069      *
    11070      * @static
    11071      * @memberOf _
    11072      * @category Object
    11073      * @param {Object} object The object to iterate over.
    11074      * @param {Function|Object|string} [iteratee=_.identity] The function invoked
    11075      *  per iteration.
    11076      * @param {*} [thisArg] The `this` binding of `iteratee`.
    11077      * @returns {Object} Returns the new mapped object.
    11078      * @example
    11079      *
    11080      * _.mapValues({ 'a': 1, 'b': 2 }, function(n) {
    11081      *   return n * 3;
    11082      * });
    11083      * // => { 'a': 3, 'b': 6 }
    11084      *
    11085      * var users = {
    11086      *   'fred':    { 'user': 'fred',    'age': 40 },
    11087      *   'pebbles': { 'user': 'pebbles', 'age': 1 }
    11088      * };
    11089      *
    11090      * // using the `_.property` callback shorthand
    11091      * _.mapValues(users, 'age');
    11092      * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
    11093      */
    11094     function mapValues(object, iteratee, thisArg) {
    11095       var result = {};
    11096       iteratee = getCallback(iteratee, thisArg, 3);
    11097 
    11098       baseForOwn(object, function(value, key, object) {
    11099         result[key] = iteratee(value, key, object);
    11100       });
    11101       return result;
    11102     }
    11103 
    11104     /**
    11105      * Recursively merges own enumerable properties of the source object(s), that
    11106      * don't resolve to `undefined` into the destination object. Subsequent sources
    11107      * overwrite property assignments of previous sources. If `customizer` is
    11108      * provided it is invoked to produce the merged values of the destination and
    11109      * source properties. If `customizer` returns `undefined` merging is handled
    11110      * by the method instead. The `customizer` is bound to `thisArg` and invoked
    11111      * with five arguments: (objectValue, sourceValue, key, object, source).
    11112      *
    11113      * @static
    11114      * @memberOf _
    11115      * @category Object
    11116      * @param {Object} object The destination object.
    11117      * @param {...Object} [sources] The source objects.
    11118      * @param {Function} [customizer] The function to customize assigned values.
    11119      * @param {*} [thisArg] The `this` binding of `customizer`.
    11120      * @returns {Object} Returns `object`.
    11121      * @example
    11122      *
    11123      * var users = {
    11124      *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
    11125      * };
    11126      *
    11127      * var ages = {
    11128      *   'data': [{ 'age': 36 }, { 'age': 40 }]
    11129      * };
    11130      *
    11131      * _.merge(users, ages);
    11132      * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
    11133      *
    11134      * // using a customizer callback
    11135      * var object = {
    11136      *   'fruits': ['apple'],
    11137      *   'vegetables': ['beet']
    11138      * };
    11139      *
    11140      * var other = {
    11141      *   'fruits': ['banana'],
    11142      *   'vegetables': ['carrot']
    11143      * };
    11144      *
    11145      * _.merge(object, other, function(a, b) {
    11146      *   if (_.isArray(a)) {
    11147      *     return a.concat(b);
    11148      *   }
    11149      * });
    11150      * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
    11151      */
    11152     var merge = createAssigner(baseMerge);
    11153 
    11154     /**
    11155      * The opposite of `_.pick`; this method creates an object composed of the
    11156      * own and inherited enumerable properties of `object` that are not omitted.
    11157      * Property names may be specified as individual arguments or as arrays of
    11158      * property names. If `predicate` is provided it is invoked for each property
    11159      * of `object` omitting the properties `predicate` returns truthy for. The
    11160      * predicate is bound to `thisArg` and invoked with three arguments:
    11161      * (value, key, object).
    11162      *
    11163      * @static
    11164      * @memberOf _
    11165      * @category Object
    11166      * @param {Object} object The source object.
    11167      * @param {Function|...(string|string[])} [predicate] The function invoked per
    11168      *  iteration or property names to omit, specified as individual property
    11169      *  names or arrays of property names.
    11170      * @param {*} [thisArg] The `this` binding of `predicate`.
    11171      * @returns {Object} Returns the new object.
    11172      * @example
    11173      *
    11174      * var object = { 'user': 'fred', 'age': 40 };
    11175      *
    11176      * _.omit(object, 'age');
    11177      * // => { 'user': 'fred' }
    11178      *
    11179      * _.omit(object, _.isNumber);
    11180      * // => { 'user': 'fred' }
    11181      */
    11182     var omit = restParam(function(object, props) {
    11183       if (object == null) {
    11184         return {};
    11185       }
    11186       if (typeof props[0] != 'function') {
    11187         var props = arrayMap(baseFlatten(props), String);
    11188         return pickByArray(object, baseDifference(keysIn(object), props));
    11189       }
    11190       var predicate = bindCallback(props[0], props[1], 3);
    11191       return pickByCallback(object, function(value, key, object) {
    11192         return !predicate(value, key, object);
    11193       });
    11194     });
    11195 
    11196     /**
    11197      * Creates a two dimensional array of the key-value pairs for `object`,
    11198      * e.g. `[[key1, value1], [key2, value2]]`.
    11199      *
    11200      * @static
    11201      * @memberOf _
    11202      * @category Object
    11203      * @param {Object} object The object to query.
    11204      * @returns {Array} Returns the new array of key-value pairs.
    11205      * @example
    11206      *
    11207      * _.pairs({ 'barney': 36, 'fred': 40 });
    11208      * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)
    11209      */
    11210     function pairs(object) {
    11211       var index = -1,
    11212           props = keys(object),
    11213           length = props.length,
    11214           result = Array(length);
    11215 
    11216       while (++index < length) {
    11217         var key = props[index];
    11218         result[index] = [key, object[key]];
    11219       }
    11220       return result;
    11221     }
    11222 
    11223     /**
    11224      * Creates an object composed of the picked `object` properties. Property
    11225      * names may be specified as individual arguments or as arrays of property
    11226      * names. If `predicate` is provided it is invoked for each property of `object`
    11227      * picking the properties `predicate` returns truthy for. The predicate is
    11228      * bound to `thisArg` and invoked with three arguments: (value, key, object).
    11229      *
    11230      * @static
    11231      * @memberOf _
    11232      * @category Object
    11233      * @param {Object} object The source object.
    11234      * @param {Function|...(string|string[])} [predicate] The function invoked per
    11235      *  iteration or property names to pick, specified as individual property
    11236      *  names or arrays of property names.
    11237      * @param {*} [thisArg] The `this` binding of `predicate`.
    11238      * @returns {Object} Returns the new object.
    11239      * @example
    11240      *
    11241      * var object = { 'user': 'fred', 'age': 40 };
    11242      *
    11243      * _.pick(object, 'user');
    11244      * // => { 'user': 'fred' }
    11245      *
    11246      * _.pick(object, _.isString);
    11247      * // => { 'user': 'fred' }
    11248      */
    11249     var pick = restParam(function(object, props) {
    11250       if (object == null) {
    11251         return {};
    11252       }
    11253       return typeof props[0] == 'function'
    11254         ? pickByCallback(object, bindCallback(props[0], props[1], 3))
    11255         : pickByArray(object, baseFlatten(props));
    11256     });
    11257 
    11258     /**
    11259      * This method is like `_.get` except that if the resolved value is a function
    11260      * it is invoked with the `this` binding of its parent object and its result
    11261      * is returned.
    11262      *
    11263      * @static
    11264      * @memberOf _
    11265      * @category Object
    11266      * @param {Object} object The object to query.
    11267      * @param {Array|string} path The path of the property to resolve.
    11268      * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.
    11269      * @returns {*} Returns the resolved value.
    11270      * @example
    11271      *
    11272      * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
    11273      *
    11274      * _.result(object, 'a[0].b.c1');
    11275      * // => 3
    11276      *
    11277      * _.result(object, 'a[0].b.c2');
    11278      * // => 4
    11279      *
    11280      * _.result(object, 'a.b.c', 'default');
    11281      * // => 'default'
    11282      *
    11283      * _.result(object, 'a.b.c', _.constant('default'));
    11284      * // => 'default'
    11285      */
    11286     function result(object, path, defaultValue) {
    11287       var result = object == null ? undefined : object[path];
    11288       if (result === undefined) {
    11289         if (object != null && !isKey(path, object)) {
    11290           path = toPath(path);
    11291           object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));
    11292           result = object == null ? undefined : object[last(path)];
    11293         }
    11294         result = result === undefined ? defaultValue : result;
    11295       }
    11296       return isFunction(result) ? result.call(object) : result;
    11297     }
    11298 
    11299     /**
    11300      * Sets the property value of `path` on `object`. If a portion of `path`
    11301      * does not exist it is created.
    11302      *
    11303      * @static
    11304      * @memberOf _
    11305      * @category Object
    11306      * @param {Object} object The object to augment.
    11307      * @param {Array|string} path The path of the property to set.
    11308      * @param {*} value The value to set.
    11309      * @returns {Object} Returns `object`.
    11310      * @example
    11311      *
    11312      * var object = { 'a': [{ 'b': { 'c': 3 } }] };
    11313      *
    11314      * _.set(object, 'a[0].b.c', 4);
    11315      * console.log(object.a[0].b.c);
    11316      * // => 4
    11317      *
    11318      * _.set(object, 'x[0].y.z', 5);
    11319      * console.log(object.x[0].y.z);
    11320      * // => 5
    11321      */
    11322     function set(object, path, value) {
    11323       if (object == null) {
    11324         return object;
    11325       }
    11326       var pathKey = (path + '');
    11327       path = (object[pathKey] != null || isKey(path, object)) ? [pathKey] : toPath(path);
    11328 
    11329       var index = -1,
    11330           length = path.length,
    11331           endIndex = length - 1,
    11332           nested = object;
    11333 
    11334       while (nested != null && ++index < length) {
    11335         var key = path[index];
    11336         if (isObject(nested)) {
    11337           if (index == endIndex) {
    11338             nested[key] = value;
    11339           } else if (nested[key] == null) {
    11340             nested[key] = isIndex(path[index + 1]) ? [] : {};
    11341           }
    11342         }
    11343         nested = nested[key];
    11344       }
    11345       return object;
    11346     }
    11347 
    11348     /**
    11349      * An alternative to `_.reduce`; this method transforms `object` to a new
    11350      * `accumulator` object which is the result of running each of its own enumerable
    11351      * properties through `iteratee`, with each invocation potentially mutating
    11352      * the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked
    11353      * with four arguments: (accumulator, value, key, object). Iteratee functions
    11354      * may exit iteration early by explicitly returning `false`.
    11355      *
    11356      * @static
    11357      * @memberOf _
    11358      * @category Object
    11359      * @param {Array|Object} object The object to iterate over.
    11360      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    11361      * @param {*} [accumulator] The custom accumulator value.
    11362      * @param {*} [thisArg] The `this` binding of `iteratee`.
    11363      * @returns {*} Returns the accumulated value.
    11364      * @example
    11365      *
    11366      * _.transform([2, 3, 4], function(result, n) {
    11367      *   result.push(n *= n);
    11368      *   return n % 2 == 0;
    11369      * });
    11370      * // => [4, 9]
    11371      *
    11372      * _.transform({ 'a': 1, 'b': 2 }, function(result, n, key) {
    11373      *   result[key] = n * 3;
    11374      * });
    11375      * // => { 'a': 3, 'b': 6 }
    11376      */
    11377     function transform(object, iteratee, accumulator, thisArg) {
    11378       var isArr = isArray(object) || isTypedArray(object);
    11379       iteratee = getCallback(iteratee, thisArg, 4);
    11380 
    11381       if (accumulator == null) {
    11382         if (isArr || isObject(object)) {
    11383           var Ctor = object.constructor;
    11384           if (isArr) {
    11385             accumulator = isArray(object) ? new Ctor : [];
    11386           } else {
    11387             accumulator = baseCreate(isFunction(Ctor) && Ctor.prototype);
    11388           }
    11389         } else {
    11390           accumulator = {};
    11391         }
    11392       }
    11393       (isArr ? arrayEach : baseForOwn)(object, function(value, index, object) {
    11394         return iteratee(accumulator, value, index, object);
    11395       });
    11396       return accumulator;
    11397     }
    11398 
    11399     /**
    11400      * Creates an array of the own enumerable property values of `object`.
    11401      *
    11402      * **Note:** Non-object values are coerced to objects.
    11403      *
    11404      * @static
    11405      * @memberOf _
    11406      * @category Object
    11407      * @param {Object} object The object to query.
    11408      * @returns {Array} Returns the array of property values.
    11409      * @example
    11410      *
    11411      * function Foo() {
    11412      *   this.a = 1;
    11413      *   this.b = 2;
    11414      * }
    11415      *
    11416      * Foo.prototype.c = 3;
    11417      *
    11418      * _.values(new Foo);
    11419      * // => [1, 2] (iteration order is not guaranteed)
    11420      *
    11421      * _.values('hi');
    11422      * // => ['h', 'i']
    11423      */
    11424     function values(object) {
    11425       return baseValues(object, keys(object));
    11426     }
    11427 
    11428     /**
    11429      * Creates an array of the own and inherited enumerable property values
    11430      * of `object`.
    11431      *
    11432      * **Note:** Non-object values are coerced to objects.
    11433      *
    11434      * @static
    11435      * @memberOf _
    11436      * @category Object
    11437      * @param {Object} object The object to query.
    11438      * @returns {Array} Returns the array of property values.
    11439      * @example
    11440      *
    11441      * function Foo() {
    11442      *   this.a = 1;
    11443      *   this.b = 2;
    11444      * }
    11445      *
    11446      * Foo.prototype.c = 3;
    11447      *
    11448      * _.valuesIn(new Foo);
    11449      * // => [1, 2, 3] (iteration order is not guaranteed)
    11450      */
    11451     function valuesIn(object) {
    11452       return baseValues(object, keysIn(object));
    11453     }
    11454 
    11455     /*------------------------------------------------------------------------*/
    11456 
    11457     /**
    11458      * Checks if `n` is between `start` and up to but not including, `end`. If
    11459      * `end` is not specified it is set to `start` with `start` then set to `0`.
    11460      *
    11461      * @static
    11462      * @memberOf _
    11463      * @category Number
    11464      * @param {number} n The number to check.
    11465      * @param {number} [start=0] The start of the range.
    11466      * @param {number} end The end of the range.
    11467      * @returns {boolean} Returns `true` if `n` is in the range, else `false`.
    11468      * @example
    11469      *
    11470      * _.inRange(3, 2, 4);
    11471      * // => true
    11472      *
    11473      * _.inRange(4, 8);
    11474      * // => true
    11475      *
    11476      * _.inRange(4, 2);
    11477      * // => false
    11478      *
    11479      * _.inRange(2, 2);
    11480      * // => false
    11481      *
    11482      * _.inRange(1.2, 2);
    11483      * // => true
    11484      *
    11485      * _.inRange(5.2, 4);
    11486      * // => false
    11487      */
    11488     function inRange(value, start, end) {
    11489       start = +start || 0;
    11490       if (typeof end === 'undefined') {
    11491         end = start;
    11492         start = 0;
    11493       } else {
    11494         end = +end || 0;
    11495       }
    11496       return value >= nativeMin(start, end) && value < nativeMax(start, end);
    11497     }
    11498 
    11499     /**
    11500      * Produces a random number between `min` and `max` (inclusive). If only one
    11501      * argument is provided a number between `0` and the given number is returned.
    11502      * If `floating` is `true`, or either `min` or `max` are floats, a floating-point
    11503      * number is returned instead of an integer.
    11504      *
    11505      * @static
    11506      * @memberOf _
    11507      * @category Number
    11508      * @param {number} [min=0] The minimum possible value.
    11509      * @param {number} [max=1] The maximum possible value.
    11510      * @param {boolean} [floating] Specify returning a floating-point number.
    11511      * @returns {number} Returns the random number.
    11512      * @example
    11513      *
    11514      * _.random(0, 5);
    11515      * // => an integer between 0 and 5
    11516      *
    11517      * _.random(5);
    11518      * // => also an integer between 0 and 5
    11519      *
    11520      * _.random(5, true);
    11521      * // => a floating-point number between 0 and 5
    11522      *
    11523      * _.random(1.2, 5.2);
    11524      * // => a floating-point number between 1.2 and 5.2
    11525      */
    11526     function random(min, max, floating) {
    11527       if (floating && isIterateeCall(min, max, floating)) {
    11528         max = floating = null;
    11529       }
    11530       var noMin = min == null,
    11531           noMax = max == null;
    11532 
    11533       if (floating == null) {
    11534         if (noMax && typeof min == 'boolean') {
    11535           floating = min;
    11536           min = 1;
    11537         }
    11538         else if (typeof max == 'boolean') {
    11539           floating = max;
    11540           noMax = true;
    11541         }
    11542       }
    11543       if (noMin && noMax) {
    11544         max = 1;
    11545         noMax = false;
    11546       }
    11547       min = +min || 0;
    11548       if (noMax) {
    11549         max = min;
    11550         min = 0;
    11551       } else {
    11552         max = +max || 0;
    11553       }
    11554       if (floating || min % 1 || max % 1) {
    11555         var rand = nativeRandom();
    11556         return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand + '').length - 1)))), max);
    11557       }
    11558       return baseRandom(min, max);
    11559     }
    11560 
    11561     /*------------------------------------------------------------------------*/
    11562 
    11563     /**
    11564      * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
    11565      *
    11566      * @static
    11567      * @memberOf _
    11568      * @category String
    11569      * @param {string} [string=''] The string to convert.
    11570      * @returns {string} Returns the camel cased string.
    11571      * @example
    11572      *
    11573      * _.camelCase('Foo Bar');
    11574      * // => 'fooBar'
    11575      *
    11576      * _.camelCase('--foo-bar');
    11577      * // => 'fooBar'
    11578      *
    11579      * _.camelCase('__foo_bar__');
    11580      * // => 'fooBar'
    11581      */
    11582     var camelCase = createCompounder(function(result, word, index) {
    11583       word = word.toLowerCase();
    11584       return result + (index ? (word.charAt(0).toUpperCase() + word.slice(1)) : word);
    11585     });
    11586 
    11587     /**
    11588      * Capitalizes the first character of `string`.
    11589      *
    11590      * @static
    11591      * @memberOf _
    11592      * @category String
    11593      * @param {string} [string=''] The string to capitalize.
    11594      * @returns {string} Returns the capitalized string.
    11595      * @example
    11596      *
    11597      * _.capitalize('fred');
    11598      * // => 'Fred'
    11599      */
    11600     function capitalize(string) {
    11601       string = baseToString(string);
    11602       return string && (string.charAt(0).toUpperCase() + string.slice(1));
    11603     }
    11604 
    11605     /**
    11606      * Deburrs `string` by converting [latin-1 supplementary letters](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
    11607      * to basic latin letters and removing [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
    11608      *
    11609      * @static
    11610      * @memberOf _
    11611      * @category String
    11612      * @param {string} [string=''] The string to deburr.
    11613      * @returns {string} Returns the deburred string.
    11614      * @example
    11615      *
    11616      * _.deburr('déjà vu');
    11617      * // => 'deja vu'
    11618      */
    11619     function deburr(string) {
    11620       string = baseToString(string);
    11621       return string && string.replace(reLatin1, deburrLetter).replace(reComboMark, '');
    11622     }
    11623 
    11624     /**
    11625      * Checks if `string` ends with the given target string.
    11626      *
    11627      * @static
    11628      * @memberOf _
    11629      * @category String
    11630      * @param {string} [string=''] The string to search.
    11631      * @param {string} [target] The string to search for.
    11632      * @param {number} [position=string.length] The position to search from.
    11633      * @returns {boolean} Returns `true` if `string` ends with `target`, else `false`.
    11634      * @example
    11635      *
    11636      * _.endsWith('abc', 'c');
    11637      * // => true
    11638      *
    11639      * _.endsWith('abc', 'b');
    11640      * // => false
    11641      *
    11642      * _.endsWith('abc', 'b', 2);
    11643      * // => true
    11644      */
    11645     function endsWith(string, target, position) {
    11646       string = baseToString(string);
    11647       target = (target + '');
    11648 
    11649       var length = string.length;
    11650       position = position === undefined
    11651         ? length
    11652         : nativeMin(position < 0 ? 0 : (+position || 0), length);
    11653 
    11654       position -= target.length;
    11655       return position >= 0 && string.indexOf(target, position) == position;
    11656     }
    11657 
    11658     /**
    11659      * Converts the characters "&", "<", ">", '"', "'", and "\`", in `string` to
    11660      * their corresponding HTML entities.
    11661      *
    11662      * **Note:** No other characters are escaped. To escape additional characters
    11663      * use a third-party library like [_he_](https://mths.be/he).
    11664      *
    11665      * Though the ">" character is escaped for symmetry, characters like
    11666      * ">" and "/" don't require escaping in HTML and have no special meaning
    11667      * unless they're part of a tag or unquoted attribute value.
    11668      * See [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
    11669      * (under "semi-related fun fact") for more details.
    11670      *
    11671      * Backticks are escaped because in Internet Explorer < 9, they can break out
    11672      * of attribute values or HTML comments. See [#59](https://html5sec.org/#59),
    11673      * [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and
    11674      * [#133](https://html5sec.org/#133) of the [HTML5 Security Cheatsheet](https://html5sec.org/)
    11675      * for more details.
    11676      *
    11677      * When working with HTML you should always [quote attribute values](http://wonko.com/post/html-escaping)
    11678      * to reduce XSS vectors.
    11679      *
    11680      * @static
    11681      * @memberOf _
    11682      * @category String
    11683      * @param {string} [string=''] The string to escape.
    11684      * @returns {string} Returns the escaped string.
    11685      * @example
    11686      *
    11687      * _.escape('fred, barney, & pebbles');
    11688      * // => 'fred, barney, &amp; pebbles'
    11689      */
    11690     function escape(string) {
    11691       // Reset `lastIndex` because in IE < 9 `String#replace` does not.
    11692       string = baseToString(string);
    11693       return (string && reHasUnescapedHtml.test(string))
    11694         ? string.replace(reUnescapedHtml, escapeHtmlChar)
    11695         : string;
    11696     }
    11697 
    11698     /**
    11699      * Escapes the `RegExp` special characters "\", "/", "^", "$", ".", "|", "?",
    11700      * "*", "+", "(", ")", "[", "]", "{" and "}" in `string`.
    11701      *
    11702      * @static
    11703      * @memberOf _
    11704      * @category String
    11705      * @param {string} [string=''] The string to escape.
    11706      * @returns {string} Returns the escaped string.
    11707      * @example
    11708      *
    11709      * _.escapeRegExp('[lodash](https://lodash.com/)');
    11710      * // => '\[lodash\]\(https:\/\/lodash\.com\/\)'
    11711      */
    11712     function escapeRegExp(string) {
    11713       string = baseToString(string);
    11714       return (string && reHasRegExpChars.test(string))
    11715         ? string.replace(reRegExpChars, '\\$&')
    11716         : string;
    11717     }
    11718 
    11719     /**
    11720      * Converts `string` to [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
    11721      *
    11722      * @static
    11723      * @memberOf _
    11724      * @category String
    11725      * @param {string} [string=''] The string to convert.
    11726      * @returns {string} Returns the kebab cased string.
    11727      * @example
    11728      *
    11729      * _.kebabCase('Foo Bar');
    11730      * // => 'foo-bar'
    11731      *
    11732      * _.kebabCase('fooBar');
    11733      * // => 'foo-bar'
    11734      *
    11735      * _.kebabCase('__foo_bar__');
    11736      * // => 'foo-bar'
    11737      */
    11738     var kebabCase = createCompounder(function(result, word, index) {
    11739       return result + (index ? '-' : '') + word.toLowerCase();
    11740     });
    11741 
    11742     /**
    11743      * Pads `string` on the left and right sides if it is shorter than `length`.
    11744      * Padding characters are truncated if they can't be evenly divided by `length`.
    11745      *
    11746      * @static
    11747      * @memberOf _
    11748      * @category String
    11749      * @param {string} [string=''] The string to pad.
    11750      * @param {number} [length=0] The padding length.
    11751      * @param {string} [chars=' '] The string used as padding.
    11752      * @returns {string} Returns the padded string.
    11753      * @example
    11754      *
    11755      * _.pad('abc', 8);
    11756      * // => '  abc   '
    11757      *
    11758      * _.pad('abc', 8, '_-');
    11759      * // => '_-abc_-_'
    11760      *
    11761      * _.pad('abc', 3);
    11762      * // => 'abc'
    11763      */
    11764     function pad(string, length, chars) {
    11765       string = baseToString(string);
    11766       length = +length;
    11767 
    11768       var strLength = string.length;
    11769       if (strLength >= length || !nativeIsFinite(length)) {
    11770         return string;
    11771       }
    11772       var mid = (length - strLength) / 2,
    11773           leftLength = floor(mid),
    11774           rightLength = ceil(mid);
    11775 
    11776       chars = createPadding('', rightLength, chars);
    11777       return chars.slice(0, leftLength) + string + chars;
    11778     }
    11779 
    11780     /**
    11781      * Pads `string` on the left side if it is shorter than `length`. Padding
    11782      * characters are truncated if they exceed `length`.
    11783      *
    11784      * @static
    11785      * @memberOf _
    11786      * @category String
    11787      * @param {string} [string=''] The string to pad.
    11788      * @param {number} [length=0] The padding length.
    11789      * @param {string} [chars=' '] The string used as padding.
    11790      * @returns {string} Returns the padded string.
    11791      * @example
    11792      *
    11793      * _.padLeft('abc', 6);
    11794      * // => '   abc'
    11795      *
    11796      * _.padLeft('abc', 6, '_-');
    11797      * // => '_-_abc'
    11798      *
    11799      * _.padLeft('abc', 3);
    11800      * // => 'abc'
    11801      */
    11802     var padLeft = createPadDir();
    11803 
    11804     /**
    11805      * Pads `string` on the right side if it is shorter than `length`. Padding
    11806      * characters are truncated if they exceed `length`.
    11807      *
    11808      * @static
    11809      * @memberOf _
    11810      * @category String
    11811      * @param {string} [string=''] The string to pad.
    11812      * @param {number} [length=0] The padding length.
    11813      * @param {string} [chars=' '] The string used as padding.
    11814      * @returns {string} Returns the padded string.
    11815      * @example
    11816      *
    11817      * _.padRight('abc', 6);
    11818      * // => 'abc   '
    11819      *
    11820      * _.padRight('abc', 6, '_-');
    11821      * // => 'abc_-_'
    11822      *
    11823      * _.padRight('abc', 3);
    11824      * // => 'abc'
    11825      */
    11826     var padRight = createPadDir(true);
    11827 
    11828     /**
    11829      * Converts `string` to an integer of the specified radix. If `radix` is
    11830      * `undefined` or `0`, a `radix` of `10` is used unless `value` is a hexadecimal,
    11831      * in which case a `radix` of `16` is used.
    11832      *
    11833      * **Note:** This method aligns with the [ES5 implementation](https://es5.github.io/#E)
    11834      * of `parseInt`.
    11835      *
    11836      * @static
    11837      * @memberOf _
    11838      * @category String
    11839      * @param {string} string The string to convert.
    11840      * @param {number} [radix] The radix to interpret `value` by.
    11841      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    11842      * @returns {number} Returns the converted integer.
    11843      * @example
    11844      *
    11845      * _.parseInt('08');
    11846      * // => 8
    11847      *
    11848      * _.map(['6', '08', '10'], _.parseInt);
    11849      * // => [6, 8, 10]
    11850      */
    11851     function parseInt(string, radix, guard) {
    11852       if (guard && isIterateeCall(string, radix, guard)) {
    11853         radix = 0;
    11854       }
    11855       return nativeParseInt(string, radix);
    11856     }
    11857     // Fallback for environments with pre-ES5 implementations.
    11858     if (nativeParseInt(whitespace + '08') != 8) {
    11859       parseInt = function(string, radix, guard) {
    11860         // Firefox < 21 and Opera < 15 follow ES3 for `parseInt`.
    11861         // Chrome fails to trim leading <BOM> whitespace characters.
    11862         // See https://code.google.com/p/v8/issues/detail?id=3109 for more details.
    11863         if (guard ? isIterateeCall(string, radix, guard) : radix == null) {
    11864           radix = 0;
    11865         } else if (radix) {
    11866           radix = +radix;
    11867         }
    11868         string = trim(string);
    11869         return nativeParseInt(string, radix || (reHasHexPrefix.test(string) ? 16 : 10));
    11870       };
    11871     }
    11872 
    11873     /**
    11874      * Repeats the given string `n` times.
    11875      *
    11876      * @static
    11877      * @memberOf _
    11878      * @category String
    11879      * @param {string} [string=''] The string to repeat.
    11880      * @param {number} [n=0] The number of times to repeat the string.
    11881      * @returns {string} Returns the repeated string.
    11882      * @example
    11883      *
    11884      * _.repeat('*', 3);
    11885      * // => '***'
    11886      *
    11887      * _.repeat('abc', 2);
    11888      * // => 'abcabc'
    11889      *
    11890      * _.repeat('abc', 0);
    11891      * // => ''
    11892      */
    11893     function repeat(string, n) {
    11894       var result = '';
    11895       string = baseToString(string);
    11896       n = +n;
    11897       if (n < 1 || !string || !nativeIsFinite(n)) {
    11898         return result;
    11899       }
    11900       // Leverage the exponentiation by squaring algorithm for a faster repeat.
    11901       // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
    11902       do {
    11903         if (n % 2) {
    11904           result += string;
    11905         }
    11906         n = floor(n / 2);
    11907         string += string;
    11908       } while (n);
    11909 
    11910       return result;
    11911     }
    11912 
    11913     /**
    11914      * Converts `string` to [snake case](https://en.wikipedia.org/wiki/Snake_case).
    11915      *
    11916      * @static
    11917      * @memberOf _
    11918      * @category String
    11919      * @param {string} [string=''] The string to convert.
    11920      * @returns {string} Returns the snake cased string.
    11921      * @example
    11922      *
    11923      * _.snakeCase('Foo Bar');
    11924      * // => 'foo_bar'
    11925      *
    11926      * _.snakeCase('fooBar');
    11927      * // => 'foo_bar'
    11928      *
    11929      * _.snakeCase('--foo-bar');
    11930      * // => 'foo_bar'
    11931      */
    11932     var snakeCase = createCompounder(function(result, word, index) {
    11933       return result + (index ? '_' : '') + word.toLowerCase();
    11934     });
    11935 
    11936     /**
    11937      * Converts `string` to [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
    11938      *
    11939      * @static
    11940      * @memberOf _
    11941      * @category String
    11942      * @param {string} [string=''] The string to convert.
    11943      * @returns {string} Returns the start cased string.
    11944      * @example
    11945      *
    11946      * _.startCase('--foo-bar');
    11947      * // => 'Foo Bar'
    11948      *
    11949      * _.startCase('fooBar');
    11950      * // => 'Foo Bar'
    11951      *
    11952      * _.startCase('__foo_bar__');
    11953      * // => 'Foo Bar'
    11954      */
    11955     var startCase = createCompounder(function(result, word, index) {
    11956       return result + (index ? ' ' : '') + (word.charAt(0).toUpperCase() + word.slice(1));
    11957     });
    11958 
    11959     /**
    11960      * Checks if `string` starts with the given target string.
    11961      *
    11962      * @static
    11963      * @memberOf _
    11964      * @category String
    11965      * @param {string} [string=''] The string to search.
    11966      * @param {string} [target] The string to search for.
    11967      * @param {number} [position=0] The position to search from.
    11968      * @returns {boolean} Returns `true` if `string` starts with `target`, else `false`.
    11969      * @example
    11970      *
    11971      * _.startsWith('abc', 'a');
    11972      * // => true
    11973      *
    11974      * _.startsWith('abc', 'b');
    11975      * // => false
    11976      *
    11977      * _.startsWith('abc', 'b', 1);
    11978      * // => true
    11979      */
    11980     function startsWith(string, target, position) {
    11981       string = baseToString(string);
    11982       position = position == null
    11983         ? 0
    11984         : nativeMin(position < 0 ? 0 : (+position || 0), string.length);
    11985 
    11986       return string.lastIndexOf(target, position) == position;
    11987     }
    11988 
    11989     /**
    11990      * Creates a compiled template function that can interpolate data properties
    11991      * in "interpolate" delimiters, HTML-escape interpolated data properties in
    11992      * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
    11993      * properties may be accessed as free variables in the template. If a setting
    11994      * object is provided it takes precedence over `_.templateSettings` values.
    11995      *
    11996      * **Note:** In the development build `_.template` utilizes
    11997      * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
    11998      * for easier debugging.
    11999      *
    12000      * For more information on precompiling templates see
    12001      * [lodash's custom builds documentation](https://lodash.com/custom-builds).
    12002      *
    12003      * For more information on Chrome extension sandboxes see
    12004      * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
    12005      *
    12006      * @static
    12007      * @memberOf _
    12008      * @category String
    12009      * @param {string} [string=''] The template string.
    12010      * @param {Object} [options] The options object.
    12011      * @param {RegExp} [options.escape] The HTML "escape" delimiter.
    12012      * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
    12013      * @param {Object} [options.imports] An object to import into the template as free variables.
    12014      * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
    12015      * @param {string} [options.sourceURL] The sourceURL of the template's compiled source.
    12016      * @param {string} [options.variable] The data object variable name.
    12017      * @param- {Object} [otherOptions] Enables the legacy `options` param signature.
    12018      * @returns {Function} Returns the compiled template function.
    12019      * @example
    12020      *
    12021      * // using the "interpolate" delimiter to create a compiled template
    12022      * var compiled = _.template('hello <%= user %>!');
    12023      * compiled({ 'user': 'fred' });
    12024      * // => 'hello fred!'
    12025      *
    12026      * // using the HTML "escape" delimiter to escape data property values
    12027      * var compiled = _.template('<b><%- value %></b>');
    12028      * compiled({ 'value': '<script>' });
    12029      * // => '<b>&lt;script&gt;</b>'
    12030      *
    12031      * // using the "evaluate" delimiter to execute JavaScript and generate HTML
    12032      * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
    12033      * compiled({ 'users': ['fred', 'barney'] });
    12034      * // => '<li>fred</li><li>barney</li>'
    12035      *
    12036      * // using the internal `print` function in "evaluate" delimiters
    12037      * var compiled = _.template('<% print("hello " + user); %>!');
    12038      * compiled({ 'user': 'barney' });
    12039      * // => 'hello barney!'
    12040      *
    12041      * // using the ES delimiter as an alternative to the default "interpolate" delimiter
    12042      * var compiled = _.template('hello ${ user }!');
    12043      * compiled({ 'user': 'pebbles' });
    12044      * // => 'hello pebbles!'
    12045      *
    12046      * // using custom template delimiters
    12047      * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
    12048      * var compiled = _.template('hello {{ user }}!');
    12049      * compiled({ 'user': 'mustache' });
    12050      * // => 'hello mustache!'
    12051      *
    12052      * // using backslashes to treat delimiters as plain text
    12053      * var compiled = _.template('<%= "\\<%- value %\\>" %>');
    12054      * compiled({ 'value': 'ignored' });
    12055      * // => '<%- value %>'
    12056      *
    12057      * // using the `imports` option to import `jQuery` as `jq`
    12058      * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
    12059      * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
    12060      * compiled({ 'users': ['fred', 'barney'] });
    12061      * // => '<li>fred</li><li>barney</li>'
    12062      *
    12063      * // using the `sourceURL` option to specify a custom sourceURL for the template
    12064      * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
    12065      * compiled(data);
    12066      * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
    12067      *
    12068      * // using the `variable` option to ensure a with-statement isn't used in the compiled template
    12069      * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
    12070      * compiled.source;
    12071      * // => function(data) {
    12072      * //   var __t, __p = '';
    12073      * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
    12074      * //   return __p;
    12075      * // }
    12076      *
    12077      * // using the `source` property to inline compiled templates for meaningful
    12078      * // line numbers in error messages and a stack trace
    12079      * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
    12080      *   var JST = {\
    12081      *     "main": ' + _.template(mainText).source + '\
    12082      *   };\
    12083      * ');
    12084      */
    12085     function template(string, options, otherOptions) {
    12086       // Based on John Resig's `tmpl` implementation (http://ejohn.org/blog/javascript-micro-templating/)
    12087       // and Laura Doktorova's doT.js (https://github.com/olado/doT).
    12088       var settings = lodash.templateSettings;
    12089 
    12090       if (otherOptions && isIterateeCall(string, options, otherOptions)) {
    12091         options = otherOptions = null;
    12092       }
    12093       string = baseToString(string);
    12094       options = assignWith(baseAssign({}, otherOptions || options), settings, assignOwnDefaults);
    12095 
    12096       var imports = assignWith(baseAssign({}, options.imports), settings.imports, assignOwnDefaults),
    12097           importsKeys = keys(imports),
    12098           importsValues = baseValues(imports, importsKeys);
    12099 
    12100       var isEscaping,
    12101           isEvaluating,
    12102           index = 0,
    12103           interpolate = options.interpolate || reNoMatch,
    12104           source = "__p += '";
    12105 
    12106       // Compile the regexp to match each delimiter.
    12107       var reDelimiters = RegExp(
    12108         (options.escape || reNoMatch).source + '|' +
    12109         interpolate.source + '|' +
    12110         (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
    12111         (options.evaluate || reNoMatch).source + '|$'
    12112       , 'g');
    12113 
    12114       // Use a sourceURL for easier debugging.
    12115       var sourceURL = '//# sourceURL=' +
    12116         ('sourceURL' in options
    12117           ? options.sourceURL
    12118           : ('lodash.templateSources[' + (++templateCounter) + ']')
    12119         ) + '\n';
    12120 
    12121       string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
    12122         interpolateValue || (interpolateValue = esTemplateValue);
    12123 
    12124         // Escape characters that can't be included in string literals.
    12125         source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
    12126 
    12127         // Replace delimiters with snippets.
    12128         if (escapeValue) {
    12129           isEscaping = true;
    12130           source += "' +\n__e(" + escapeValue + ") +\n'";
    12131         }
    12132         if (evaluateValue) {
    12133           isEvaluating = true;
    12134           source += "';\n" + evaluateValue + ";\n__p += '";
    12135         }
    12136         if (interpolateValue) {
    12137           source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
    12138         }
    12139         index = offset + match.length;
    12140 
    12141         // The JS engine embedded in Adobe products requires returning the `match`
    12142         // string in order to produce the correct `offset` value.
    12143         return match;
    12144       });
    12145 
    12146       source += "';\n";
    12147 
    12148       // If `variable` is not specified wrap a with-statement around the generated
    12149       // code to add the data object to the top of the scope chain.
    12150       var variable = options.variable;
    12151       if (!variable) {
    12152         source = 'with (obj) {\n' + source + '\n}\n';
    12153       }
    12154       // Cleanup code by stripping empty strings.
    12155       source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
    12156         .replace(reEmptyStringMiddle, '$1')
    12157         .replace(reEmptyStringTrailing, '$1;');
    12158 
    12159       // Frame code as the function body.
    12160       source = 'function(' + (variable || 'obj') + ') {\n' +
    12161         (variable
    12162           ? ''
    12163           : 'obj || (obj = {});\n'
    12164         ) +
    12165         "var __t, __p = ''" +
    12166         (isEscaping
    12167            ? ', __e = _.escape'
    12168            : ''
    12169         ) +
    12170         (isEvaluating
    12171           ? ', __j = Array.prototype.join;\n' +
    12172             "function print() { __p += __j.call(arguments, '') }\n"
    12173           : ';\n'
    12174         ) +
    12175         source +
    12176         'return __p\n}';
    12177 
    12178       var result = attempt(function() {
    12179         return Function(importsKeys, sourceURL + 'return ' + source).apply(undefined, importsValues);
    12180       });
    12181 
    12182       // Provide the compiled function's source by its `toString` method or
    12183       // the `source` property as a convenience for inlining compiled templates.
    12184       result.source = source;
    12185       if (isError(result)) {
    12186         throw result;
    12187       }
    12188       return result;
    12189     }
    12190 
    12191     /**
    12192      * Removes leading and trailing whitespace or specified characters from `string`.
    12193      *
    12194      * @static
    12195      * @memberOf _
    12196      * @category String
    12197      * @param {string} [string=''] The string to trim.
    12198      * @param {string} [chars=whitespace] The characters to trim.
    12199      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    12200      * @returns {string} Returns the trimmed string.
    12201      * @example
    12202      *
    12203      * _.trim('  abc  ');
    12204      * // => 'abc'
    12205      *
    12206      * _.trim('-_-abc-_-', '_-');
    12207      * // => 'abc'
    12208      *
    12209      * _.map(['  foo  ', '  bar  '], _.trim);
    12210      * // => ['foo', 'bar']
    12211      */
    12212     function trim(string, chars, guard) {
    12213       var value = string;
    12214       string = baseToString(string);
    12215       if (!string) {
    12216         return string;
    12217       }
    12218       if (guard ? isIterateeCall(value, chars, guard) : chars == null) {
    12219         return string.slice(trimmedLeftIndex(string), trimmedRightIndex(string) + 1);
    12220       }
    12221       chars = (chars + '');
    12222       return string.slice(charsLeftIndex(string, chars), charsRightIndex(string, chars) + 1);
    12223     }
    12224 
    12225     /**
    12226      * Removes leading whitespace or specified characters from `string`.
    12227      *
    12228      * @static
    12229      * @memberOf _
    12230      * @category String
    12231      * @param {string} [string=''] The string to trim.
    12232      * @param {string} [chars=whitespace] The characters to trim.
    12233      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    12234      * @returns {string} Returns the trimmed string.
    12235      * @example
    12236      *
    12237      * _.trimLeft('  abc  ');
    12238      * // => 'abc  '
    12239      *
    12240      * _.trimLeft('-_-abc-_-', '_-');
    12241      * // => 'abc-_-'
    12242      */
    12243     function trimLeft(string, chars, guard) {
    12244       var value = string;
    12245       string = baseToString(string);
    12246       if (!string) {
    12247         return string;
    12248       }
    12249       if (guard ? isIterateeCall(value, chars, guard) : chars == null) {
    12250         return string.slice(trimmedLeftIndex(string));
    12251       }
    12252       return string.slice(charsLeftIndex(string, (chars + '')));
    12253     }
    12254 
    12255     /**
    12256      * Removes trailing whitespace or specified characters from `string`.
    12257      *
    12258      * @static
    12259      * @memberOf _
    12260      * @category String
    12261      * @param {string} [string=''] The string to trim.
    12262      * @param {string} [chars=whitespace] The characters to trim.
    12263      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    12264      * @returns {string} Returns the trimmed string.
    12265      * @example
    12266      *
    12267      * _.trimRight('  abc  ');
    12268      * // => '  abc'
    12269      *
    12270      * _.trimRight('-_-abc-_-', '_-');
    12271      * // => '-_-abc'
    12272      */
    12273     function trimRight(string, chars, guard) {
    12274       var value = string;
    12275       string = baseToString(string);
    12276       if (!string) {
    12277         return string;
    12278       }
    12279       if (guard ? isIterateeCall(value, chars, guard) : chars == null) {
    12280         return string.slice(0, trimmedRightIndex(string) + 1);
    12281       }
    12282       return string.slice(0, charsRightIndex(string, (chars + '')) + 1);
    12283     }
    12284 
    12285     /**
    12286      * Truncates `string` if it is longer than the given maximum string length.
    12287      * The last characters of the truncated string are replaced with the omission
    12288      * string which defaults to "...".
    12289      *
    12290      * @static
    12291      * @memberOf _
    12292      * @category String
    12293      * @param {string} [string=''] The string to truncate.
    12294      * @param {Object|number} [options] The options object or maximum string length.
    12295      * @param {number} [options.length=30] The maximum string length.
    12296      * @param {string} [options.omission='...'] The string to indicate text is omitted.
    12297      * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
    12298      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    12299      * @returns {string} Returns the truncated string.
    12300      * @example
    12301      *
    12302      * _.trunc('hi-diddly-ho there, neighborino');
    12303      * // => 'hi-diddly-ho there, neighbo...'
    12304      *
    12305      * _.trunc('hi-diddly-ho there, neighborino', 24);
    12306      * // => 'hi-diddly-ho there, n...'
    12307      *
    12308      * _.trunc('hi-diddly-ho there, neighborino', {
    12309      *   'length': 24,
    12310      *   'separator': ' '
    12311      * });
    12312      * // => 'hi-diddly-ho there,...'
    12313      *
    12314      * _.trunc('hi-diddly-ho there, neighborino', {
    12315      *   'length': 24,
    12316      *   'separator': /,? +/
    12317      * });
    12318      * // => 'hi-diddly-ho there...'
    12319      *
    12320      * _.trunc('hi-diddly-ho there, neighborino', {
    12321      *   'omission': ' [...]'
    12322      * });
    12323      * // => 'hi-diddly-ho there, neig [...]'
    12324      */
    12325     function trunc(string, options, guard) {
    12326       if (guard && isIterateeCall(string, options, guard)) {
    12327         options = null;
    12328       }
    12329       var length = DEFAULT_TRUNC_LENGTH,
    12330           omission = DEFAULT_TRUNC_OMISSION;
    12331 
    12332       if (options != null) {
    12333         if (isObject(options)) {
    12334           var separator = 'separator' in options ? options.separator : separator;
    12335           length = 'length' in options ? (+options.length || 0) : length;
    12336           omission = 'omission' in options ? baseToString(options.omission) : omission;
    12337         } else {
    12338           length = +options || 0;
    12339         }
    12340       }
    12341       string = baseToString(string);
    12342       if (length >= string.length) {
    12343         return string;
    12344       }
    12345       var end = length - omission.length;
    12346       if (end < 1) {
    12347         return omission;
    12348       }
    12349       var result = string.slice(0, end);
    12350       if (separator == null) {
    12351         return result + omission;
    12352       }
    12353       if (isRegExp(separator)) {
    12354         if (string.slice(end).search(separator)) {
    12355           var match,
    12356               newEnd,
    12357               substring = string.slice(0, end);
    12358 
    12359           if (!separator.global) {
    12360             separator = RegExp(separator.source, (reFlags.exec(separator) || '') + 'g');
    12361           }
    12362           separator.lastIndex = 0;
    12363           while ((match = separator.exec(substring))) {
    12364             newEnd = match.index;
    12365           }
    12366           result = result.slice(0, newEnd == null ? end : newEnd);
    12367         }
    12368       } else if (string.indexOf(separator, end) != end) {
    12369         var index = result.lastIndexOf(separator);
    12370         if (index > -1) {
    12371           result = result.slice(0, index);
    12372         }
    12373       }
    12374       return result + omission;
    12375     }
    12376 
    12377     /**
    12378      * The inverse of `_.escape`; this method converts the HTML entities
    12379      * `&amp;`, `&lt;`, `&gt;`, `&quot;`, `&#39;`, and `&#96;` in `string` to their
    12380      * corresponding characters.
    12381      *
    12382      * **Note:** No other HTML entities are unescaped. To unescape additional HTML
    12383      * entities use a third-party library like [_he_](https://mths.be/he).
    12384      *
    12385      * @static
    12386      * @memberOf _
    12387      * @category String
    12388      * @param {string} [string=''] The string to unescape.
    12389      * @returns {string} Returns the unescaped string.
    12390      * @example
    12391      *
    12392      * _.unescape('fred, barney, &amp; pebbles');
    12393      * // => 'fred, barney, & pebbles'
    12394      */
    12395     function unescape(string) {
    12396       string = baseToString(string);
    12397       return (string && reHasEscapedHtml.test(string))
    12398         ? string.replace(reEscapedHtml, unescapeHtmlChar)
    12399         : string;
    12400     }
    12401 
    12402     /**
    12403      * Splits `string` into an array of its words.
    12404      *
    12405      * @static
    12406      * @memberOf _
    12407      * @category String
    12408      * @param {string} [string=''] The string to inspect.
    12409      * @param {RegExp|string} [pattern] The pattern to match words.
    12410      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    12411      * @returns {Array} Returns the words of `string`.
    12412      * @example
    12413      *
    12414      * _.words('fred, barney, & pebbles');
    12415      * // => ['fred', 'barney', 'pebbles']
    12416      *
    12417      * _.words('fred, barney, & pebbles', /[^, ]+/g);
    12418      * // => ['fred', 'barney', '&', 'pebbles']
    12419      */
    12420     function words(string, pattern, guard) {
    12421       if (guard && isIterateeCall(string, pattern, guard)) {
    12422         pattern = null;
    12423       }
    12424       string = baseToString(string);
    12425       return string.match(pattern || reWords) || [];
    12426     }
    12427 
    12428     /*------------------------------------------------------------------------*/
    12429 
    12430     /**
    12431      * Attempts to invoke `func`, returning either the result or the caught error
    12432      * object. Any additional arguments are provided to `func` when it is invoked.
    12433      *
    12434      * @static
    12435      * @memberOf _
    12436      * @category Utility
    12437      * @param {Function} func The function to attempt.
    12438      * @returns {*} Returns the `func` result or error object.
    12439      * @example
    12440      *
    12441      * // avoid throwing errors for invalid selectors
    12442      * var elements = _.attempt(function(selector) {
    12443      *   return document.querySelectorAll(selector);
    12444      * }, '>_>');
    12445      *
    12446      * if (_.isError(elements)) {
    12447      *   elements = [];
    12448      * }
    12449      */
    12450     var attempt = restParam(function(func, args) {
    12451       try {
    12452         return func.apply(undefined, args);
    12453       } catch(e) {
    12454         return isError(e) ? e : new Error(e);
    12455       }
    12456     });
    12457 
    12458     /**
    12459      * Creates a function that invokes `func` with the `this` binding of `thisArg`
    12460      * and arguments of the created function. If `func` is a property name the
    12461      * created callback returns the property value for a given element. If `func`
    12462      * is an object the created callback returns `true` for elements that contain
    12463      * the equivalent object properties, otherwise it returns `false`.
    12464      *
    12465      * @static
    12466      * @memberOf _
    12467      * @alias iteratee
    12468      * @category Utility
    12469      * @param {*} [func=_.identity] The value to convert to a callback.
    12470      * @param {*} [thisArg] The `this` binding of `func`.
    12471      * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.
    12472      * @returns {Function} Returns the callback.
    12473      * @example
    12474      *
    12475      * var users = [
    12476      *   { 'user': 'barney', 'age': 36 },
    12477      *   { 'user': 'fred',   'age': 40 }
    12478      * ];
    12479      *
    12480      * // wrap to create custom callback shorthands
    12481      * _.callback = _.wrap(_.callback, function(callback, func, thisArg) {
    12482      *   var match = /^(.+?)__([gl]t)(.+)$/.exec(func);
    12483      *   if (!match) {
    12484      *     return callback(func, thisArg);
    12485      *   }
    12486      *   return function(object) {
    12487      *     return match[2] == 'gt'
    12488      *       ? object[match[1]] > match[3]
    12489      *       : object[match[1]] < match[3];
    12490      *   };
    12491      * });
    12492      *
    12493      * _.filter(users, 'age__gt36');
    12494      * // => [{ 'user': 'fred', 'age': 40 }]
    12495      */
    12496     function callback(func, thisArg, guard) {
    12497       if (guard && isIterateeCall(func, thisArg, guard)) {
    12498         thisArg = null;
    12499       }
    12500       return baseCallback(func, thisArg);
    12501     }
    12502 
    12503     /**
    12504      * Creates a function that returns `value`.
    12505      *
    12506      * @static
    12507      * @memberOf _
    12508      * @category Utility
    12509      * @param {*} value The value to return from the new function.
    12510      * @returns {Function} Returns the new function.
    12511      * @example
    12512      *
    12513      * var object = { 'user': 'fred' };
    12514      * var getter = _.constant(object);
    12515      *
    12516      * getter() === object;
    12517      * // => true
    12518      */
    12519     function constant(value) {
    12520       return function() {
    12521         return value;
    12522       };
    12523     }
    12524 
    12525     /**
    12526      * This method returns the first argument provided to it.
    12527      *
    12528      * @static
    12529      * @memberOf _
    12530      * @category Utility
    12531      * @param {*} value Any value.
    12532      * @returns {*} Returns `value`.
    12533      * @example
    12534      *
    12535      * var object = { 'user': 'fred' };
    12536      *
    12537      * _.identity(object) === object;
    12538      * // => true
    12539      */
    12540     function identity(value) {
    12541       return value;
    12542     }
    12543 
    12544     /**
    12545      * Creates a function which performs a deep comparison between a given object
    12546      * and `source`, returning `true` if the given object has equivalent property
    12547      * values, else `false`.
    12548      *
    12549      * **Note:** This method supports comparing arrays, booleans, `Date` objects,
    12550      * numbers, `Object` objects, regexes, and strings. Objects are compared by
    12551      * their own, not inherited, enumerable properties. For comparing a single
    12552      * own or inherited property value see `_.matchesProperty`.
    12553      *
    12554      * @static
    12555      * @memberOf _
    12556      * @category Utility
    12557      * @param {Object} source The object of property values to match.
    12558      * @returns {Function} Returns the new function.
    12559      * @example
    12560      *
    12561      * var users = [
    12562      *   { 'user': 'barney', 'age': 36, 'active': true },
    12563      *   { 'user': 'fred',   'age': 40, 'active': false }
    12564      * ];
    12565      *
    12566      * _.filter(users, _.matches({ 'age': 40, 'active': false }));
    12567      * // => [{ 'user': 'fred', 'age': 40, 'active': false }]
    12568      */
    12569     function matches(source) {
    12570       return baseMatches(baseClone(source, true));
    12571     }
    12572 
    12573     /**
    12574      * Creates a function which compares the property value of `path` on a given
    12575      * object to `value`.
    12576      *
    12577      * **Note:** This method supports comparing arrays, booleans, `Date` objects,
    12578      * numbers, `Object` objects, regexes, and strings. Objects are compared by
    12579      * their own, not inherited, enumerable properties.
    12580      *
    12581      * @static
    12582      * @memberOf _
    12583      * @category Utility
    12584      * @param {Array|string} path The path of the property to get.
    12585      * @param {*} value The value to compare.
    12586      * @returns {Function} Returns the new function.
    12587      * @example
    12588      *
    12589      * var users = [
    12590      *   { 'user': 'barney' },
    12591      *   { 'user': 'fred' }
    12592      * ];
    12593      *
    12594      * _.find(users, _.matchesProperty('user', 'fred'));
    12595      * // => { 'user': 'fred' }
    12596      */
    12597     function matchesProperty(path, value) {
    12598       return baseMatchesProperty(path, baseClone(value, true));
    12599     }
    12600 
    12601     /**
    12602      * Creates a function which invokes the method at `path` on a given object.
    12603      *
    12604      * @static
    12605      * @memberOf _
    12606      * @category Utility
    12607      * @param {Array|string} path The path of the method to invoke.
    12608      * @returns {Function} Returns the new function.
    12609      * @example
    12610      *
    12611      * var objects = [
    12612      *   { 'a': { 'b': { 'c': _.constant(2) } } },
    12613      *   { 'a': { 'b': { 'c': _.constant(1) } } }
    12614      * ];
    12615      *
    12616      * _.map(objects, _.method('a.b.c'));
    12617      * // => [2, 1]
    12618      *
    12619      * _.invoke(_.sortBy(objects, _.method(['a', 'b', 'c'])), 'a.b.c');
    12620      * // => [1, 2]
    12621      */
    12622     var method = restParam(function(path, args) {
    12623       return function(object) {
    12624         return invokePath(object, path, args);
    12625       }
    12626     });
    12627 
    12628     /**
    12629      * The opposite of `_.method`; this method creates a function which invokes
    12630      * the method at a given path on `object`.
    12631      *
    12632      * @static
    12633      * @memberOf _
    12634      * @category Utility
    12635      * @param {Object} object The object to query.
    12636      * @returns {Function} Returns the new function.
    12637      * @example
    12638      *
    12639      * var array = _.times(3, _.constant),
    12640      *     object = { 'a': array, 'b': array, 'c': array };
    12641      *
    12642      * _.map(['a[2]', 'c[0]'], _.methodOf(object));
    12643      * // => [2, 0]
    12644      *
    12645      * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
    12646      * // => [2, 0]
    12647      */
    12648     var methodOf = restParam(function(object, args) {
    12649       return function(path) {
    12650         return invokePath(object, path, args);
    12651       };
    12652     });
    12653 
    12654     /**
    12655      * Adds all own enumerable function properties of a source object to the
    12656      * destination object. If `object` is a function then methods are added to
    12657      * its prototype as well.
    12658      *
    12659      * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
    12660      * avoid conflicts caused by modifying the original.
    12661      *
    12662      * @static
    12663      * @memberOf _
    12664      * @category Utility
    12665      * @param {Function|Object} [object=lodash] The destination object.
    12666      * @param {Object} source The object of functions to add.
    12667      * @param {Object} [options] The options object.
    12668      * @param {boolean} [options.chain=true] Specify whether the functions added
    12669      *  are chainable.
    12670      * @returns {Function|Object} Returns `object`.
    12671      * @example
    12672      *
    12673      * function vowels(string) {
    12674      *   return _.filter(string, function(v) {
    12675      *     return /[aeiou]/i.test(v);
    12676      *   });
    12677      * }
    12678      *
    12679      * // use `_.runInContext` to avoid conflicts (esp. in Node.js)
    12680      * var _ = require('lodash').runInContext();
    12681      *
    12682      * _.mixin({ 'vowels': vowels });
    12683      * _.vowels('fred');
    12684      * // => ['e']
    12685      *
    12686      * _('fred').vowels().value();
    12687      * // => ['e']
    12688      *
    12689      * _.mixin({ 'vowels': vowels }, { 'chain': false });
    12690      * _('fred').vowels();
    12691      * // => ['e']
    12692      */
    12693     function mixin(object, source, options) {
    12694       if (options == null) {
    12695         var isObj = isObject(source),
    12696             props = isObj && keys(source),
    12697             methodNames = props && props.length && baseFunctions(source, props);
    12698 
    12699         if (!(methodNames ? methodNames.length : isObj)) {
    12700           methodNames = false;
    12701           options = source;
    12702           source = object;
    12703           object = this;
    12704         }
    12705       }
    12706       if (!methodNames) {
    12707         methodNames = baseFunctions(source, keys(source));
    12708       }
    12709       var chain = true,
    12710           index = -1,
    12711           isFunc = isFunction(object),
    12712           length = methodNames.length;
    12713 
    12714       if (options === false) {
    12715         chain = false;
    12716       } else if (isObject(options) && 'chain' in options) {
    12717         chain = options.chain;
    12718       }
    12719       while (++index < length) {
    12720         var methodName = methodNames[index],
    12721             func = source[methodName];
    12722 
    12723         object[methodName] = func;
    12724         if (isFunc) {
    12725           object.prototype[methodName] = (function(func) {
    12726             return function() {
    12727               var chainAll = this.__chain__;
    12728               if (chain || chainAll) {
    12729                 var result = object(this.__wrapped__),
    12730                     actions = result.__actions__ = arrayCopy(this.__actions__);
    12731 
    12732                 actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
    12733                 result.__chain__ = chainAll;
    12734                 return result;
    12735               }
    12736               var args = [this.value()];
    12737               push.apply(args, arguments);
    12738               return func.apply(object, args);
    12739             };
    12740           }(func));
    12741         }
    12742       }
    12743       return object;
    12744     }
    12745 
    12746     /**
    12747      * Reverts the `_` variable to its previous value and returns a reference to
    12748      * the `lodash` function.
    12749      *
    12750      * @static
    12751      * @memberOf _
    12752      * @category Utility
    12753      * @returns {Function} Returns the `lodash` function.
    12754      * @example
    12755      *
    12756      * var lodash = _.noConflict();
    12757      */
    12758     function noConflict() {
    12759       context._ = oldDash;
    12760       return this;
    12761     }
    12762 
    12763     /**
    12764      * A no-operation function which returns `undefined` regardless of the
    12765      * arguments it receives.
    12766      *
    12767      * @static
    12768      * @memberOf _
    12769      * @category Utility
    12770      * @example
    12771      *
    12772      * var object = { 'user': 'fred' };
    12773      *
    12774      * _.noop(object) === undefined;
    12775      * // => true
    12776      */
    12777     function noop() {
    12778       // No operation performed.
    12779     }
    12780 
    12781     /**
    12782      * Creates a function which returns the property value at `path` on a
    12783      * given object.
    12784      *
    12785      * @static
    12786      * @memberOf _
    12787      * @category Utility
    12788      * @param {Array|string} path The path of the property to get.
    12789      * @returns {Function} Returns the new function.
    12790      * @example
    12791      *
    12792      * var objects = [
    12793      *   { 'a': { 'b': { 'c': 2 } } },
    12794      *   { 'a': { 'b': { 'c': 1 } } }
    12795      * ];
    12796      *
    12797      * _.map(objects, _.property('a.b.c'));
    12798      * // => [2, 1]
    12799      *
    12800      * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');
    12801      * // => [1, 2]
    12802      */
    12803     function property(path) {
    12804       return isKey(path) ? baseProperty(path) : basePropertyDeep(path);
    12805     }
    12806 
    12807     /**
    12808      * The opposite of `_.property`; this method creates a function which returns
    12809      * the property value at a given path on `object`.
    12810      *
    12811      * @static
    12812      * @memberOf _
    12813      * @category Utility
    12814      * @param {Object} object The object to query.
    12815      * @returns {Function} Returns the new function.
    12816      * @example
    12817      *
    12818      * var array = [0, 1, 2],
    12819      *     object = { 'a': array, 'b': array, 'c': array };
    12820      *
    12821      * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
    12822      * // => [2, 0]
    12823      *
    12824      * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
    12825      * // => [2, 0]
    12826      */
    12827     function propertyOf(object) {
    12828       return function(path) {
    12829         return baseGet(object, toPath(path), path + '');
    12830       };
    12831     }
    12832 
    12833     /**
    12834      * Creates an array of numbers (positive and/or negative) progressing from
    12835      * `start` up to, but not including, `end`. If `end` is not specified it is
    12836      * set to `start` with `start` then set to `0`. If `end` is less than `start`
    12837      * a zero-length range is created unless a negative `step` is specified.
    12838      *
    12839      * @static
    12840      * @memberOf _
    12841      * @category Utility
    12842      * @param {number} [start=0] The start of the range.
    12843      * @param {number} end The end of the range.
    12844      * @param {number} [step=1] The value to increment or decrement by.
    12845      * @returns {Array} Returns the new array of numbers.
    12846      * @example
    12847      *
    12848      * _.range(4);
    12849      * // => [0, 1, 2, 3]
    12850      *
    12851      * _.range(1, 5);
    12852      * // => [1, 2, 3, 4]
    12853      *
    12854      * _.range(0, 20, 5);
    12855      * // => [0, 5, 10, 15]
    12856      *
    12857      * _.range(0, -4, -1);
    12858      * // => [0, -1, -2, -3]
    12859      *
    12860      * _.range(1, 4, 0);
    12861      * // => [1, 1, 1]
    12862      *
    12863      * _.range(0);
    12864      * // => []
    12865      */
    12866     function range(start, end, step) {
    12867       if (step && isIterateeCall(start, end, step)) {
    12868         end = step = null;
    12869       }
    12870       start = +start || 0;
    12871       step = step == null ? 1 : (+step || 0);
    12872 
    12873       if (end == null) {
    12874         end = start;
    12875         start = 0;
    12876       } else {
    12877         end = +end || 0;
    12878       }
    12879       // Use `Array(length)` so engines like Chakra and V8 avoid slower modes.
    12880       // See https://youtu.be/XAqIpGU8ZZk#t=17m25s for more details.
    12881       var index = -1,
    12882           length = nativeMax(ceil((end - start) / (step || 1)), 0),
    12883           result = Array(length);
    12884 
    12885       while (++index < length) {
    12886         result[index] = start;
    12887         start += step;
    12888       }
    12889       return result;
    12890     }
    12891 
    12892     /**
    12893      * Invokes the iteratee function `n` times, returning an array of the results
    12894      * of each invocation. The `iteratee` is bound to `thisArg` and invoked with
    12895      * one argument; (index).
    12896      *
    12897      * @static
    12898      * @memberOf _
    12899      * @category Utility
    12900      * @param {number} n The number of times to invoke `iteratee`.
    12901      * @param {Function} [iteratee=_.identity] The function invoked per iteration.
    12902      * @param {*} [thisArg] The `this` binding of `iteratee`.
    12903      * @returns {Array} Returns the array of results.
    12904      * @example
    12905      *
    12906      * var diceRolls = _.times(3, _.partial(_.random, 1, 6, false));
    12907      * // => [3, 6, 4]
    12908      *
    12909      * _.times(3, function(n) {
    12910      *   mage.castSpell(n);
    12911      * });
    12912      * // => invokes `mage.castSpell(n)` three times with `n` of `0`, `1`, and `2`
    12913      *
    12914      * _.times(3, function(n) {
    12915      *   this.cast(n);
    12916      * }, mage);
    12917      * // => also invokes `mage.castSpell(n)` three times
    12918      */
    12919     function times(n, iteratee, thisArg) {
    12920       n = floor(n);
    12921 
    12922       // Exit early to avoid a JSC JIT bug in Safari 8
    12923       // where `Array(0)` is treated as `Array(1)`.
    12924       if (n < 1 || !nativeIsFinite(n)) {
    12925         return [];
    12926       }
    12927       var index = -1,
    12928           result = Array(nativeMin(n, MAX_ARRAY_LENGTH));
    12929 
    12930       iteratee = bindCallback(iteratee, thisArg, 1);
    12931       while (++index < n) {
    12932         if (index < MAX_ARRAY_LENGTH) {
    12933           result[index] = iteratee(index);
    12934         } else {
    12935           iteratee(index);
    12936         }
    12937       }
    12938       return result;
    12939     }
    12940 
    12941     /**
    12942      * Generates a unique ID. If `prefix` is provided the ID is appended to it.
    12943      *
    12944      * @static
    12945      * @memberOf _
    12946      * @category Utility
    12947      * @param {string} [prefix] The value to prefix the ID with.
    12948      * @returns {string} Returns the unique ID.
    12949      * @example
    12950      *
    12951      * _.uniqueId('contact_');
    12952      * // => 'contact_104'
    12953      *
    12954      * _.uniqueId();
    12955      * // => '105'
    12956      */
    12957     function uniqueId(prefix) {
    12958       var id = ++idCounter;
    12959       return baseToString(prefix) + id;
    12960     }
    12961 
    12962     /*------------------------------------------------------------------------*/
    12963 
    12964     /**
    12965      * Adds two numbers.
    12966      *
    12967      * @static
    12968      * @memberOf _
    12969      * @category Math
    12970      * @param {number} augend The first number to add.
    12971      * @param {number} addend The second number to add.
    12972      * @returns {number} Returns the sum.
    12973      * @example
    12974      *
    12975      * _.add(6, 4);
    12976      * // => 10
    12977      */
    12978     function add(augend, addend) {
    12979       return (+augend || 0) + (+addend || 0);
    12980     }
    12981 
    12982     /**
    12983      * Gets the maximum value of `collection`. If `collection` is empty or falsey
    12984      * `-Infinity` is returned. If an iteratee function is provided it is invoked
    12985      * for each value in `collection` to generate the criterion by which the value
    12986      * is ranked. The `iteratee` is bound to `thisArg` and invoked with three
    12987      * arguments: (value, index, collection).
    12988      *
    12989      * If a property name is provided for `iteratee` the created `_.property`
    12990      * style callback returns the property value of the given element.
    12991      *
    12992      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    12993      * style callback returns `true` for elements that have a matching property
    12994      * value, else `false`.
    12995      *
    12996      * If an object is provided for `iteratee` the created `_.matches` style
    12997      * callback returns `true` for elements that have the properties of the given
    12998      * object, else `false`.
    12999      *
    13000      * @static
    13001      * @memberOf _
    13002      * @category Math
    13003      * @param {Array|Object|string} collection The collection to iterate over.
    13004      * @param {Function|Object|string} [iteratee] The function invoked per iteration.
    13005      * @param {*} [thisArg] The `this` binding of `iteratee`.
    13006      * @returns {*} Returns the maximum value.
    13007      * @example
    13008      *
    13009      * _.max([4, 2, 8, 6]);
    13010      * // => 8
    13011      *
    13012      * _.max([]);
    13013      * // => -Infinity
    13014      *
    13015      * var users = [
    13016      *   { 'user': 'barney', 'age': 36 },
    13017      *   { 'user': 'fred',   'age': 40 }
    13018      * ];
    13019      *
    13020      * _.max(users, function(chr) {
    13021      *   return chr.age;
    13022      * });
    13023      * // => { 'user': 'fred', 'age': 40 }
    13024      *
    13025      * // using the `_.property` callback shorthand
    13026      * _.max(users, 'age');
    13027      * // => { 'user': 'fred', 'age': 40 }
    13028      */
    13029     var max = createExtremum(arrayMax);
    13030 
    13031     /**
    13032      * Gets the minimum value of `collection`. If `collection` is empty or falsey
    13033      * `Infinity` is returned. If an iteratee function is provided it is invoked
    13034      * for each value in `collection` to generate the criterion by which the value
    13035      * is ranked. The `iteratee` is bound to `thisArg` and invoked with three
    13036      * arguments: (value, index, collection).
    13037      *
    13038      * If a property name is provided for `iteratee` the created `_.property`
    13039      * style callback returns the property value of the given element.
    13040      *
    13041      * If a value is also provided for `thisArg` the created `_.matchesProperty`
    13042      * style callback returns `true` for elements that have a matching property
    13043      * value, else `false`.
    13044      *
    13045      * If an object is provided for `iteratee` the created `_.matches` style
    13046      * callback returns `true` for elements that have the properties of the given
    13047      * object, else `false`.
    13048      *
    13049      * @static
    13050      * @memberOf _
    13051      * @category Math
    13052      * @param {Array|Object|string} collection The collection to iterate over.
    13053      * @param {Function|Object|string} [iteratee] The function invoked per iteration.
    13054      * @param {*} [thisArg] The `this` binding of `iteratee`.
    13055      * @returns {*} Returns the minimum value.
    13056      * @example
    13057      *
    13058      * _.min([4, 2, 8, 6]);
    13059      * // => 2
    13060      *
    13061      * _.min([]);
    13062      * // => Infinity
    13063      *
    13064      * var users = [
    13065      *   { 'user': 'barney', 'age': 36 },
    13066      *   { 'user': 'fred',   'age': 40 }
    13067      * ];
    13068      *
    13069      * _.min(users, function(chr) {
    13070      *   return chr.age;
    13071      * });
    13072      * // => { 'user': 'barney', 'age': 36 }
    13073      *
    13074      * // using the `_.property` callback shorthand
    13075      * _.min(users, 'age');
    13076      * // => { 'user': 'barney', 'age': 36 }
    13077      */
    13078     var min = createExtremum(arrayMin, true);
    13079 
    13080     /**
    13081      * Gets the sum of the values in `collection`.
    13082      *
    13083      * @static
    13084      * @memberOf _
    13085      * @category Math
    13086      * @param {Array|Object|string} collection The collection to iterate over.
    13087      * @param {Function|Object|string} [iteratee] The function invoked per iteration.
    13088      * @param {*} [thisArg] The `this` binding of `iteratee`.
    13089      * @returns {number} Returns the sum.
    13090      * @example
    13091      *
    13092      * _.sum([4, 6]);
    13093      * // => 10
    13094      *
    13095      * _.sum({ 'a': 4, 'b': 6 });
    13096      * // => 10
    13097      *
    13098      * var objects = [
    13099      *   { 'n': 4 },
    13100      *   { 'n': 6 }
    13101      * ];
    13102      *
    13103      * _.sum(objects, function(object) {
    13104      *   return object.n;
    13105      * });
    13106      * // => 10
    13107      *
    13108      * // using the `_.property` callback shorthand
    13109      * _.sum(objects, 'n');
    13110      * // => 10
    13111      */
    13112     function sum(collection, iteratee, thisArg) {
    13113       if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {
    13114         iteratee = null;
    13115       }
    13116       var func = getCallback(),
    13117           noIteratee = iteratee == null;
    13118 
    13119       if (!(func === baseCallback && noIteratee)) {
    13120         noIteratee = false;
    13121         iteratee = func(iteratee, thisArg, 3);
    13122       }
    13123       return noIteratee
    13124         ? arraySum(isArray(collection) ? collection : toIterable(collection))
    13125         : baseSum(collection, iteratee);
    13126     }
    13127 
    13128     /*------------------------------------------------------------------------*/
    13129 
    13130     // Ensure wrappers are instances of `baseLodash`.
    13131     lodash.prototype = baseLodash.prototype;
    13132 
    13133     LodashWrapper.prototype = baseCreate(baseLodash.prototype);
    13134     LodashWrapper.prototype.constructor = LodashWrapper;
    13135 
    13136     LazyWrapper.prototype = baseCreate(baseLodash.prototype);
    13137     LazyWrapper.prototype.constructor = LazyWrapper;
    13138 
    13139     // Add functions to the `Map` cache.
    13140     MapCache.prototype['delete'] = mapDelete;
    13141     MapCache.prototype.get = mapGet;
    13142     MapCache.prototype.has = mapHas;
    13143     MapCache.prototype.set = mapSet;
    13144 
    13145     // Add functions to the `Set` cache.
    13146     SetCache.prototype.push = cachePush;
    13147 
    13148     // Assign cache to `_.memoize`.
    13149     memoize.Cache = MapCache;
    13150 
    13151     // Add functions that return wrapped values when chaining.
    13152     lodash.after = after;
    13153     lodash.ary = ary;
    13154     lodash.assign = assign;
    13155     lodash.at = at;
    13156     lodash.before = before;
    13157     lodash.bind = bind;
    13158     lodash.bindAll = bindAll;
    13159     lodash.bindKey = bindKey;
    13160     lodash.callback = callback;
    13161     lodash.chain = chain;
    13162     lodash.chunk = chunk;
    13163     lodash.compact = compact;
    13164     lodash.constant = constant;
    13165     lodash.countBy = countBy;
    13166     lodash.create = create;
    13167     lodash.curry = curry;
    13168     lodash.curryRight = curryRight;
    13169     lodash.debounce = debounce;
    13170     lodash.defaults = defaults;
    13171     lodash.defer = defer;
    13172     lodash.delay = delay;
    13173     lodash.difference = difference;
    13174     lodash.drop = drop;
    13175     lodash.dropRight = dropRight;
    13176     lodash.dropRightWhile = dropRightWhile;
    13177     lodash.dropWhile = dropWhile;
    13178     lodash.fill = fill;
    13179     lodash.filter = filter;
    13180     lodash.flatten = flatten;
    13181     lodash.flattenDeep = flattenDeep;
    13182     lodash.flow = flow;
    13183     lodash.flowRight = flowRight;
    13184     lodash.forEach = forEach;
    13185     lodash.forEachRight = forEachRight;
    13186     lodash.forIn = forIn;
    13187     lodash.forInRight = forInRight;
    13188     lodash.forOwn = forOwn;
    13189     lodash.forOwnRight = forOwnRight;
    13190     lodash.functions = functions;
    13191     lodash.groupBy = groupBy;
    13192     lodash.indexBy = indexBy;
    13193     lodash.initial = initial;
    13194     lodash.intersection = intersection;
    13195     lodash.invert = invert;
    13196     lodash.invoke = invoke;
    13197     lodash.keys = keys;
    13198     lodash.keysIn = keysIn;
    13199     lodash.map = map;
    13200     lodash.mapValues = mapValues;
    13201     lodash.matches = matches;
    13202     lodash.matchesProperty = matchesProperty;
    13203     lodash.memoize = memoize;
    13204     lodash.merge = merge;
    13205     lodash.method = method;
    13206     lodash.methodOf = methodOf;
    13207     lodash.mixin = mixin;
    13208     lodash.negate = negate;
    13209     lodash.omit = omit;
    13210     lodash.once = once;
    13211     lodash.pairs = pairs;
    13212     lodash.partial = partial;
    13213     lodash.partialRight = partialRight;
    13214     lodash.partition = partition;
    13215     lodash.pick = pick;
    13216     lodash.pluck = pluck;
    13217     lodash.property = property;
    13218     lodash.propertyOf = propertyOf;
    13219     lodash.pull = pull;
    13220     lodash.pullAt = pullAt;
    13221     lodash.range = range;
    13222     lodash.rearg = rearg;
    13223     lodash.reject = reject;
    13224     lodash.remove = remove;
    13225     lodash.rest = rest;
    13226     lodash.restParam = restParam;
    13227     lodash.set = set;
    13228     lodash.shuffle = shuffle;
    13229     lodash.slice = slice;
    13230     lodash.sortBy = sortBy;
    13231     lodash.sortByAll = sortByAll;
    13232     lodash.sortByOrder = sortByOrder;
    13233     lodash.spread = spread;
    13234     lodash.take = take;
    13235     lodash.takeRight = takeRight;
    13236     lodash.takeRightWhile = takeRightWhile;
    13237     lodash.takeWhile = takeWhile;
    13238     lodash.tap = tap;
    13239     lodash.throttle = throttle;
    13240     lodash.thru = thru;
    13241     lodash.times = times;
    13242     lodash.toArray = toArray;
    13243     lodash.toPlainObject = toPlainObject;
    13244     lodash.transform = transform;
    13245     lodash.union = union;
    13246     lodash.uniq = uniq;
    13247     lodash.unzip = unzip;
    13248     lodash.values = values;
    13249     lodash.valuesIn = valuesIn;
    13250     lodash.where = where;
    13251     lodash.without = without;
    13252     lodash.wrap = wrap;
    13253     lodash.xor = xor;
    13254     lodash.zip = zip;
    13255     lodash.zipObject = zipObject;
    13256 
    13257     // Add aliases.
    13258     lodash.backflow = flowRight;
    13259     lodash.collect = map;
    13260     lodash.compose = flowRight;
    13261     lodash.each = forEach;
    13262     lodash.eachRight = forEachRight;
    13263     lodash.extend = assign;
    13264     lodash.iteratee = callback;
    13265     lodash.methods = functions;
    13266     lodash.object = zipObject;
    13267     lodash.select = filter;
    13268     lodash.tail = rest;
    13269     lodash.unique = uniq;
    13270 
    13271     // Add functions to `lodash.prototype`.
    13272     mixin(lodash, lodash);
    13273 
    13274     /*------------------------------------------------------------------------*/
    13275 
    13276     // Add functions that return unwrapped values when chaining.
    13277     lodash.add = add;
    13278     lodash.attempt = attempt;
    13279     lodash.camelCase = camelCase;
    13280     lodash.capitalize = capitalize;
    13281     lodash.clone = clone;
    13282     lodash.cloneDeep = cloneDeep;
    13283     lodash.deburr = deburr;
    13284     lodash.endsWith = endsWith;
    13285     lodash.escape = escape;
    13286     lodash.escapeRegExp = escapeRegExp;
    13287     lodash.every = every;
    13288     lodash.find = find;
    13289     lodash.findIndex = findIndex;
    13290     lodash.findKey = findKey;
    13291     lodash.findLast = findLast;
    13292     lodash.findLastIndex = findLastIndex;
    13293     lodash.findLastKey = findLastKey;
    13294     lodash.findWhere = findWhere;
    13295     lodash.first = first;
    13296     lodash.get = get;
    13297     lodash.has = has;
    13298     lodash.identity = identity;
    13299     lodash.includes = includes;
    13300     lodash.indexOf = indexOf;
    13301     lodash.inRange = inRange;
    13302     lodash.isArguments = isArguments;
    13303     lodash.isArray = isArray;
    13304     lodash.isBoolean = isBoolean;
    13305     lodash.isDate = isDate;
    13306     lodash.isElement = isElement;
    13307     lodash.isEmpty = isEmpty;
    13308     lodash.isEqual = isEqual;
    13309     lodash.isError = isError;
    13310     lodash.isFinite = isFinite;
    13311     lodash.isFunction = isFunction;
    13312     lodash.isMatch = isMatch;
    13313     lodash.isNaN = isNaN;
    13314     lodash.isNative = isNative;
    13315     lodash.isNull = isNull;
    13316     lodash.isNumber = isNumber;
    13317     lodash.isObject = isObject;
    13318     lodash.isPlainObject = isPlainObject;
    13319     lodash.isRegExp = isRegExp;
    13320     lodash.isString = isString;
    13321     lodash.isTypedArray = isTypedArray;
    13322     lodash.isUndefined = isUndefined;
    13323     lodash.kebabCase = kebabCase;
    13324     lodash.last = last;
    13325     lodash.lastIndexOf = lastIndexOf;
    13326     lodash.max = max;
    13327     lodash.min = min;
    13328     lodash.noConflict = noConflict;
    13329     lodash.noop = noop;
    13330     lodash.now = now;
    13331     lodash.pad = pad;
    13332     lodash.padLeft = padLeft;
    13333     lodash.padRight = padRight;
    13334     lodash.parseInt = parseInt;
    13335     lodash.random = random;
    13336     lodash.reduce = reduce;
    13337     lodash.reduceRight = reduceRight;
    13338     lodash.repeat = repeat;
    13339     lodash.result = result;
    13340     lodash.runInContext = runInContext;
    13341     lodash.size = size;
    13342     lodash.snakeCase = snakeCase;
    13343     lodash.some = some;
    13344     lodash.sortedIndex = sortedIndex;
    13345     lodash.sortedLastIndex = sortedLastIndex;
    13346     lodash.startCase = startCase;
    13347     lodash.startsWith = startsWith;
    13348     lodash.sum = sum;
    13349     lodash.template = template;
    13350     lodash.trim = trim;
    13351     lodash.trimLeft = trimLeft;
    13352     lodash.trimRight = trimRight;
    13353     lodash.trunc = trunc;
    13354     lodash.unescape = unescape;
    13355     lodash.uniqueId = uniqueId;
    13356     lodash.words = words;
    13357 
    13358     // Add aliases.
    13359     lodash.all = every;
    13360     lodash.any = some;
    13361     lodash.contains = includes;
    13362     lodash.detect = find;
    13363     lodash.foldl = reduce;
    13364     lodash.foldr = reduceRight;
    13365     lodash.head = first;
    13366     lodash.include = includes;
    13367     lodash.inject = reduce;
    13368 
    13369     mixin(lodash, (function() {
    13370       var source = {};
    13371       baseForOwn(lodash, function(func, methodName) {
    13372         if (!lodash.prototype[methodName]) {
    13373           source[methodName] = func;
    13374         }
    13375       });
    13376       return source;
    13377     }()), false);
    13378 
    13379     /*------------------------------------------------------------------------*/
    13380 
    13381     // Add functions capable of returning wrapped and unwrapped values when chaining.
    13382     lodash.sample = sample;
    13383 
    13384     lodash.prototype.sample = function(n) {
    13385       if (!this.__chain__ && n == null) {
    13386         return sample(this.value());
    13387       }
    13388       return this.thru(function(value) {
    13389         return sample(value, n);
    13390       });
    13391     };
    13392 
    13393     /*------------------------------------------------------------------------*/
    13394 
    13395     /**
    13396      * The semantic version number.
    13397      *
    13398      * @static
    13399      * @memberOf _
    13400      * @type string
    13401      */
    13402     lodash.VERSION = VERSION;
    13403 
    13404     // Assign default placeholders.
    13405     arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
    13406       lodash[methodName].placeholder = lodash;
    13407     });
    13408 
    13409     // Add `LazyWrapper` methods that accept an `iteratee` value.
    13410     arrayEach(['dropWhile', 'filter', 'map', 'takeWhile'], function(methodName, type) {
    13411       var isFilter = type != LAZY_MAP_FLAG,
    13412           isDropWhile = type == LAZY_DROP_WHILE_FLAG;
    13413 
    13414       LazyWrapper.prototype[methodName] = function(iteratee, thisArg) {
    13415         var filtered = this.__filtered__,
    13416             result = (filtered && isDropWhile) ? new LazyWrapper(this) : this.clone(),
    13417             iteratees = result.__iteratees__ || (result.__iteratees__ = []);
    13418 
    13419         iteratees.push({
    13420           'done': false,
    13421           'count': 0,
    13422           'index': 0,
    13423           'iteratee': getCallback(iteratee, thisArg, 1),
    13424           'limit': -1,
    13425           'type': type
    13426         });
    13427 
    13428         result.__filtered__ = filtered || isFilter;
    13429         return result;
    13430       };
    13431     });
    13432 
    13433     // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
    13434     arrayEach(['drop', 'take'], function(methodName, index) {
    13435       var whileName = methodName + 'While';
    13436 
    13437       LazyWrapper.prototype[methodName] = function(n) {
    13438         var filtered = this.__filtered__,
    13439             result = (filtered && !index) ? this.dropWhile() : this.clone();
    13440 
    13441         n = n == null ? 1 : nativeMax(floor(n) || 0, 0);
    13442         if (filtered) {
    13443           if (index) {
    13444             result.__takeCount__ = nativeMin(result.__takeCount__, n);
    13445           } else {
    13446             last(result.__iteratees__).limit = n;
    13447           }
    13448         } else {
    13449           var views = result.__views__ || (result.__views__ = []);
    13450           views.push({ 'size': n, 'type': methodName + (result.__dir__ < 0 ? 'Right' : '') });
    13451         }
    13452         return result;
    13453       };
    13454 
    13455       LazyWrapper.prototype[methodName + 'Right'] = function(n) {
    13456         return this.reverse()[methodName](n).reverse();
    13457       };
    13458 
    13459       LazyWrapper.prototype[methodName + 'RightWhile'] = function(predicate, thisArg) {
    13460         return this.reverse()[whileName](predicate, thisArg).reverse();
    13461       };
    13462     });
    13463 
    13464     // Add `LazyWrapper` methods for `_.first` and `_.last`.
    13465     arrayEach(['first', 'last'], function(methodName, index) {
    13466       var takeName = 'take' + (index ? 'Right' : '');
    13467 
    13468       LazyWrapper.prototype[methodName] = function() {
    13469         return this[takeName](1).value()[0];
    13470       };
    13471     });
    13472 
    13473     // Add `LazyWrapper` methods for `_.initial` and `_.rest`.
    13474     arrayEach(['initial', 'rest'], function(methodName, index) {
    13475       var dropName = 'drop' + (index ? '' : 'Right');
    13476 
    13477       LazyWrapper.prototype[methodName] = function() {
    13478         return this[dropName](1);
    13479       };
    13480     });
    13481 
    13482     // Add `LazyWrapper` methods for `_.pluck` and `_.where`.
    13483     arrayEach(['pluck', 'where'], function(methodName, index) {
    13484       var operationName = index ? 'filter' : 'map',
    13485           createCallback = index ? baseMatches : property;
    13486 
    13487       LazyWrapper.prototype[methodName] = function(value) {
    13488         return this[operationName](createCallback(value));
    13489       };
    13490     });
    13491 
    13492     LazyWrapper.prototype.compact = function() {
    13493       return this.filter(identity);
    13494     };
    13495 
    13496     LazyWrapper.prototype.reject = function(predicate, thisArg) {
    13497       predicate = getCallback(predicate, thisArg, 1);
    13498       return this.filter(function(value) {
    13499         return !predicate(value);
    13500       });
    13501     };
    13502 
    13503     LazyWrapper.prototype.slice = function(start, end) {
    13504       start = start == null ? 0 : (+start || 0);
    13505       var result = start < 0 ? this.takeRight(-start) : this.drop(start);
    13506 
    13507       if (end !== undefined) {
    13508         end = (+end || 0);
    13509         result = end < 0 ? result.dropRight(-end) : result.take(end - start);
    13510       }
    13511       return result;
    13512     };
    13513 
    13514     LazyWrapper.prototype.toArray = function() {
    13515       return this.drop(0);
    13516     };
    13517 
    13518     // Add `LazyWrapper` methods to `lodash.prototype`.
    13519     baseForOwn(LazyWrapper.prototype, function(func, methodName) {
    13520       var lodashFunc = lodash[methodName];
    13521       if (!lodashFunc) {
    13522         return;
    13523       }
    13524       var checkIteratee = /^(?:filter|map|reject)|While$/.test(methodName),
    13525           retUnwrapped = /^(?:first|last)$/.test(methodName);
    13526 
    13527       lodash.prototype[methodName] = function() {
    13528         var args = arguments,
    13529             length = args.length,
    13530             chainAll = this.__chain__,
    13531             value = this.__wrapped__,
    13532             isHybrid = !!this.__actions__.length,
    13533             isLazy = value instanceof LazyWrapper,
    13534             iteratee = args[0],
    13535             useLazy = isLazy || isArray(value);
    13536 
    13537         if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
    13538           // avoid lazy use if the iteratee has a "length" value other than `1`
    13539           isLazy = useLazy = false;
    13540         }
    13541         var onlyLazy = isLazy && !isHybrid;
    13542         if (retUnwrapped && !chainAll) {
    13543           return onlyLazy
    13544             ? func.call(value)
    13545             : lodashFunc.call(lodash, this.value());
    13546         }
    13547         var interceptor = function(value) {
    13548           var otherArgs = [value];
    13549           push.apply(otherArgs, args);
    13550           return lodashFunc.apply(lodash, otherArgs);
    13551         };
    13552         if (useLazy) {
    13553           var wrapper = onlyLazy ? value : new LazyWrapper(this),
    13554               result = func.apply(wrapper, args);
    13555 
    13556           if (!retUnwrapped && (isHybrid || result.__actions__)) {
    13557             var actions = result.__actions__ || (result.__actions__ = []);
    13558             actions.push({ 'func': thru, 'args': [interceptor], 'thisArg': lodash });
    13559           }
    13560           return new LodashWrapper(result, chainAll);
    13561         }
    13562         return this.thru(interceptor);
    13563       };
    13564     });
    13565 
    13566     // Add `Array` and `String` methods to `lodash.prototype`.
    13567     arrayEach(['concat', 'join', 'pop', 'push', 'replace', 'shift', 'sort', 'splice', 'split', 'unshift'], function(methodName) {
    13568       var func = (/^(?:replace|split)$/.test(methodName) ? stringProto : arrayProto)[methodName],
    13569           chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
    13570           retUnwrapped = /^(?:join|pop|replace|shift)$/.test(methodName);
    13571 
    13572       lodash.prototype[methodName] = function() {
    13573         var args = arguments;
    13574         if (retUnwrapped && !this.__chain__) {
    13575           return func.apply(this.value(), args);
    13576         }
    13577         return this[chainName](function(value) {
    13578           return func.apply(value, args);
    13579         });
    13580       };
    13581     });
    13582 
    13583     // Map minified function names to their real names.
    13584     baseForOwn(LazyWrapper.prototype, function(func, methodName) {
    13585       var lodashFunc = lodash[methodName];
    13586       if (lodashFunc) {
    13587         var key = lodashFunc.name,
    13588             names = realNames[key] || (realNames[key] = []);
    13589 
    13590         names.push({ 'name': methodName, 'func': lodashFunc });
    13591       }
    13592     });
    13593 
    13594     realNames[createHybridWrapper(null, BIND_KEY_FLAG).name] = [{ 'name': 'wrapper', 'func': null }];
    13595 
    13596     // Add functions to the lazy wrapper.
    13597     LazyWrapper.prototype.clone = lazyClone;
    13598     LazyWrapper.prototype.reverse = lazyReverse;
    13599     LazyWrapper.prototype.value = lazyValue;
    13600 
    13601     // Add chaining functions to the `lodash` wrapper.
    13602     lodash.prototype.chain = wrapperChain;
    13603     lodash.prototype.commit = wrapperCommit;
    13604     lodash.prototype.plant = wrapperPlant;
    13605     lodash.prototype.reverse = wrapperReverse;
    13606     lodash.prototype.toString = wrapperToString;
    13607     lodash.prototype.run = lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
    13608 
    13609     // Add function aliases to the `lodash` wrapper.
    13610     lodash.prototype.collect = lodash.prototype.map;
    13611     lodash.prototype.head = lodash.prototype.first;
    13612     lodash.prototype.select = lodash.prototype.filter;
    13613     lodash.prototype.tail = lodash.prototype.rest;
    13614 
    13615     return lodash;
    13616   }
    13617 
    13618   /*--------------------------------------------------------------------------*/
    13619 
    13620   // Export lodash.
    13621   var _ = runInContext();
    13622 
    13623   // Some AMD build optimizers like r.js check for condition patterns like the following:
    13624   if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
    13625     // Expose lodash to the global object when an AMD loader is present to avoid
    13626     // errors in cases where lodash is loaded by a script tag and not intended
    13627     // as an AMD module. See http://requirejs.org/docs/errors.html#mismatch for
    13628     // more details.
    13629     root._ = _;
    13630 
    13631     // Define as an anonymous module so, through path mapping, it can be
    13632     // referenced as the "underscore" module.
    13633     define(function() {
    13634       return _;
    13635     });
    13636   }
    13637   // Check for `exports` after `define` in case a build optimizer adds an `exports` object.
    13638   else if (freeExports && freeModule) {
    13639     // Export for Node.js or RingoJS.
    13640     if (moduleExports) {
    13641       (freeModule.exports = _)._ = _;
    13642     }
    13643     // Export for Narwhal or Rhino -require.
    13644     else {
    13645       freeExports._ = _;
    13646     }
    13647   }
    13648   else {
    13649     // Export for a browser or Rhino.
    13650     root._ = _;
    13651   }
    13652 }.call(this));
    13653 
    13654 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    13655 },{}],13:[function(require,module,exports){
    13656 /*
    13657  * Lexical analysis and token construction.
    13658  */
    13659 
    13660 "use strict";
    13661 
    13662 var _      = require("lodash");
    13663 var events = require("events");
    13664 var reg    = require("./reg.js");
    13665 var state  = require("./state.js").state;
    13666 
    13667 var unicodeData = require("../data/ascii-identifier-data.js");
    13668 var asciiIdentifierStartTable = unicodeData.asciiIdentifierStartTable;
    13669 var asciiIdentifierPartTable = unicodeData.asciiIdentifierPartTable;
    13670 var nonAsciiIdentifierStartTable = require("../data/non-ascii-identifier-start.js");
    13671 var nonAsciiIdentifierPartTable = require("../data/non-ascii-identifier-part-only.js");
    13672 
    13673 // Some of these token types are from JavaScript Parser API
    13674 // while others are specific to JSHint parser.
    13675 // JS Parser API: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
    13676 
    13677 var Token = {
    13678   Identifier: 1,
    13679   Punctuator: 2,
    13680   NumericLiteral: 3,
    13681   StringLiteral: 4,
    13682   Comment: 5,
    13683   Keyword: 6,
    13684   NullLiteral: 7,
    13685   BooleanLiteral: 8,
    13686   RegExp: 9,
    13687   TemplateHead: 10,
    13688   TemplateMiddle: 11,
    13689   TemplateTail: 12,
    13690   NoSubstTemplate: 13
    13691 };
    13692 
    13693 var Context = {
    13694   Block: 1,
    13695   Template: 2
    13696 };
    13697 
    13698 function isHex(str) {
    13699   return /^[0-9a-fA-F]+$/.test(str);
    13700 }
    13701 
    13702 function isHexDigit(str) {
    13703   return str.length === 1 && isHex(str);
    13704 }
    13705 
    13706 // Object that handles postponed lexing verifications that checks the parsed
    13707 // environment state.
    13708 
    13709 function asyncTrigger() {
    13710   var _checks = [];
    13711 
    13712   return {
    13713     push: function(fn) {
    13714       _checks.push(fn);
    13715     },
    13716 
    13717     check: function() {
    13718       for (var check = 0; check < _checks.length; ++check) {
    13719         _checks[check]();
    13720       }
    13721 
    13722       _checks.splice(0, _checks.length);
    13723     }
    13724   };
    13725 }
    13726 
    13727 /*
    13728  * Lexer for JSHint.
    13729  *
    13730  * This object does a char-by-char scan of the provided source code
    13731  * and produces a sequence of tokens.
    13732  *
    13733  *   var lex = new Lexer("var i = 0;");
    13734  *   lex.start();
    13735  *   lex.token(); // returns the next token
    13736  *
    13737  * You have to use the token() method to move the lexer forward
    13738  * but you don't have to use its return value to get tokens. In addition
    13739  * to token() method returning the next token, the Lexer object also
    13740  * emits events.
    13741  *
    13742  *   lex.on("Identifier", function(data) {
    13743  *     if (data.name.indexOf("_") >= 0) {
    13744  *       // Produce a warning.
    13745  *     }
    13746  *   });
    13747  *
    13748  * Note that the token() method returns tokens in a JSLint-compatible
    13749  * format while the event emitter uses a slightly modified version of
    13750  * Mozilla's JavaScript Parser API. Eventually, we will move away from
    13751  * JSLint format.
    13752  */
    13753 function Lexer(source) {
    13754   var lines = source;
    13755 
    13756   if (typeof lines === "string") {
    13757     lines = lines
    13758       .replace(/\r\n/g, "\n")
    13759       .replace(/\r/g, "\n")
    13760       .split("\n");
    13761   }
    13762 
    13763   // If the first line is a shebang (#!), make it a blank and move on.
    13764   // Shebangs are used by Node scripts.
    13765 
    13766   if (lines[0] && lines[0].substr(0, 2) === "#!") {
    13767     if (lines[0].indexOf("node") !== -1) {
    13768       state.option.node = true;
    13769     }
    13770     lines[0] = "";
    13771   }
    13772 
    13773   this.emitter = new events.EventEmitter();
    13774   this.source = source;
    13775   this.setLines(lines);
    13776   this.prereg = true;
    13777 
    13778   this.line = 0;
    13779   this.char = 1;
    13780   this.from = 1;
    13781   this.input = "";
    13782   this.inComment = false;
    13783   this.context = [];
    13784   this.templateStarts = [];
    13785 
    13786   for (var i = 0; i < state.option.indent; i += 1) {
    13787     state.tab += " ";
    13788   }
    13789 }
    13790 
    13791 Lexer.prototype = {
    13792   _lines: [],
    13793 
    13794   inContext: function(ctxType) {
    13795     return this.context.length > 0 && this.context[this.context.length - 1].type === ctxType;
    13796   },
    13797 
    13798   pushContext: function(ctxType) {
    13799     this.context.push({ type: ctxType });
    13800   },
    13801 
    13802   popContext: function() {
    13803     return this.context.pop();
    13804   },
    13805 
    13806   isContext: function(context) {
    13807     return this.context.length > 0 && this.context[this.context.length - 1] === context;
    13808   },
    13809 
    13810   currentContext: function() {
    13811     return this.context.length > 0 && this.context[this.context.length - 1];
    13812   },
    13813 
    13814   getLines: function() {
    13815     this._lines = state.lines;
    13816     return this._lines;
    13817   },
    13818 
    13819   setLines: function(val) {
    13820     this._lines = val;
    13821     state.lines = this._lines;
    13822   },
    13823 
    13824   /*
    13825    * Return the next i character without actually moving the
    13826    * char pointer.
    13827    */
    13828   peek: function(i) {
    13829     return this.input.charAt(i || 0);
    13830   },
    13831 
    13832   /*
    13833    * Move the char pointer forward i times.
    13834    */
    13835   skip: function(i) {
    13836     i = i || 1;
    13837     this.char += i;
    13838     this.input = this.input.slice(i);
    13839   },
    13840 
    13841   /*
    13842    * Subscribe to a token event. The API for this method is similar
    13843    * Underscore.js i.e. you can subscribe to multiple events with
    13844    * one call:
    13845    *
    13846    *   lex.on("Identifier Number", function(data) {
    13847    *     // ...
    13848    *   });
    13849    */
    13850   on: function(names, listener) {
    13851     names.split(" ").forEach(function(name) {
    13852       this.emitter.on(name, listener);
    13853     }.bind(this));
    13854   },
    13855 
    13856   /*
    13857    * Trigger a token event. All arguments will be passed to each
    13858    * listener.
    13859    */
    13860   trigger: function() {
    13861     this.emitter.emit.apply(this.emitter, Array.prototype.slice.call(arguments));
    13862   },
    13863 
    13864   /*
    13865    * Postpone a token event. the checking condition is set as
    13866    * last parameter, and the trigger function is called in a
    13867    * stored callback. To be later called using the check() function
    13868    * by the parser. This avoids parser's peek() to give the lexer
    13869    * a false context.
    13870    */
    13871   triggerAsync: function(type, args, checks, fn) {
    13872     checks.push(function() {
    13873       if (fn()) {
    13874         this.trigger(type, args);
    13875       }
    13876     }.bind(this));
    13877   },
    13878 
    13879   /*
    13880    * Extract a punctuator out of the next sequence of characters
    13881    * or return 'null' if its not possible.
    13882    *
    13883    * This method's implementation was heavily influenced by the
    13884    * scanPunctuator function in the Esprima parser's source code.
    13885    */
    13886   scanPunctuator: function() {
    13887     var ch1 = this.peek();
    13888     var ch2, ch3, ch4;
    13889 
    13890     switch (ch1) {
    13891     // Most common single-character punctuators
    13892     case ".":
    13893       if ((/^[0-9]$/).test(this.peek(1))) {
    13894         return null;
    13895       }
    13896       if (this.peek(1) === "." && this.peek(2) === ".") {
    13897         return {
    13898           type: Token.Punctuator,
    13899           value: "..."
    13900         };
    13901       }
    13902       /* falls through */
    13903     case "(":
    13904     case ")":
    13905     case ";":
    13906     case ",":
    13907     case "[":
    13908     case "]":
    13909     case ":":
    13910     case "~":
    13911     case "?":
    13912       return {
    13913         type: Token.Punctuator,
    13914         value: ch1
    13915       };
    13916 
    13917     // A block/object opener
    13918     case "{":
    13919       this.pushContext(Context.Block);
    13920       return {
    13921         type: Token.Punctuator,
    13922         value: ch1
    13923       };
    13924 
    13925     // A block/object closer
    13926     case "}":
    13927       if (this.inContext(Context.Block)) {
    13928         this.popContext();
    13929       }
    13930       return {
    13931         type: Token.Punctuator,
    13932         value: ch1
    13933       };
    13934 
    13935     // A pound sign (for Node shebangs)
    13936     case "#":
    13937       return {
    13938         type: Token.Punctuator,
    13939         value: ch1
    13940       };
    13941 
    13942     // We're at the end of input
    13943     case "":
    13944       return null;
    13945     }
    13946 
    13947     // Peek more characters
    13948 
    13949     ch2 = this.peek(1);
    13950     ch3 = this.peek(2);
    13951     ch4 = this.peek(3);
    13952 
    13953     // 4-character punctuator: >>>=
    13954 
    13955     if (ch1 === ">" && ch2 === ">" && ch3 === ">" && ch4 === "=") {
    13956       return {
    13957         type: Token.Punctuator,
    13958         value: ">>>="
    13959       };
    13960     }
    13961 
    13962     // 3-character punctuators: === !== >>> <<= >>=
    13963 
    13964     if (ch1 === "=" && ch2 === "=" && ch3 === "=") {
    13965       return {
    13966         type: Token.Punctuator,
    13967         value: "==="
    13968       };
    13969     }
    13970 
    13971     if (ch1 === "!" && ch2 === "=" && ch3 === "=") {
    13972       return {
    13973         type: Token.Punctuator,
    13974         value: "!=="
    13975       };
    13976     }
    13977 
    13978     if (ch1 === ">" && ch2 === ">" && ch3 === ">") {
    13979       return {
    13980         type: Token.Punctuator,
    13981         value: ">>>"
    13982       };
    13983     }
    13984 
    13985     if (ch1 === "<" && ch2 === "<" && ch3 === "=") {
    13986       return {
    13987         type: Token.Punctuator,
    13988         value: "<<="
    13989       };
    13990     }
    13991 
    13992     if (ch1 === ">" && ch2 === ">" && ch3 === "=") {
    13993       return {
    13994         type: Token.Punctuator,
    13995         value: ">>="
    13996       };
    13997     }
    13998 
    13999     // Fat arrow punctuator
    14000     if (ch1 === "=" && ch2 === ">") {
    14001       return {
    14002         type: Token.Punctuator,
    14003         value: ch1 + ch2
    14004       };
    14005     }
    14006 
    14007     // 2-character punctuators: <= >= == != ++ -- << >> && ||
    14008     // += -= *= %= &= |= ^= /=
    14009     if (ch1 === ch2 && ("+-<>&|".indexOf(ch1) >= 0)) {
    14010       return {
    14011         type: Token.Punctuator,
    14012         value: ch1 + ch2
    14013       };
    14014     }
    14015 
    14016     if ("<>=!+-*%&|^/".indexOf(ch1) >= 0) {
    14017       if (ch2 === "=") {
    14018         return {
    14019           type: Token.Punctuator,
    14020           value: ch1 + ch2
    14021         };
    14022       }
    14023 
    14024       return {
    14025         type: Token.Punctuator,
    14026         value: ch1
    14027       };
    14028     }
    14029 
    14030     return null;
    14031   },
    14032 
    14033   /*
    14034    * Extract a comment out of the next sequence of characters and/or
    14035    * lines or return 'null' if its not possible. Since comments can
    14036    * span across multiple lines this method has to move the char
    14037    * pointer.
    14038    *
    14039    * In addition to normal JavaScript comments (// and /*) this method
    14040    * also recognizes JSHint- and JSLint-specific comments such as
    14041    * /*jshint, /*jslint, /*globals and so on.
    14042    */
    14043   scanComments: function(checks) {
    14044     var ch1 = this.peek();
    14045     var ch2 = this.peek(1);
    14046     var rest = this.input.substr(2);
    14047     var startLine = this.line;
    14048     var startChar = this.char;
    14049     var self = this;
    14050 
    14051     // Create a comment token object and make sure it
    14052     // has all the data JSHint needs to work with special
    14053     // comments.
    14054 
    14055     function commentToken(label, body, opt) {
    14056       var special = ["jshint", "jslint", "members", "member", "globals", "global", "exported"];
    14057       var isSpecial = false;
    14058       var value = label + body;
    14059       var commentType = "plain";
    14060       opt = opt || {};
    14061 
    14062       if (opt.isMultiline) {
    14063         value += "*/";
    14064       }
    14065 
    14066       body = body.replace(/\n/g, " ");
    14067 
    14068       if (label === "/*" && reg.fallsThrough.test(body)) {
    14069         isSpecial = true;
    14070         commentType = "falls through";
    14071       }
    14072 
    14073       special.forEach(function(str) {
    14074         if (isSpecial) {
    14075           return;
    14076         }
    14077 
    14078         // Don't recognize any special comments other than jshint for single-line
    14079         // comments. This introduced many problems with legit comments.
    14080         if (label === "//" && str !== "jshint") {
    14081           return;
    14082         }
    14083 
    14084         if (body.charAt(str.length) === " " && body.substr(0, str.length) === str) {
    14085           isSpecial = true;
    14086           label = label + str;
    14087           body = body.substr(str.length);
    14088         }
    14089 
    14090         if (!isSpecial && body.charAt(0) === " " && body.charAt(str.length + 1) === " " &&
    14091           body.substr(1, str.length) === str) {
    14092           isSpecial = true;
    14093           label = label + " " + str;
    14094           body = body.substr(str.length + 1);
    14095         }
    14096 
    14097         if (!isSpecial) {
    14098           return;
    14099         }
    14100 
    14101         switch (str) {
    14102         case "member":
    14103           commentType = "members";
    14104           break;
    14105         case "global":
    14106           commentType = "globals";
    14107           break;
    14108         default:
    14109           var options = body.split(":").map(function(v) {
    14110             return v.replace(/^\s+/, "").replace(/\s+$/, "");
    14111           });
    14112 
    14113           if (options.length === 2) {
    14114             switch (options[0]) {
    14115             case "ignore":
    14116               switch (options[1]) {
    14117               case "start":
    14118                 self.ignoringLinterErrors = true;
    14119                 isSpecial = false;
    14120                 break;
    14121               case "end":
    14122                 self.ignoringLinterErrors = false;
    14123                 isSpecial = false;
    14124                 break;
    14125               }
    14126             }
    14127           }
    14128 
    14129           commentType = str;
    14130         }
    14131       });
    14132 
    14133       return {
    14134         type: Token.Comment,
    14135         commentType: commentType,
    14136         value: value,
    14137         body: body,
    14138         isSpecial: isSpecial,
    14139         isMultiline: opt.isMultiline || false,
    14140         isMalformed: opt.isMalformed || false
    14141       };
    14142     }
    14143 
    14144     // End of unbegun comment. Raise an error and skip that input.
    14145     if (ch1 === "*" && ch2 === "/") {
    14146       this.trigger("error", {
    14147         code: "E018",
    14148         line: startLine,
    14149         character: startChar
    14150       });
    14151 
    14152       this.skip(2);
    14153       return null;
    14154     }
    14155 
    14156     // Comments must start either with // or /*
    14157     if (ch1 !== "/" || (ch2 !== "*" && ch2 !== "/")) {
    14158       return null;
    14159     }
    14160 
    14161     // One-line comment
    14162     if (ch2 === "/") {
    14163       this.skip(this.input.length); // Skip to the EOL.
    14164       return commentToken("//", rest);
    14165     }
    14166 
    14167     var body = "";
    14168 
    14169     /* Multi-line comment */
    14170     if (ch2 === "*") {
    14171       this.inComment = true;
    14172       this.skip(2);
    14173 
    14174       while (this.peek() !== "*" || this.peek(1) !== "/") {
    14175         if (this.peek() === "") { // End of Line
    14176           body += "\n";
    14177 
    14178           // If we hit EOF and our comment is still unclosed,
    14179           // trigger an error and end the comment implicitly.
    14180           if (!this.nextLine(checks)) {
    14181             this.trigger("error", {
    14182               code: "E017",
    14183               line: startLine,
    14184               character: startChar
    14185             });
    14186 
    14187             this.inComment = false;
    14188             return commentToken("/*", body, {
    14189               isMultiline: true,
    14190               isMalformed: true
    14191             });
    14192           }
    14193         } else {
    14194           body += this.peek();
    14195           this.skip();
    14196         }
    14197       }
    14198 
    14199       this.skip(2);
    14200       this.inComment = false;
    14201       return commentToken("/*", body, { isMultiline: true });
    14202     }
    14203   },
    14204 
    14205   /*
    14206    * Extract a keyword out of the next sequence of characters or
    14207    * return 'null' if its not possible.
    14208    */
    14209   scanKeyword: function() {
    14210     var result = /^[a-zA-Z_$][a-zA-Z0-9_$]*/.exec(this.input);
    14211     var keywords = [
    14212       "if", "in", "do", "var", "for", "new",
    14213       "try", "let", "this", "else", "case",
    14214       "void", "with", "enum", "while", "break",
    14215       "catch", "throw", "const", "yield", "class",
    14216       "super", "return", "typeof", "delete",
    14217       "switch", "export", "import", "default",
    14218       "finally", "extends", "function", "continue",
    14219       "debugger", "instanceof"
    14220     ];
    14221 
    14222     if (result && keywords.indexOf(result[0]) >= 0) {
    14223       return {
    14224         type: Token.Keyword,
    14225         value: result[0]
    14226       };
    14227     }
    14228 
    14229     return null;
    14230   },
    14231 
    14232   /*
    14233    * Extract a JavaScript identifier out of the next sequence of
    14234    * characters or return 'null' if its not possible. In addition,
    14235    * to Identifier this method can also produce BooleanLiteral
    14236    * (true/false) and NullLiteral (null).
    14237    */
    14238   scanIdentifier: function() {
    14239     var id = "";
    14240     var index = 0;
    14241     var type, char;
    14242 
    14243     function isNonAsciiIdentifierStart(code) {
    14244       return nonAsciiIdentifierStartTable.indexOf(code) > -1;
    14245     }
    14246 
    14247     function isNonAsciiIdentifierPart(code) {
    14248       return isNonAsciiIdentifierStart(code) || nonAsciiIdentifierPartTable.indexOf(code) > -1;
    14249     }
    14250 
    14251     var readUnicodeEscapeSequence = function() {
    14252       /*jshint validthis:true */
    14253       index += 1;
    14254 
    14255       if (this.peek(index) !== "u") {
    14256         return null;
    14257       }
    14258 
    14259       var sequence = this.peek(index + 1) + this.peek(index + 2) +
    14260         this.peek(index + 3) + this.peek(index + 4);
    14261       var code;
    14262 
    14263       if (isHex(sequence)) {
    14264         code = parseInt(sequence, 16);
    14265 
    14266         if (asciiIdentifierPartTable[code] || isNonAsciiIdentifierPart(code)) {
    14267           index += 5;
    14268           return "\\u" + sequence;
    14269         }
    14270 
    14271         return null;
    14272       }
    14273 
    14274       return null;
    14275     }.bind(this);
    14276 
    14277     var getIdentifierStart = function() {
    14278       /*jshint validthis:true */
    14279       var chr = this.peek(index);
    14280       var code = chr.charCodeAt(0);
    14281 
    14282       if (code === 92) {
    14283         return readUnicodeEscapeSequence();
    14284       }
    14285 
    14286       if (code < 128) {
    14287         if (asciiIdentifierStartTable[code]) {
    14288           index += 1;
    14289           return chr;
    14290         }
    14291 
    14292         return null;
    14293       }
    14294 
    14295       if (isNonAsciiIdentifierStart(code)) {
    14296         index += 1;
    14297         return chr;
    14298       }
    14299 
    14300       return null;
    14301     }.bind(this);
    14302 
    14303     var getIdentifierPart = function() {
    14304       /*jshint validthis:true */
    14305       var chr = this.peek(index);
    14306       var code = chr.charCodeAt(0);
    14307 
    14308       if (code === 92) {
    14309         return readUnicodeEscapeSequence();
    14310       }
    14311 
    14312       if (code < 128) {
    14313         if (asciiIdentifierPartTable[code]) {
    14314           index += 1;
    14315           return chr;
    14316         }
    14317 
    14318         return null;
    14319       }
    14320 
    14321       if (isNonAsciiIdentifierPart(code)) {
    14322         index += 1;
    14323         return chr;
    14324       }
    14325 
    14326       return null;
    14327     }.bind(this);
    14328 
    14329     function removeEscapeSequences(id) {
    14330       return id.replace(/\\u([0-9a-fA-F]{4})/g, function(m0, codepoint) {
    14331         return String.fromCharCode(parseInt(codepoint, 16));
    14332       });
    14333     }
    14334 
    14335     char = getIdentifierStart();
    14336     if (char === null) {
    14337       return null;
    14338     }
    14339 
    14340     id = char;
    14341     for (;;) {
    14342       char = getIdentifierPart();
    14343 
    14344       if (char === null) {
    14345         break;
    14346       }
    14347 
    14348       id += char;
    14349     }
    14350 
    14351     switch (id) {
    14352     case "true":
    14353     case "false":
    14354       type = Token.BooleanLiteral;
    14355       break;
    14356     case "null":
    14357       type = Token.NullLiteral;
    14358       break;
    14359     default:
    14360       type = Token.Identifier;
    14361     }
    14362 
    14363     return {
    14364       type: type,
    14365       value: removeEscapeSequences(id),
    14366       text: id,
    14367       tokenLength: id.length
    14368     };
    14369   },
    14370 
    14371   /*
    14372    * Extract a numeric literal out of the next sequence of
    14373    * characters or return 'null' if its not possible. This method
    14374    * supports all numeric literals described in section 7.8.3
    14375    * of the EcmaScript 5 specification.
    14376    *
    14377    * This method's implementation was heavily influenced by the
    14378    * scanNumericLiteral function in the Esprima parser's source code.
    14379    */
    14380   scanNumericLiteral: function(checks) {
    14381     var index = 0;
    14382     var value = "";
    14383     var length = this.input.length;
    14384     var char = this.peek(index);
    14385     var bad;
    14386     var isAllowedDigit = isDecimalDigit;
    14387     var base = 10;
    14388     var isLegacy = false;
    14389 
    14390     function isDecimalDigit(str) {
    14391       return (/^[0-9]$/).test(str);
    14392     }
    14393 
    14394     function isOctalDigit(str) {
    14395       return (/^[0-7]$/).test(str);
    14396     }
    14397 
    14398     function isBinaryDigit(str) {
    14399       return (/^[01]$/).test(str);
    14400     }
    14401 
    14402     function isIdentifierStart(ch) {
    14403       return (ch === "$") || (ch === "_") || (ch === "\\") ||
    14404         (ch >= "a" && ch <= "z") || (ch >= "A" && ch <= "Z");
    14405     }
    14406 
    14407     // Numbers must start either with a decimal digit or a point.
    14408 
    14409     if (char !== "." && !isDecimalDigit(char)) {
    14410       return null;
    14411     }
    14412 
    14413     if (char !== ".") {
    14414       value = this.peek(index);
    14415       index += 1;
    14416       char = this.peek(index);
    14417 
    14418       if (value === "0") {
    14419         // Base-16 numbers.
    14420         if (char === "x" || char === "X") {
    14421           isAllowedDigit = isHexDigit;
    14422           base = 16;
    14423 
    14424           index += 1;
    14425           value += char;
    14426         }
    14427 
    14428         // Base-8 numbers.
    14429         if (char === "o" || char === "O") {
    14430           isAllowedDigit = isOctalDigit;
    14431           base = 8;
    14432 
    14433           if (!state.inES6(true)) {
    14434             this.triggerAsync(
    14435               "warning",
    14436               {
    14437                 code: "W119",
    14438                 line: this.line,
    14439                 character: this.char,
    14440                 data: [ "Octal integer literal", "6" ]
    14441               },
    14442               checks,
    14443               function() { return true; }
    14444             );
    14445           }
    14446 
    14447           index += 1;
    14448           value += char;
    14449         }
    14450 
    14451         // Base-2 numbers.
    14452         if (char === "b" || char === "B") {
    14453           isAllowedDigit = isBinaryDigit;
    14454           base = 2;
    14455 
    14456           if (!state.inES6(true)) {
    14457             this.triggerAsync(
    14458               "warning",
    14459               {
    14460                 code: "W119",
    14461                 line: this.line,
    14462                 character: this.char,
    14463                 data: [ "Binary integer literal", "6" ]
    14464               },
    14465               checks,
    14466               function() { return true; }
    14467             );
    14468           }
    14469 
    14470           index += 1;
    14471           value += char;
    14472         }
    14473 
    14474         // Legacy base-8 numbers.
    14475         if (isOctalDigit(char)) {
    14476           isAllowedDigit = isOctalDigit;
    14477           base = 8;
    14478           isLegacy = true;
    14479           bad = false;
    14480 
    14481           index += 1;
    14482           value += char;
    14483         }
    14484 
    14485         // Decimal numbers that start with '0' such as '09' are illegal
    14486         // but we still parse them and return as malformed.
    14487 
    14488         if (!isOctalDigit(char) && isDecimalDigit(char)) {
    14489           index += 1;
    14490           value += char;
    14491         }
    14492       }
    14493 
    14494       while (index < length) {
    14495         char = this.peek(index);
    14496 
    14497         if (isLegacy && isDecimalDigit(char)) {
    14498           // Numbers like '019' (note the 9) are not valid octals
    14499           // but we still parse them and mark as malformed.
    14500           bad = true;
    14501         } else if (!isAllowedDigit(char)) {
    14502           break;
    14503         }
    14504         value += char;
    14505         index += 1;
    14506       }
    14507 
    14508       if (isAllowedDigit !== isDecimalDigit) {
    14509         if (!isLegacy && value.length <= 2) { // 0x
    14510           return {
    14511             type: Token.NumericLiteral,
    14512             value: value,
    14513             isMalformed: true
    14514           };
    14515         }
    14516 
    14517         if (index < length) {
    14518           char = this.peek(index);
    14519           if (isIdentifierStart(char)) {
    14520             return null;
    14521           }
    14522         }
    14523 
    14524         return {
    14525           type: Token.NumericLiteral,
    14526           value: value,
    14527           base: base,
    14528           isLegacy: isLegacy,
    14529           isMalformed: false
    14530         };
    14531       }
    14532     }
    14533 
    14534     // Decimal digits.
    14535 
    14536     if (char === ".") {
    14537       value += char;
    14538       index += 1;
    14539 
    14540       while (index < length) {
    14541         char = this.peek(index);
    14542         if (!isDecimalDigit(char)) {
    14543           break;
    14544         }
    14545         value += char;
    14546         index += 1;
    14547       }
    14548     }
    14549 
    14550     // Exponent part.
    14551 
    14552     if (char === "e" || char === "E") {
    14553       value += char;
    14554       index += 1;
    14555       char = this.peek(index);
    14556 
    14557       if (char === "+" || char === "-") {
    14558         value += this.peek(index);
    14559         index += 1;
    14560       }
    14561 
    14562       char = this.peek(index);
    14563       if (isDecimalDigit(char)) {
    14564         value += char;
    14565         index += 1;
    14566 
    14567         while (index < length) {
    14568           char = this.peek(index);
    14569           if (!isDecimalDigit(char)) {
    14570             break;
    14571           }
    14572           value += char;
    14573           index += 1;
    14574         }
    14575       } else {
    14576         return null;
    14577       }
    14578     }
    14579 
    14580     if (index < length) {
    14581       char = this.peek(index);
    14582       if (isIdentifierStart(char)) {
    14583         return null;
    14584       }
    14585     }
    14586 
    14587     return {
    14588       type: Token.NumericLiteral,
    14589       value: value,
    14590       base: base,
    14591       isMalformed: !isFinite(value)
    14592     };
    14593   },
    14594 
    14595 
    14596   // Assumes previously parsed character was \ (=== '\\') and was not skipped.
    14597   scanEscapeSequence: function(checks) {
    14598     var allowNewLine = false;
    14599     var jump = 1;
    14600     this.skip();
    14601     var char = this.peek();
    14602 
    14603     switch (char) {
    14604     case "'":
    14605       this.triggerAsync("warning", {
    14606         code: "W114",
    14607         line: this.line,
    14608         character: this.char,
    14609         data: [ "\\'" ]
    14610       }, checks, function() {return state.jsonMode; });
    14611       break;
    14612     case "b":
    14613       char = "\\b";
    14614       break;
    14615     case "f":
    14616       char = "\\f";
    14617       break;
    14618     case "n":
    14619       char = "\\n";
    14620       break;
    14621     case "r":
    14622       char = "\\r";
    14623       break;
    14624     case "t":
    14625       char = "\\t";
    14626       break;
    14627     case "0":
    14628       char = "\\0";
    14629 
    14630       // Octal literals fail in strict mode.
    14631       // Check if the number is between 00 and 07.
    14632       var n = parseInt(this.peek(1), 10);
    14633       this.triggerAsync("warning", {
    14634         code: "W115",
    14635         line: this.line,
    14636         character: this.char
    14637       }, checks,
    14638       function() { return n >= 0 && n <= 7 && state.isStrict(); });
    14639       break;
    14640     case "1":
    14641     case "2":
    14642     case "3":
    14643     case "4":
    14644     case "5":
    14645     case "6":
    14646     case "7":
    14647       char = "\\" + char;
    14648       this.triggerAsync("warning", {
    14649         code: "W115",
    14650         line: this.line,
    14651         character: this.char
    14652       }, checks,
    14653       function() { return state.isStrict(); });
    14654       break;
    14655     case "u":
    14656       var sequence = this.input.substr(1, 4);
    14657       var code = parseInt(sequence, 16);
    14658       if (!isHex(sequence)) {
    14659         // This condition unequivocally describes a syntax error.
    14660         // TODO: Re-factor as an "error" (not a "warning").
    14661         this.trigger("warning", {
    14662           code: "W052",
    14663           line: this.line,
    14664           character: this.char,
    14665           data: [ "u" + sequence ]
    14666         });
    14667       }
    14668       char = String.fromCharCode(code);
    14669       jump = 5;
    14670       break;
    14671     case "v":
    14672       this.triggerAsync("warning", {
    14673         code: "W114",
    14674         line: this.line,
    14675         character: this.char,
    14676         data: [ "\\v" ]
    14677       }, checks, function() { return state.jsonMode; });
    14678 
    14679       char = "\v";
    14680       break;
    14681     case "x":
    14682       var  x = parseInt(this.input.substr(1, 2), 16);
    14683 
    14684       this.triggerAsync("warning", {
    14685         code: "W114",
    14686         line: this.line,
    14687         character: this.char,
    14688         data: [ "\\x-" ]
    14689       }, checks, function() { return state.jsonMode; });
    14690 
    14691       char = String.fromCharCode(x);
    14692       jump = 3;
    14693       break;
    14694     case "\\":
    14695       char = "\\\\";
    14696       break;
    14697     case "\"":
    14698       char = "\\\"";
    14699       break;
    14700     case "/":
    14701       break;
    14702     case "":
    14703       allowNewLine = true;
    14704       char = "";
    14705       break;
    14706     }
    14707 
    14708     return { char: char, jump: jump, allowNewLine: allowNewLine };
    14709   },
    14710 
    14711   /*
    14712    * Extract a template literal out of the next sequence of characters
    14713    * and/or lines or return 'null' if its not possible. Since template
    14714    * literals can span across multiple lines, this method has to move
    14715    * the char pointer.
    14716    */
    14717   scanTemplateLiteral: function(checks) {
    14718     var tokenType;
    14719     var value = "";
    14720     var ch;
    14721     var startLine = this.line;
    14722     var startChar = this.char;
    14723     var depth = this.templateStarts.length;
    14724 
    14725     if (this.peek() === "`") {
    14726       if (!state.inES6(true)) {
    14727         this.triggerAsync(
    14728           "warning",
    14729           {
    14730             code: "W119",
    14731             line: this.line,
    14732             character: this.char,
    14733             data: ["template literal syntax", "6"]
    14734           },
    14735           checks,
    14736           function() { return true; }
    14737         );
    14738       }
    14739       // Template must start with a backtick.
    14740       tokenType = Token.TemplateHead;
    14741       this.templateStarts.push({ line: this.line, char: this.char });
    14742       depth = this.templateStarts.length;
    14743       this.skip(1);
    14744       this.pushContext(Context.Template);
    14745     } else if (this.inContext(Context.Template) && this.peek() === "}") {
    14746       // If we're in a template context, and we have a '}', lex a TemplateMiddle.
    14747       tokenType = Token.TemplateMiddle;
    14748     } else {
    14749       // Go lex something else.
    14750       return null;
    14751     }
    14752 
    14753     while (this.peek() !== "`") {
    14754       while ((ch = this.peek()) === "") {
    14755         value += "\n";
    14756         if (!this.nextLine(checks)) {
    14757           // Unclosed template literal --- point to the starting "`"
    14758           var startPos = this.templateStarts.pop();
    14759           this.trigger("error", {
    14760             code: "E052",
    14761             line: startPos.line,
    14762             character: startPos.char
    14763           });
    14764           return {
    14765             type: tokenType,
    14766             value: value,
    14767             startLine: startLine,
    14768             startChar: startChar,
    14769             isUnclosed: true,
    14770             depth: depth,
    14771             context: this.popContext()
    14772           };
    14773         }
    14774       }
    14775 
    14776       if (ch === '$' && this.peek(1) === '{') {
    14777         value += '${';
    14778         this.skip(2);
    14779         return {
    14780           type: tokenType,
    14781           value: value,
    14782           startLine: startLine,
    14783           startChar: startChar,
    14784           isUnclosed: false,
    14785           depth: depth,
    14786           context: this.currentContext()
    14787         };
    14788       } else if (ch === '\\') {
    14789         var escape = this.scanEscapeSequence(checks);
    14790         value += escape.char;
    14791         this.skip(escape.jump);
    14792       } else if (ch !== '`') {
    14793         // Otherwise, append the value and continue.
    14794         value += ch;
    14795         this.skip(1);
    14796       }
    14797     }
    14798 
    14799     // Final value is either NoSubstTemplate or TemplateTail
    14800     tokenType = tokenType === Token.TemplateHead ? Token.NoSubstTemplate : Token.TemplateTail;
    14801     this.skip(1);
    14802     this.templateStarts.pop();
    14803 
    14804     return {
    14805       type: tokenType,
    14806       value: value,
    14807       startLine: startLine,
    14808       startChar: startChar,
    14809       isUnclosed: false,
    14810       depth: depth,
    14811       context: this.popContext()
    14812     };
    14813   },
    14814 
    14815   /*
    14816    * Extract a string out of the next sequence of characters and/or
    14817    * lines or return 'null' if its not possible. Since strings can
    14818    * span across multiple lines this method has to move the char
    14819    * pointer.
    14820    *
    14821    * This method recognizes pseudo-multiline JavaScript strings:
    14822    *
    14823    *   var str = "hello\
    14824    *   world";
    14825    */
    14826   scanStringLiteral: function(checks) {
    14827     /*jshint loopfunc:true */
    14828     var quote = this.peek();
    14829 
    14830     // String must start with a quote.
    14831     if (quote !== "\"" && quote !== "'") {
    14832       return null;
    14833     }
    14834 
    14835     // In JSON strings must always use double quotes.
    14836     this.triggerAsync("warning", {
    14837       code: "W108",
    14838       line: this.line,
    14839       character: this.char // +1?
    14840     }, checks, function() { return state.jsonMode && quote !== "\""; });
    14841 
    14842     var value = "";
    14843     var startLine = this.line;
    14844     var startChar = this.char;
    14845     var allowNewLine = false;
    14846 
    14847     this.skip();
    14848 
    14849     while (this.peek() !== quote) {
    14850       if (this.peek() === "") { // End Of Line
    14851 
    14852         // If an EOL is not preceded by a backslash, show a warning
    14853         // and proceed like it was a legit multi-line string where
    14854         // author simply forgot to escape the newline symbol.
    14855         //
    14856         // Another approach is to implicitly close a string on EOL
    14857         // but it generates too many false positives.
    14858 
    14859         if (!allowNewLine) {
    14860           // This condition unequivocally describes a syntax error.
    14861           // TODO: Re-factor as an "error" (not a "warning").
    14862           this.trigger("warning", {
    14863             code: "W112",
    14864             line: this.line,
    14865             character: this.char
    14866           });
    14867         } else {
    14868           allowNewLine = false;
    14869 
    14870           // Otherwise show a warning if multistr option was not set.
    14871           // For JSON, show warning no matter what.
    14872 
    14873           this.triggerAsync("warning", {
    14874             code: "W043",
    14875             line: this.line,
    14876             character: this.char
    14877           }, checks, function() { return !state.option.multistr; });
    14878 
    14879           this.triggerAsync("warning", {
    14880             code: "W042",
    14881             line: this.line,
    14882             character: this.char
    14883           }, checks, function() { return state.jsonMode && state.option.multistr; });
    14884         }
    14885 
    14886         // If we get an EOF inside of an unclosed string, show an
    14887         // error and implicitly close it at the EOF point.
    14888 
    14889         if (!this.nextLine(checks)) {
    14890           this.trigger("error", {
    14891             code: "E029",
    14892             line: startLine,
    14893             character: startChar
    14894           });
    14895 
    14896           return {
    14897             type: Token.StringLiteral,
    14898             value: value,
    14899             startLine: startLine,
    14900             startChar: startChar,
    14901             isUnclosed: true,
    14902             quote: quote
    14903           };
    14904         }
    14905 
    14906       } else { // Any character other than End Of Line
    14907 
    14908         allowNewLine = false;
    14909         var char = this.peek();
    14910         var jump = 1; // A length of a jump, after we're done
    14911                       // parsing this character.
    14912 
    14913         if (char < " ") {
    14914           // Warn about a control character in a string.
    14915           this.triggerAsync(
    14916             "warning",
    14917             {
    14918               code: "W113",
    14919               line: this.line,
    14920               character: this.char,
    14921               data: [ "<non-printable>" ]
    14922             },
    14923             checks,
    14924             function() { return true; }
    14925           );
    14926         }
    14927 
    14928         // Special treatment for some escaped characters.
    14929         if (char === "\\") {
    14930           var parsed = this.scanEscapeSequence(checks);
    14931           char = parsed.char;
    14932           jump = parsed.jump;
    14933           allowNewLine = parsed.allowNewLine;
    14934         }
    14935 
    14936         value += char;
    14937         this.skip(jump);
    14938       }
    14939     }
    14940 
    14941     this.skip();
    14942     return {
    14943       type: Token.StringLiteral,
    14944       value: value,
    14945       startLine: startLine,
    14946       startChar: startChar,
    14947       isUnclosed: false,
    14948       quote: quote
    14949     };
    14950   },
    14951 
    14952   /*
    14953    * Extract a regular expression out of the next sequence of
    14954    * characters and/or lines or return 'null' if its not possible.
    14955    *
    14956    * This method is platform dependent: it accepts almost any
    14957    * regular expression values but then tries to compile and run
    14958    * them using system's RegExp object. This means that there are
    14959    * rare edge cases where one JavaScript engine complains about
    14960    * your regular expression while others don't.
    14961    */
    14962   scanRegExp: function(checks) {
    14963     var index = 0;
    14964     var length = this.input.length;
    14965     var char = this.peek();
    14966     var value = char;
    14967     var body = "";
    14968     var flags = [];
    14969     var malformed = false;
    14970     var isCharSet = false;
    14971     var terminated, malformedDesc;
    14972 
    14973     var scanUnexpectedChars = function() {
    14974       // Unexpected control character
    14975       if (char < " ") {
    14976         malformed = true;
    14977         this.triggerAsync(
    14978           "warning",
    14979           {
    14980             code: "W048",
    14981             line: this.line,
    14982             character: this.char
    14983           },
    14984           checks,
    14985           function() { return true; }
    14986         );
    14987       }
    14988 
    14989       // Unexpected escaped character
    14990       if (char === "<") {
    14991         malformed = true;
    14992         this.triggerAsync(
    14993           "warning",
    14994           {
    14995             code: "W049",
    14996             line: this.line,
    14997             character: this.char,
    14998             data: [ char ]
    14999           },
    15000           checks,
    15001           function() { return true; }
    15002         );
    15003       }
    15004     }.bind(this);
    15005 
    15006     // Regular expressions must start with '/'
    15007     if (!this.prereg || char !== "/") {
    15008       return null;
    15009     }
    15010 
    15011     index += 1;
    15012     terminated = false;
    15013 
    15014     // Try to get everything in between slashes. A couple of
    15015     // cases aside (see scanUnexpectedChars) we don't really
    15016     // care whether the resulting expression is valid or not.
    15017     // We will check that later using the RegExp object.
    15018 
    15019     while (index < length) {
    15020       char = this.peek(index);
    15021       value += char;
    15022       body += char;
    15023 
    15024       if (isCharSet) {
    15025         if (char === "]") {
    15026           if (this.peek(index - 1) !== "\\" || this.peek(index - 2) === "\\") {
    15027             isCharSet = false;
    15028           }
    15029         }
    15030 
    15031         if (char === "\\") {
    15032           index += 1;
    15033           char = this.peek(index);
    15034           body += char;
    15035           value += char;
    15036 
    15037           scanUnexpectedChars();
    15038         }
    15039 
    15040         index += 1;
    15041         continue;
    15042       }
    15043 
    15044       if (char === "\\") {
    15045         index += 1;
    15046         char = this.peek(index);
    15047         body += char;
    15048         value += char;
    15049 
    15050         scanUnexpectedChars();
    15051 
    15052         if (char === "/") {
    15053           index += 1;
    15054           continue;
    15055         }
    15056 
    15057         if (char === "[") {
    15058           index += 1;
    15059           continue;
    15060         }
    15061       }
    15062 
    15063       if (char === "[") {
    15064         isCharSet = true;
    15065         index += 1;
    15066         continue;
    15067       }
    15068 
    15069       if (char === "/") {
    15070         body = body.substr(0, body.length - 1);
    15071         terminated = true;
    15072         index += 1;
    15073         break;
    15074       }
    15075 
    15076       index += 1;
    15077     }
    15078 
    15079     // A regular expression that was never closed is an
    15080     // error from which we cannot recover.
    15081 
    15082     if (!terminated) {
    15083       this.trigger("error", {
    15084         code: "E015",
    15085         line: this.line,
    15086         character: this.from
    15087       });
    15088 
    15089       return void this.trigger("fatal", {
    15090         line: this.line,
    15091         from: this.from
    15092       });
    15093     }
    15094 
    15095     // Parse flags (if any).
    15096 
    15097     while (index < length) {
    15098       char = this.peek(index);
    15099       if (!/[gimy]/.test(char)) {
    15100         break;
    15101       }
    15102       if (char === "y") {
    15103         if (!state.inES6(true)) {
    15104           this.triggerAsync(
    15105             "warning",
    15106             {
    15107               code: "W119",
    15108               line: this.line,
    15109               character: this.char,
    15110               data: [ "Sticky RegExp flag", "6" ]
    15111             },
    15112             checks,
    15113             function() { return true; }
    15114           );
    15115         }
    15116         if (value.indexOf("y") > -1) {
    15117           malformedDesc = "Duplicate RegExp flag";
    15118         }
    15119       } else {
    15120         flags.push(char);
    15121       }
    15122       value += char;
    15123       index += 1;
    15124     }
    15125 
    15126     // Check regular expression for correctness.
    15127 
    15128     try {
    15129       new RegExp(body, flags.join(""));
    15130     } catch (err) {
    15131       /**
    15132        * Because JSHint relies on the current engine's RegExp parser to
    15133        * validate RegExp literals, the description (exposed as the "data"
    15134        * property on the error object) is platform dependent.
    15135        */
    15136       malformedDesc = err.message;
    15137     }
    15138 
    15139     if (malformedDesc) {
    15140       malformed = true;
    15141       this.trigger("error", {
    15142         code: "E016",
    15143         line: this.line,
    15144         character: this.char,
    15145         data: [ malformedDesc ]
    15146       });
    15147     }
    15148 
    15149     return {
    15150       type: Token.RegExp,
    15151       value: value,
    15152       flags: flags,
    15153       isMalformed: malformed
    15154     };
    15155   },
    15156 
    15157   /*
    15158    * Scan for any occurrence of non-breaking spaces. Non-breaking spaces
    15159    * can be mistakenly typed on OS X with option-space. Non UTF-8 web
    15160    * pages with non-breaking pages produce syntax errors.
    15161    */
    15162   scanNonBreakingSpaces: function() {
    15163     return state.option.nonbsp ?
    15164       this.input.search(/(\u00A0)/) : -1;
    15165   },
    15166 
    15167   /*
    15168    * Scan for characters that get silently deleted by one or more browsers.
    15169    */
    15170   scanUnsafeChars: function() {
    15171     return this.input.search(reg.unsafeChars);
    15172   },
    15173 
    15174   /*
    15175    * Produce the next raw token or return 'null' if no tokens can be matched.
    15176    * This method skips over all space characters.
    15177    */
    15178   next: function(checks) {
    15179     this.from = this.char;
    15180 
    15181     // Move to the next non-space character.
    15182     while (/\s/.test(this.peek())) {
    15183       this.from += 1;
    15184       this.skip();
    15185     }
    15186 
    15187     // Methods that work with multi-line structures and move the
    15188     // character pointer.
    15189 
    15190     var match = this.scanComments(checks) ||
    15191       this.scanStringLiteral(checks) ||
    15192       this.scanTemplateLiteral(checks);
    15193 
    15194     if (match) {
    15195       return match;
    15196     }
    15197 
    15198     // Methods that don't move the character pointer.
    15199 
    15200     match =
    15201       this.scanRegExp(checks) ||
    15202       this.scanPunctuator() ||
    15203       this.scanKeyword() ||
    15204       this.scanIdentifier() ||
    15205       this.scanNumericLiteral(checks);
    15206 
    15207     if (match) {
    15208       this.skip(match.tokenLength || match.value.length);
    15209       return match;
    15210     }
    15211 
    15212     // No token could be matched, give up.
    15213 
    15214     return null;
    15215   },
    15216 
    15217   /*
    15218    * Switch to the next line and reset all char pointers. Once
    15219    * switched, this method also checks for other minor warnings.
    15220    */
    15221   nextLine: function(checks) {
    15222     var char;
    15223 
    15224     if (this.line >= this.getLines().length) {
    15225       return false;
    15226     }
    15227 
    15228     this.input = this.getLines()[this.line];
    15229     this.line += 1;
    15230     this.char = 1;
    15231     this.from = 1;
    15232 
    15233     var inputTrimmed = this.input.trim();
    15234 
    15235     var startsWith = function() {
    15236       return _.some(arguments, function(prefix) {
    15237         return inputTrimmed.indexOf(prefix) === 0;
    15238       });
    15239     };
    15240 
    15241     var endsWith = function() {
    15242       return _.some(arguments, function(suffix) {
    15243         return inputTrimmed.indexOf(suffix, inputTrimmed.length - suffix.length) !== -1;
    15244       });
    15245     };
    15246 
    15247     // If we are ignoring linter errors, replace the input with empty string
    15248     // if it doesn't already at least start or end a multi-line comment
    15249     if (this.ignoringLinterErrors === true) {
    15250       if (!startsWith("/*", "//") && !(this.inComment && endsWith("*/"))) {
    15251         this.input = "";
    15252       }
    15253     }
    15254 
    15255     char = this.scanNonBreakingSpaces();
    15256     if (char >= 0) {
    15257       this.triggerAsync(
    15258         "warning",
    15259         { code: "W125", line: this.line, character: char + 1 },
    15260         checks,
    15261         function() { return true; }
    15262       );
    15263     }
    15264 
    15265     this.input = this.input.replace(/\t/g, state.tab);
    15266     char = this.scanUnsafeChars();
    15267 
    15268     if (char >= 0) {
    15269       this.triggerAsync(
    15270         "warning",
    15271         { code: "W100", line: this.line, character: char },
    15272         checks,
    15273         function() { return true; }
    15274       );
    15275     }
    15276 
    15277     // If there is a limit on line length, warn when lines get too
    15278     // long.
    15279 
    15280     if (!this.ignoringLinterErrors && state.option.maxlen &&
    15281       state.option.maxlen < this.input.length) {
    15282       var inComment = this.inComment ||
    15283         startsWith.call(inputTrimmed, "//") ||
    15284         startsWith.call(inputTrimmed, "/*");
    15285 
    15286       var shouldTriggerError = !inComment || !reg.maxlenException.test(inputTrimmed);
    15287 
    15288       if (shouldTriggerError) {
    15289         this.triggerAsync(
    15290           "warning",
    15291           { code: "W101", line: this.line, character: this.input.length },
    15292           checks,
    15293           function() { return true; }
    15294         );
    15295       }
    15296     }
    15297 
    15298     return true;
    15299   },
    15300 
    15301   /*
    15302    * Produce the next token. This function is called by advance() to get
    15303    * the next token. It returns a token in a JSLint-compatible format.
    15304    */
    15305   token: function() {
    15306     /*jshint loopfunc:true */
    15307     var checks = asyncTrigger();
    15308     var token;
    15309 
    15310 
    15311     function isReserved(token, isProperty) {
    15312       if (!token.reserved) {
    15313         return false;
    15314       }
    15315       var meta = token.meta;
    15316 
    15317       if (meta && meta.isFutureReservedWord && state.inES5()) {
    15318         // ES3 FutureReservedWord in an ES5 environment.
    15319         if (!meta.es5) {
    15320           return false;
    15321         }
    15322 
    15323         // Some ES5 FutureReservedWord identifiers are active only
    15324         // within a strict mode environment.
    15325         if (meta.strictOnly) {
    15326           if (!state.option.strict && !state.isStrict()) {
    15327             return false;
    15328           }
    15329         }
    15330 
    15331         if (isProperty) {
    15332           return false;
    15333         }
    15334       }
    15335 
    15336       return true;
    15337     }
    15338 
    15339     // Produce a token object.
    15340     var create = function(type, value, isProperty, token) {
    15341       /*jshint validthis:true */
    15342       var obj;
    15343 
    15344       if (type !== "(endline)" && type !== "(end)") {
    15345         this.prereg = false;
    15346       }
    15347 
    15348       if (type === "(punctuator)") {
    15349         switch (value) {
    15350         case ".":
    15351         case ")":
    15352         case "~":
    15353         case "#":
    15354         case "]":
    15355         case "++":
    15356         case "--":
    15357           this.prereg = false;
    15358           break;
    15359         default:
    15360           this.prereg = true;
    15361         }
    15362 
    15363         obj = Object.create(state.syntax[value] || state.syntax["(error)"]);
    15364       }
    15365 
    15366       if (type === "(identifier)") {
    15367         if (value === "return" || value === "case" || value === "yield" ||
    15368             value === "typeof" || value === "instanceof") {
    15369           this.prereg = true;
    15370         }
    15371 
    15372         if (_.has(state.syntax, value)) {
    15373           obj = Object.create(state.syntax[value] || state.syntax["(error)"]);
    15374 
    15375           // If this can't be a reserved keyword, reset the object.
    15376           if (!isReserved(obj, isProperty && type === "(identifier)")) {
    15377             obj = null;
    15378           }
    15379         }
    15380       }
    15381 
    15382       if (type === "(template)" || type === "(template middle)") {
    15383         this.prereg = true;
    15384       }
    15385 
    15386       if (!obj) {
    15387         obj = Object.create(state.syntax[type]);
    15388       }
    15389 
    15390       obj.identifier = (type === "(identifier)");
    15391       obj.type = obj.type || type;
    15392       obj.value = value;
    15393       obj.line = this.line;
    15394       obj.character = this.char;
    15395       obj.from = this.from;
    15396       if (obj.identifier && token) obj.raw_text = token.text || token.value;
    15397       if (token && token.startLine && token.startLine !== this.line) {
    15398         obj.startLine = token.startLine;
    15399       }
    15400       if (token && token.context) {
    15401         // Context of current token
    15402         obj.context = token.context;
    15403       }
    15404       if (token && token.depth) {
    15405         // Nested template depth
    15406         obj.depth = token.depth;
    15407       }
    15408       if (token && token.isUnclosed) {
    15409         // Mark token as unclosed string / template literal
    15410         obj.isUnclosed = token.isUnclosed;
    15411       }
    15412 
    15413       if (isProperty && obj.identifier) {
    15414         obj.isProperty = isProperty;
    15415       }
    15416 
    15417       obj.check = checks.check;
    15418 
    15419       return obj;
    15420     }.bind(this);
    15421 
    15422     for (;;) {
    15423       if (!this.input.length) {
    15424         if (this.nextLine(checks)) {
    15425           return create("(endline)", "");
    15426         }
    15427 
    15428         if (this.exhausted) {
    15429           return null;
    15430         }
    15431 
    15432         this.exhausted = true;
    15433         return create("(end)", "");
    15434       }
    15435 
    15436       token = this.next(checks);
    15437 
    15438       if (!token) {
    15439         if (this.input.length) {
    15440           // Unexpected character.
    15441           this.trigger("error", {
    15442             code: "E024",
    15443             line: this.line,
    15444             character: this.char,
    15445             data: [ this.peek() ]
    15446           });
    15447 
    15448           this.input = "";
    15449         }
    15450 
    15451         continue;
    15452       }
    15453 
    15454       switch (token.type) {
    15455       case Token.StringLiteral:
    15456         this.triggerAsync("String", {
    15457           line: this.line,
    15458           char: this.char,
    15459           from: this.from,
    15460           startLine: token.startLine,
    15461           startChar: token.startChar,
    15462           value: token.value,
    15463           quote: token.quote
    15464         }, checks, function() { return true; });
    15465 
    15466         return create("(string)", token.value, null, token);
    15467 
    15468       case Token.TemplateHead:
    15469         this.trigger("TemplateHead", {
    15470           line: this.line,
    15471           char: this.char,
    15472           from: this.from,
    15473           startLine: token.startLine,
    15474           startChar: token.startChar,
    15475           value: token.value
    15476         });
    15477         return create("(template)", token.value, null, token);
    15478 
    15479       case Token.TemplateMiddle:
    15480         this.trigger("TemplateMiddle", {
    15481           line: this.line,
    15482           char: this.char,
    15483           from: this.from,
    15484           startLine: token.startLine,
    15485           startChar: token.startChar,
    15486           value: token.value
    15487         });
    15488         return create("(template middle)", token.value, null, token);
    15489 
    15490       case Token.TemplateTail:
    15491         this.trigger("TemplateTail", {
    15492           line: this.line,
    15493           char: this.char,
    15494           from: this.from,
    15495           startLine: token.startLine,
    15496           startChar: token.startChar,
    15497           value: token.value
    15498         });
    15499         return create("(template tail)", token.value, null, token);
    15500 
    15501       case Token.NoSubstTemplate:
    15502         this.trigger("NoSubstTemplate", {
    15503           line: this.line,
    15504           char: this.char,
    15505           from: this.from,
    15506           startLine: token.startLine,
    15507           startChar: token.startChar,
    15508           value: token.value
    15509         });
    15510         return create("(no subst template)", token.value, null, token);
    15511 
    15512       case Token.Identifier:
    15513         this.triggerAsync("Identifier", {
    15514           line: this.line,
    15515           char: this.char,
    15516           from: this.from,
    15517           name: token.value,
    15518           raw_name: token.text,
    15519           isProperty: state.tokens.curr.id === "."
    15520         }, checks, function() { return true; });
    15521 
    15522         /* falls through */
    15523       case Token.Keyword:
    15524       case Token.NullLiteral:
    15525       case Token.BooleanLiteral:
    15526         return create("(identifier)", token.value, state.tokens.curr.id === ".", token);
    15527 
    15528       case Token.NumericLiteral:
    15529         if (token.isMalformed) {
    15530           // This condition unequivocally describes a syntax error.
    15531           // TODO: Re-factor as an "error" (not a "warning").
    15532           this.trigger("warning", {
    15533             code: "W045",
    15534             line: this.line,
    15535             character: this.char,
    15536             data: [ token.value ]
    15537           });
    15538         }
    15539 
    15540         this.triggerAsync("warning", {
    15541           code: "W114",
    15542           line: this.line,
    15543           character: this.char,
    15544           data: [ "0x-" ]
    15545         }, checks, function() { return token.base === 16 && state.jsonMode; });
    15546 
    15547         this.triggerAsync("warning", {
    15548           code: "W115",
    15549           line: this.line,
    15550           character: this.char
    15551         }, checks, function() {
    15552           return state.isStrict() && token.base === 8 && token.isLegacy;
    15553         });
    15554 
    15555         this.trigger("Number", {
    15556           line: this.line,
    15557           char: this.char,
    15558           from: this.from,
    15559           value: token.value,
    15560           base: token.base,
    15561           isMalformed: token.malformed
    15562         });
    15563 
    15564         return create("(number)", token.value);
    15565 
    15566       case Token.RegExp:
    15567         return create("(regexp)", token.value);
    15568 
    15569       case Token.Comment:
    15570         state.tokens.curr.comment = true;
    15571 
    15572         if (token.isSpecial) {
    15573           return {
    15574             id: '(comment)',
    15575             value: token.value,
    15576             body: token.body,
    15577             type: token.commentType,
    15578             isSpecial: token.isSpecial,
    15579             line: this.line,
    15580             character: this.char,
    15581             from: this.from
    15582           };
    15583         }
    15584 
    15585         break;
    15586 
    15587       case "":
    15588         break;
    15589 
    15590       default:
    15591         return create("(punctuator)", token.value);
    15592       }
    15593     }
    15594   }
    15595 };
    15596 
    15597 exports.Lexer = Lexer;
    15598 exports.Context = Context;
    15599 
    15600 },{"../data/ascii-identifier-data.js":1,"../data/non-ascii-identifier-part-only.js":2,"../data/non-ascii-identifier-start.js":3,"./reg.js":17,"./state.js":19,"events":5,"lodash":12}],14:[function(require,module,exports){
    15601 "use strict";
    15602 
    15603 var _ = require("lodash");
    15604 
    15605 var errors = {
    15606   // JSHint options
    15607   E001: "Bad option: '{a}'.",
    15608   E002: "Bad option value.",
    15609 
    15610   // JSHint input
    15611   E003: "Expected a JSON value.",
    15612   E004: "Input is neither a string nor an array of strings.",
    15613   E005: "Input is empty.",
    15614   E006: "Unexpected early end of program.",
    15615 
    15616   // Strict mode
    15617   E007: "Missing \"use strict\" statement.",
    15618   E008: "Strict violation.",
    15619   E009: "Option 'validthis' can't be used in a global scope.",
    15620   E010: "'with' is not allowed in strict mode.",
    15621 
    15622   // Constants
    15623   E011: "'{a}' has already been declared.",
    15624   E012: "const '{a}' is initialized to 'undefined'.",
    15625   E013: "Attempting to override '{a}' which is a constant.",
    15626 
    15627   // Regular expressions
    15628   E014: "A regular expression literal can be confused with '/='.",
    15629   E015: "Unclosed regular expression.",
    15630   E016: "Invalid regular expression.",
    15631 
    15632   // Tokens
    15633   E017: "Unclosed comment.",
    15634   E018: "Unbegun comment.",
    15635   E019: "Unmatched '{a}'.",
    15636   E020: "Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'.",
    15637   E021: "Expected '{a}' and instead saw '{b}'.",
    15638   E022: "Line breaking error '{a}'.",
    15639   E023: "Missing '{a}'.",
    15640   E024: "Unexpected '{a}'.",
    15641   E025: "Missing ':' on a case clause.",
    15642   E026: "Missing '}' to match '{' from line {a}.",
    15643   E027: "Missing ']' to match '[' from line {a}.",
    15644   E028: "Illegal comma.",
    15645   E029: "Unclosed string.",
    15646 
    15647   // Everything else
    15648   E030: "Expected an identifier and instead saw '{a}'.",
    15649   E031: "Bad assignment.", // FIXME: Rephrase
    15650   E032: "Expected a small integer or 'false' and instead saw '{a}'.",
    15651   E033: "Expected an operator and instead saw '{a}'.",
    15652   E034: "get/set are ES5 features.",
    15653   E035: "Missing property name.",
    15654   E036: "Expected to see a statement and instead saw a block.",
    15655   E037: null,
    15656   E038: null,
    15657   E039: "Function declarations are not invocable. Wrap the whole function invocation in parens.",
    15658   E040: "Each value should have its own case label.",
    15659   E041: "Unrecoverable syntax error.",
    15660   E042: "Stopping.",
    15661   E043: "Too many errors.",
    15662   E044: null,
    15663   E045: "Invalid for each loop.",
    15664   E046: "Yield expressions may only occur within generator functions.",
    15665   E047: null,
    15666   E048: "{a} declaration not directly within block.",
    15667   E049: "A {a} cannot be named '{b}'.",
    15668   E050: "Mozilla requires the yield expression to be parenthesized here.",
    15669   E051: null,
    15670   E052: "Unclosed template literal.",
    15671   E053: "{a} declarations are only allowed at the top level of module scope.",
    15672   E054: "Class properties must be methods. Expected '(' but instead saw '{a}'.",
    15673   E055: "The '{a}' option cannot be set after any executable code.",
    15674   E056: "'{a}' was used before it was declared, which is illegal for '{b}' variables.",
    15675   E057: "Invalid meta property: '{a}.{b}'.",
    15676   E058: "Missing semicolon.",
    15677   E059: "Incompatible values for the '{a}' and '{b}' linting options.",
    15678   E060: "Non-callable values cannot be used as the second operand to instanceof.",
    15679   E061: "Invalid position for 'yield' expression (consider wrapping in parenthesis)."
    15680 };
    15681 
    15682 var warnings = {
    15683   W001: "'hasOwnProperty' is a really bad name.",
    15684   W002: "Value of '{a}' may be overwritten in IE 8 and earlier.",
    15685   W003: "'{a}' was used before it was defined.",
    15686   W004: "'{a}' is already defined.",
    15687   W005: "A dot following a number can be confused with a decimal point.",
    15688   W006: "Confusing minuses.",
    15689   W007: "Confusing plusses.",
    15690   W008: "A leading decimal point can be confused with a dot: '{a}'.",
    15691   W009: "The array literal notation [] is preferable.",
    15692   W010: "The object literal notation {} is preferable.",
    15693   W011: null,
    15694   W012: null,
    15695   W013: null,
    15696   W014: "Misleading line break before '{a}'; readers may interpret this as an expression boundary.",
    15697   W015: null,
    15698   W016: "Unexpected use of '{a}'.",
    15699   W017: "Bad operand.",
    15700   W018: "Confusing use of '{a}'.",
    15701   W019: "Use the isNaN function to compare with NaN.",
    15702   W020: "Read only.",
    15703   W021: "Reassignment of '{a}', which is is a {b}. " +
    15704     "Use 'var' or 'let' to declare bindings that may change.",
    15705   W022: "Do not assign to the exception parameter.",
    15706   W023: "Expected an identifier in an assignment and instead saw a function invocation.",
    15707   W024: "Expected an identifier and instead saw '{a}' (a reserved word).",
    15708   W025: "Missing name in function declaration.",
    15709   W026: "Inner functions should be listed at the top of the outer function.",
    15710   W027: "Unreachable '{a}' after '{b}'.",
    15711   W028: "Label '{a}' on {b} statement.",
    15712   W030: "Expected an assignment or function call and instead saw an expression.",
    15713   W031: "Do not use 'new' for side effects.",
    15714   W032: "Unnecessary semicolon.",
    15715   W033: "Missing semicolon.",
    15716   W034: "Unnecessary directive \"{a}\".",
    15717   W035: "Empty block.",
    15718   W036: "Unexpected /*member '{a}'.",
    15719   W037: "'{a}' is a statement label.",
    15720   W038: "'{a}' used out of scope.",
    15721   W039: "'{a}' is not allowed.",
    15722   W040: "If a strict mode function is executed using function invocation, " +
    15723     "its 'this' value will be undefined.",
    15724   W041: null,
    15725   W042: "Avoid EOL escaping.",
    15726   W043: "Bad escaping of EOL. Use option multistr if needed.",
    15727   W044: "Bad or unnecessary escaping.", /* TODO(caitp): remove W044 */
    15728   W045: "Bad number '{a}'.",
    15729   W046: "Don't use extra leading zeros '{a}'.",
    15730   W047: "A trailing decimal point can be confused with a dot: '{a}'.",
    15731   W048: "Unexpected control character in regular expression.",
    15732   W049: "Unexpected escaped character '{a}' in regular expression.",
    15733   W050: "JavaScript URL.",
    15734   W051: "Variables should not be deleted.",
    15735   W052: "Unexpected '{a}'.",
    15736   W053: "Do not use {a} as a constructor.",
    15737   W054: "The Function constructor is a form of eval.",
    15738   W055: "A constructor name should start with an uppercase letter.",
    15739   W056: "Bad constructor.",
    15740   W057: "Weird construction. Is 'new' necessary?",
    15741   W058: "Missing '()' invoking a constructor.",
    15742   W059: "Avoid arguments.{a}.",
    15743   W060: "document.write can be a form of eval.",
    15744   W061: "eval can be harmful.",
    15745   W062: "Wrap an immediate function invocation in parens " +
    15746     "to assist the reader in understanding that the expression " +
    15747     "is the result of a function, and not the function itself.",
    15748   W063: "Math is not a function.",
    15749   W064: "Missing 'new' prefix when invoking a constructor.",
    15750   W065: "Missing radix parameter.",
    15751   W066: "Implied eval. Consider passing a function instead of a string.",
    15752   W067: "Bad invocation.",
    15753   W068: "Wrapping non-IIFE function literals in parens is unnecessary.",
    15754   W069: "['{a}'] is better written in dot notation.",
    15755   W070: "Extra comma. (it breaks older versions of IE)",
    15756   W071: "This function has too many statements. ({a})",
    15757   W072: "This function has too many parameters. ({a})",
    15758   W073: "Blocks are nested too deeply. ({a})",
    15759   W074: "This function's cyclomatic complexity is too high. ({a})",
    15760   W075: "Duplicate {a} '{b}'.",
    15761   W076: "Unexpected parameter '{a}' in get {b} function.",
    15762   W077: "Expected a single parameter in set {a} function.",
    15763   W078: "Setter is defined without getter.",
    15764   W079: "Redefinition of '{a}'.",
    15765   W080: "It's not necessary to initialize '{a}' to 'undefined'.",
    15766   W081: null,
    15767   W082: "Function declarations should not be placed in blocks. " +
    15768     "Use a function expression or move the statement to the top of " +
    15769     "the outer function.",
    15770   W083: "Functions declared within loops referencing an outer scoped " +
    15771     "variable may lead to confusing semantics.",
    15772   W084: "Expected a conditional expression and instead saw an assignment.",
    15773   W085: "Don't use 'with'.",
    15774   W086: "Expected a 'break' statement before '{a}'.",
    15775   W087: "Forgotten 'debugger' statement?",
    15776   W088: "Creating global 'for' variable. Should be 'for (var {a} ...'.",
    15777   W089: "The body of a for in should be wrapped in an if statement to filter " +
    15778     "unwanted properties from the prototype.",
    15779   W090: "'{a}' is not a statement label.",
    15780   W091: null,
    15781   W093: "Did you mean to return a conditional instead of an assignment?",
    15782   W094: "Unexpected comma.",
    15783   W095: "Expected a string and instead saw {a}.",
    15784   W096: "The '{a}' key may produce unexpected results.",
    15785   W097: "Use the function form of \"use strict\".",
    15786   W098: "'{a}' is defined but never used.",
    15787   W099: null,
    15788   W100: "This character may get silently deleted by one or more browsers.",
    15789   W101: "Line is too long.",
    15790   W102: null,
    15791   W103: "The '{a}' property is deprecated.",
    15792   W104: "'{a}' is available in ES{b} (use 'esversion: {b}') or Mozilla JS extensions (use moz).",
    15793   W105: "Unexpected {a} in '{b}'.",
    15794   W106: "Identifier '{a}' is not in camel case.",
    15795   W107: "Script URL.",
    15796   W108: "Strings must use doublequote.",
    15797   W109: "Strings must use singlequote.",
    15798   W110: "Mixed double and single quotes.",
    15799   W112: "Unclosed string.",
    15800   W113: "Control character in string: {a}.",
    15801   W114: "Avoid {a}.",
    15802   W115: "Octal literals are not allowed in strict mode.",
    15803   W116: "Expected '{a}' and instead saw '{b}'.",
    15804   W117: "'{a}' is not defined.",
    15805   W118: "'{a}' is only available in Mozilla JavaScript extensions (use moz option).",
    15806   W119: "'{a}' is only available in ES{b} (use 'esversion: {b}').",
    15807   W120: "You might be leaking a variable ({a}) here.",
    15808   W121: "Extending prototype of native object: '{a}'.",
    15809   W122: "Invalid typeof value '{a}'",
    15810   W123: "'{a}' is already defined in outer scope.",
    15811   W124: "A generator function should contain at least one yield expression.",
    15812   W125: "This line contains non-breaking spaces: http://jshint.com/docs/options/#nonbsp",
    15813   W126: "Unnecessary grouping operator.",
    15814   W127: "Unexpected use of a comma operator.",
    15815   W128: "Empty array elements require elision=true.",
    15816   W129: "'{a}' is defined in a future version of JavaScript. Use a " +
    15817     "different variable name to avoid migration issues.",
    15818   W130: "Invalid element after rest element.",
    15819   W131: "Invalid parameter after rest parameter.",
    15820   W132: "`var` declarations are forbidden. Use `let` or `const` instead.",
    15821   W133: "Invalid for-{a} loop left-hand-side: {b}.",
    15822   W134: "The '{a}' option is only available when linting ECMAScript {b} code.",
    15823   W135: "{a} may not be supported by non-browser environments.",
    15824   W136: "'{a}' must be in function scope.",
    15825   W137: "Empty destructuring.",
    15826   W138: "Regular parameters should not come after default parameters.",
    15827   W139: "Function expressions should not be used as the second operand to instanceof.",
    15828   W140: "Missing comma."
    15829 };
    15830 
    15831 var info = {
    15832   I001: "Comma warnings can be turned off with 'laxcomma'.",
    15833   I002: null,
    15834   I003: "ES5 option is now set per default"
    15835 };
    15836 
    15837 exports.errors = {};
    15838 exports.warnings = {};
    15839 exports.info = {};
    15840 
    15841 _.each(errors, function(desc, code) {
    15842   exports.errors[code] = { code: code, desc: desc };
    15843 });
    15844 
    15845 _.each(warnings, function(desc, code) {
    15846   exports.warnings[code] = { code: code, desc: desc };
    15847 });
    15848 
    15849 _.each(info, function(desc, code) {
    15850   exports.info[code] = { code: code, desc: desc };
    15851 });
    15852 
    15853 },{"lodash":12}],15:[function(require,module,exports){
    15854 "use strict";
    15855 
    15856 function NameStack() {
    15857   this._stack = [];
    15858 }
    15859 
    15860 Object.defineProperty(NameStack.prototype, "length", {
    15861   get: function() {
    15862     return this._stack.length;
    15863   }
    15864 });
    15865 
    15866 /**
    15867  * Create a new entry in the stack. Useful for tracking names across
    15868  * expressions.
    15869  */
    15870 NameStack.prototype.push = function() {
    15871   this._stack.push(null);
    15872 };
    15873 
    15874 /**
    15875  * Discard the most recently-created name on the stack.
    15876  */
    15877 NameStack.prototype.pop = function() {
    15878   this._stack.pop();
    15879 };
    15880 
    15881 /**
    15882  * Update the most recent name on the top of the stack.
    15883  *
    15884  * @param {object} token The token to consider as the source for the most
    15885  *                       recent name.
    15886  */
    15887 NameStack.prototype.set = function(token) {
    15888   this._stack[this.length - 1] = token;
    15889 };
    15890 
    15891 /**
    15892  * Generate a string representation of the most recent name.
    15893  *
    15894  * @returns {string}
    15895  */
    15896 NameStack.prototype.infer = function() {
    15897   var nameToken = this._stack[this.length - 1];
    15898   var prefix = "";
    15899   var type;
    15900 
    15901   // During expected operation, the topmost entry on the stack will only
    15902   // reflect the current function's name when the function is declared without
    15903   // the `function` keyword (i.e. for in-line accessor methods). In other
    15904   // cases, the `function` expression itself will introduce an empty entry on
    15905   // the top of the stack, and this should be ignored.
    15906   if (!nameToken || nameToken.type === "class") {
    15907     nameToken = this._stack[this.length - 2];
    15908   }
    15909 
    15910   if (!nameToken) {
    15911     return "(empty)";
    15912   }
    15913 
    15914   type = nameToken.type;
    15915 
    15916   if (type !== "(string)" && type !== "(number)" && type !== "(identifier)" && type !== "default") {
    15917     return "(expression)";
    15918   }
    15919 
    15920   if (nameToken.accessorType) {
    15921     prefix = nameToken.accessorType + " ";
    15922   }
    15923 
    15924   return prefix + nameToken.value;
    15925 };
    15926 
    15927 module.exports = NameStack;
    15928 
    15929 },{}],16:[function(require,module,exports){
    15930 "use strict";
    15931 
    15932 // These are the JSHint boolean options.
    15933 exports.bool = {
    15934   enforcing: {
    15935 
    15936     /**
    15937      * This option prohibits the use of bitwise operators such as `^` (XOR),
    15938      * `|` (OR) and others. Bitwise operators are very rare in JavaScript
    15939      * programs and quite often `&` is simply a mistyped `&&`.
    15940      */
    15941     bitwise     : true,
    15942 
    15943     /**
    15944      *
    15945      * This options prohibits overwriting prototypes of native objects such as
    15946      * `Array`, `Date` and so on.
    15947      *
    15948      *     // jshint freeze:true
    15949      *     Array.prototype.count = function (value) { return 4; };
    15950      *     // -> Warning: Extending prototype of native object: 'Array'.
    15951      */
    15952     freeze      : true,
    15953 
    15954     /**
    15955      * This option allows you to force all variable names to use either
    15956      * camelCase style or UPPER_CASE with underscores.
    15957      *
    15958      * @deprecated JSHint is limiting its scope to issues of code correctness.
    15959      *             If you would like to enforce rules relating to code style,
    15960      *             check out [the JSCS
    15961      *             project](https://github.com/jscs-dev/node-jscs).
    15962      */
    15963     camelcase   : true,
    15964 
    15965     /**
    15966      * This option requires you to always put curly braces around blocks in
    15967      * loops and conditionals. JavaScript allows you to omit curly braces when
    15968      * the block consists of only one statement, for example:
    15969      *
    15970      *     while (day)
    15971      *       shuffle();
    15972      *
    15973      * However, in some circumstances, it can lead to bugs (you'd think that
    15974      * `sleep()` is a part of the loop while in reality it is not):
    15975      *
    15976      *     while (day)
    15977      *       shuffle();
    15978      *       sleep();
    15979      */
    15980     curly       : true,
    15981 
    15982     /**
    15983      * This options prohibits the use of `==` and `!=` in favor of `===` and
    15984      * `!==`. The former try to coerce values before comparing them which can
    15985      * lead to some unexpected results. The latter don't do any coercion so
    15986      * they are generally safer. If you would like to learn more about type
    15987      * coercion in JavaScript, we recommend [Truth, Equality and
    15988      * JavaScript](http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/)
    15989      * by Angus Croll.
    15990      */
    15991     eqeqeq      : true,
    15992 
    15993     /**
    15994      * This option enables warnings about the use of identifiers which are
    15995      * defined in future versions of JavaScript. Although overwriting them has
    15996      * no effect in contexts where they are not implemented, this practice can
    15997      * cause issues when migrating codebases to newer versions of the language.
    15998      */
    15999     futurehostile: true,
    16000 
    16001     /**
    16002      * This option tells JSHint that your code needs to adhere to ECMAScript 3
    16003      * specification. Use this option if you need your program to be executable
    16004      * in older browsers—such as Internet Explorer 6/7/8/9—and other legacy
    16005      * JavaScript environments.
    16006      *
    16007      * @deprecated Use `esversion: 3` instead.
    16008      */
    16009     es3         : true,
    16010 
    16011     /**
    16012      * This option enables syntax first defined in [the ECMAScript 5.1
    16013      * specification](http://es5.github.io/). This includes allowing reserved
    16014      * keywords as object properties.
    16015      *
    16016      * @deprecated Use `esversion: 5` instead.
    16017      */
    16018     es5         : true,
    16019 
    16020     /**
    16021      * This option requires all `for in` loops to filter object's items. The
    16022      * for in statement allows for looping through the names of all of the
    16023      * properties of an object including those inherited through the prototype
    16024      * chain. This behavior can lead to unexpected items in your object so it
    16025      * is generally safer to always filter inherited properties out as shown in
    16026      * the example:
    16027      *
    16028      *     for (key in obj) {
    16029      *       if (obj.hasOwnProperty(key)) {
    16030      *         // We are sure that obj[key] belongs to the object and was not inherited.
    16031      *       }
    16032      *     }
    16033      *
    16034      * For more in-depth understanding of `for in` loops in JavaScript, read
    16035      * [Exploring JavaScript for-in
    16036      * loops](http://javascriptweblog.wordpress.com/2011/01/04/exploring-javascript-for-in-loops/)
    16037      * by Angus Croll.
    16038      */
    16039     forin       : true,
    16040 
    16041     /**
    16042      * This option prohibits the use of immediate function invocations without
    16043      * wrapping them in parentheses. Wrapping parentheses assists readers of
    16044      * your code in understanding that the expression is the result of a
    16045      * function, and not the function itself.
    16046      *
    16047      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16048      *             If you would like to enforce rules relating to code style,
    16049      *             check out [the JSCS
    16050      *             project](https://github.com/jscs-dev/node-jscs).
    16051      */
    16052     immed       : true,
    16053 
    16054     /**
    16055      * This option requires you to capitalize names of constructor functions.
    16056      * Capitalizing functions that are intended to be used with `new` operator
    16057      * is just a convention that helps programmers to visually distinguish
    16058      * constructor functions from other types of functions to help spot
    16059      * mistakes when using `this`.
    16060      *
    16061      * Not doing so won't break your code in any browsers or environments but
    16062      * it will be a bit harder to figure out—by reading the code—if the
    16063      * function was supposed to be used with or without new. And this is
    16064      * important because when the function that was intended to be used with
    16065      * `new` is used without it, `this` will point to the global object instead
    16066      * of a new object.
    16067      *
    16068      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16069      *             If you would like to enforce rules relating to code style,
    16070      *             check out [the JSCS
    16071      *             project](https://github.com/jscs-dev/node-jscs).
    16072      */
    16073     newcap      : true,
    16074 
    16075     /**
    16076      * This option prohibits the use of `arguments.caller` and
    16077      * `arguments.callee`.  Both `.caller` and `.callee` make quite a few
    16078      * optimizations impossible so they were deprecated in future versions of
    16079      * JavaScript. In fact, ECMAScript 5 forbids the use of `arguments.callee`
    16080      * in strict mode.
    16081      */
    16082     noarg       : true,
    16083 
    16084     /**
    16085      * This option prohibits the use of the comma operator. When misused, the
    16086      * comma operator can obscure the value of a statement and promote
    16087      * incorrect code.
    16088      */
    16089     nocomma     : true,
    16090 
    16091     /**
    16092      * This option warns when you have an empty block in your code. JSLint was
    16093      * originally warning for all empty blocks and we simply made it optional.
    16094      * There were no studies reporting that empty blocks in JavaScript break
    16095      * your code in any way.
    16096      *
    16097      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16098      *             If you would like to enforce rules relating to code style,
    16099      *             check out [the JSCS
    16100      *             project](https://github.com/jscs-dev/node-jscs).
    16101      */
    16102     noempty     : true,
    16103 
    16104     /**
    16105      * This option warns about "non-breaking whitespace" characters. These
    16106      * characters can be entered with option-space on Mac computers and have a
    16107      * potential of breaking non-UTF8 web pages.
    16108      */
    16109     nonbsp      : true,
    16110 
    16111     /**
    16112      * This option prohibits the use of constructor functions for side-effects.
    16113      * Some people like to call constructor functions without assigning its
    16114      * result to any variable:
    16115      *
    16116      *     new MyConstructor();
    16117      *
    16118      * There is no advantage in this approach over simply calling
    16119      * `MyConstructor` since the object that the operator `new` creates isn't
    16120      * used anywhere so you should generally avoid constructors like this one.
    16121      */
    16122     nonew       : true,
    16123 
    16124     /**
    16125      * This option prohibits the use of explicitly undeclared variables. This
    16126      * option is very useful for spotting leaking and mistyped variables.
    16127      *
    16128      *     // jshint undef:true
    16129      *
    16130      *     function test() {
    16131      *       var myVar = 'Hello, World';
    16132      *       console.log(myvar); // Oops, typoed here. JSHint with undef will complain
    16133      *     }
    16134      *
    16135      * If your variable is defined in another file, you can use the `global`
    16136      * directive to tell JSHint about it.
    16137      */
    16138     undef       : true,
    16139 
    16140     /**
    16141      * This option prohibits the use of the grouping operator when it is not
    16142      * strictly required. Such usage commonly reflects a misunderstanding of
    16143      * unary operators, for example:
    16144      *
    16145      *     // jshint singleGroups: true
    16146      *
    16147      *     delete(obj.attr); // Warning: Unnecessary grouping operator.
    16148      */
    16149     singleGroups: false,
    16150 
    16151     /**
    16152      * When set to true, the use of VariableStatements are forbidden.
    16153      * For example:
    16154      *
    16155      *     // jshint varstmt: true
    16156      *
    16157      *     var a; // Warning: `var` declarations are forbidden. Use `let` or `const` instead.
    16158      */
    16159     varstmt: false,
    16160 
    16161     /**
    16162      * This option is a short hand for the most strict JSHint configuration as
    16163      * available in JSHint version 2.6.3. It enables all enforcing options and
    16164      * disables all relaxing options that were defined in that release.
    16165      *
    16166      * @deprecated The option cannot be maintained without automatically opting
    16167      *             users in to new features. This can lead to unexpected
    16168      *             warnings/errors in when upgrading between minor versions of
    16169      *             JSHint.
    16170      */
    16171     enforceall : false,
    16172 
    16173     /**
    16174      * This option warns when a comma is not placed after the last element in an
    16175      * array or object literal. Due to bugs in old versions of IE, trailing
    16176      * commas used to be discouraged, but since ES5 their semantics were
    16177      * standardized. (See
    16178      * [#11.1.4](http://www.ecma-international.org/ecma-262/5.1/#sec-11.1.4) and
    16179      * [#11.1.5](http://www.ecma-international.org/ecma-262/5.1/#sec-11.1.5).)
    16180      * Now, they help to prevent the same [visual
    16181      * ambiguities](http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.2)
    16182      * that the strict usage of semicolons helps prevent.
    16183      *
    16184      * For example, this code might have worked last Tuesday:
    16185      *
    16186      *     [
    16187      *         b + c
    16188      *     ].forEach(print);
    16189      *
    16190      * But if one adds an element to the array and forgets to compensate for the
    16191      * missing comma, no syntax error is thrown, and a linter cannot determine
    16192      * if this was a mistake or an intentional function invocation.
    16193      *
    16194      *     [
    16195      *         b + c
    16196      *         (d + e)
    16197      *     ].forEach(print);
    16198      *
    16199      * If one always appends a list item with a comma, this ambiguity cannot
    16200      * occur:
    16201      *
    16202      *     [
    16203      *         b + c,
    16204      *     ].forEach(print);
    16205      *
    16206      *     [
    16207      *         b + c,
    16208      *         (d + e),
    16209      *     ].forEach(print);
    16210      */
    16211     trailingcomma: false
    16212   },
    16213   relaxing: {
    16214 
    16215     /**
    16216      * This option suppresses warnings about missing semicolons. There is a lot
    16217      * of FUD about semicolon spread by quite a few people in the community.
    16218      * The common myths are that semicolons are required all the time (they are
    16219      * not) and that they are unreliable. JavaScript has rules about semicolons
    16220      * which are followed by *all* browsers so it is up to you to decide
    16221      * whether you should or should not use semicolons in your code.
    16222      *
    16223      * For more information about semicolons in JavaScript read [An Open Letter
    16224      * to JavaScript Leaders Regarding
    16225      * Semicolons](http://blog.izs.me/post/2353458699/an-open-letter-to-javascript-leaders-regarding)
    16226      * by Isaac Schlueter and [JavaScript Semicolon
    16227      * Insertion](http://inimino.org/~inimino/blog/javascript_semicolons).
    16228      */
    16229     asi         : true,
    16230 
    16231     /**
    16232      * This option suppresses warnings about multi-line strings. Multi-line
    16233      * strings can be dangerous in JavaScript because all hell breaks loose if
    16234      * you accidentally put a whitespace in between the escape character (`\`)
    16235      * and a new line.
    16236      *
    16237      * Note that even though this option allows correct multi-line strings, it
    16238      * still warns about multi-line strings without escape characters or with
    16239      * anything in between the escape character and a whitespace.
    16240      *
    16241      *     // jshint multistr:true
    16242      *
    16243      *     var text = "Hello\
    16244      *     World"; // All good.
    16245      *
    16246      *     text = "Hello
    16247      *     World"; // Warning, no escape character.
    16248      *
    16249      *     text = "Hello\
    16250      *     World"; // Warning, there is a space after \
    16251      *
    16252      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16253      *             If you would like to enforce rules relating to code style,
    16254      *             check out [the JSCS
    16255      *             project](https://github.com/jscs-dev/node-jscs).
    16256      */
    16257     multistr    : true,
    16258 
    16259     /**
    16260      * This option suppresses warnings about the `debugger` statements in your
    16261      * code.
    16262      */
    16263     debug       : true,
    16264 
    16265     /**
    16266      * This option suppresses warnings about the use of assignments in cases
    16267      * where comparisons are expected. More often than not, code like `if (a =
    16268      * 10) {}` is a typo. However, it can be useful in cases like this one:
    16269      *
    16270      *     for (var i = 0, person; person = people[i]; i++) {}
    16271      *
    16272      * You can silence this error on a per-use basis by surrounding the assignment
    16273      * with parenthesis, such as:
    16274      *
    16275      *     for (var i = 0, person; (person = people[i]); i++) {}
    16276      */
    16277     boss        : true,
    16278 
    16279     /**
    16280      * This option suppresses warnings about the use of `eval`. The use of
    16281      * `eval` is discouraged because it can make your code vulnerable to
    16282      * various injection attacks and it makes it hard for JavaScript
    16283      * interpreter to do certain optimizations.
    16284     */
    16285     evil        : true,
    16286 
    16287     /**
    16288      * This option suppresses warnings about declaring variables inside of
    16289      * control
    16290      * structures while accessing them later from the outside. Even though
    16291      * JavaScript has only two real scopes—global and function—such practice
    16292      * leads to confusion among people new to the language and hard-to-debug
    16293      * bugs. This is why, by default, JSHint warns about variables that are
    16294      * used outside of their intended scope.
    16295      *
    16296      *     function test() {
    16297      *       if (true) {
    16298      *         var x = 0;
    16299      *       }
    16300      *
    16301      *       x += 1; // Default: 'x' used out of scope.
    16302      *                 // No warning when funcscope:true
    16303      *     }
    16304      */
    16305     funcscope   : true,
    16306 
    16307     /**
    16308      * This option suppresses warnings about the use of global strict mode.
    16309      * Global strict mode can break third-party widgets so it is not
    16310      * recommended.
    16311      *
    16312      * For more info about strict mode see the `strict` option.
    16313      *
    16314      * @deprecated Use `strict: "global"`.
    16315      */
    16316     globalstrict: true,
    16317 
    16318     /**
    16319      * This option suppresses warnings about the `__iterator__` property. This
    16320      * property is not supported by all browsers so use it carefully.
    16321      */
    16322     iterator    : true,
    16323 
    16324      /**
    16325      * This option suppresses warnings about invalid `typeof` operator values.
    16326      * This operator has only [a limited set of possible return
    16327      * values](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof).
    16328      * By default, JSHint warns when you compare its result with an invalid
    16329      * value which often can be a typo.
    16330      *
    16331      *     // 'fuction' instead of 'function'
    16332      *     if (typeof a == "fuction") { // Invalid typeof value 'fuction'
    16333      *       // ...
    16334      *     }
    16335      *
    16336      * Do not use this option unless you're absolutely sure you don't want
    16337      * these checks.
    16338      */
    16339     notypeof    : true,
    16340 
    16341     /**
    16342      * This option prohibits the use of unary increment and decrement
    16343      * operators.  Some people think that `++` and `--` reduces the quality of
    16344      * their coding styles and there are programming languages—such as
    16345      * Python—that go completely without these operators.
    16346      */
    16347     plusplus    : true,
    16348 
    16349     /**
    16350      * This option suppresses warnings about the `__proto__` property.
    16351      */
    16352     proto       : true,
    16353 
    16354     /**
    16355      * This option suppresses warnings about the use of script-targeted
    16356      * URLs—such as `javascript:...`.
    16357      */
    16358     scripturl   : true,
    16359 
    16360     /**
    16361      * This option suppresses warnings about using `[]` notation when it can be
    16362      * expressed in dot notation: `person['name']` vs. `person.name`.
    16363      *
    16364      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16365      *             If you would like to enforce rules relating to code style,
    16366      *             check out [the JSCS
    16367      *             project](https://github.com/jscs-dev/node-jscs).
    16368      */
    16369     sub         : true,
    16370 
    16371     /**
    16372      * This option suppresses warnings about "weird" constructions like
    16373      * `new function () { ... }` and `new Object;`. Such constructions are
    16374      * sometimes used to produce singletons in JavaScript:
    16375      *
    16376      *     var singleton = new function() {
    16377      *       var privateVar;
    16378      *
    16379      *       this.publicMethod  = function () {}
    16380      *       this.publicMethod2 = function () {}
    16381      *     };
    16382      */
    16383     supernew    : true,
    16384 
    16385     /**
    16386      * This option suppresses most of the warnings about possibly unsafe line
    16387      * breakings in your code. It doesn't suppress warnings about comma-first
    16388      * coding style. To suppress those you have to use `laxcomma` (see below).
    16389      *
    16390      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16391      *             If you would like to enforce rules relating to code style,
    16392      *             check out [the JSCS
    16393      *             project](https://github.com/jscs-dev/node-jscs).
    16394      */
    16395     laxbreak    : true,
    16396 
    16397     /**
    16398      * This option suppresses warnings about comma-first coding style:
    16399      *
    16400      *     var obj = {
    16401      *         name: 'Anton'
    16402      *       , handle: 'valueof'
    16403      *       , role: 'SW Engineer'
    16404      *     };
    16405      *
    16406      * @deprecated JSHint is limiting its scope to issues of code correctness.
    16407      *             If you would like to enforce rules relating to code style,
    16408      *             check out [the JSCS
    16409      *             project](https://github.com/jscs-dev/node-jscs).
    16410      */
    16411     laxcomma    : true,
    16412 
    16413     /**
    16414      * This option suppresses warnings about possible strict violations when
    16415      * the code is running in strict mode and you use `this` in a
    16416      * non-constructor function. You should use this option—in a function scope
    16417      * only—when you are positive that your use of `this` is valid in the
    16418      * strict mode (for example, if you call your function using
    16419      * `Function.call`).
    16420      *
    16421      * **Note:** This option can be used only inside of a function scope.
    16422      * JSHint will fail with an error if you will try to set this option
    16423      * globally.
    16424      */
    16425     validthis   : true,
    16426 
    16427     /**
    16428      * This option suppresses warnings about the use of the `with` statement.
    16429      * The semantics of the `with` statement can cause confusion among
    16430      * developers and accidental definition of global variables.
    16431      *
    16432      * More info:
    16433      *
    16434      * * [with Statement Considered
    16435      *   Harmful](http://yuiblog.com/blog/2006/04/11/with-statement-considered-harmful/)
    16436      */
    16437     withstmt    : true,
    16438 
    16439     /**
    16440      * This options tells JSHint that your code uses Mozilla JavaScript
    16441      * extensions. Unless you develop specifically for the Firefox web browser
    16442      * you don't need this option.
    16443      *
    16444      * More info:
    16445      *
    16446      * * [New in JavaScript
    16447      *   1.7](https://developer.mozilla.org/en-US/docs/JavaScript/New_in_JavaScript/1.7)
    16448      */
    16449     moz         : true,
    16450 
    16451     /**
    16452      * This option suppresses warnings about generator functions with no
    16453      * `yield` statement in them.
    16454      */
    16455     noyield     : true,
    16456 
    16457     /**
    16458      * This option suppresses warnings about `== null` comparisons. Such
    16459      * comparisons are often useful when you want to check if a variable is
    16460      * `null` or `undefined`.
    16461      */
    16462     eqnull      : true,
    16463 
    16464     /**
    16465      * This option suppresses warnings about missing semicolons, but only when
    16466      * the semicolon is omitted for the last statement in a one-line block:
    16467      *
    16468      *     var name = (function() { return 'Anton' }());
    16469      *
    16470      * This is a very niche use case that is useful only when you use automatic
    16471      * JavaScript code generators.
    16472      */
    16473     lastsemic   : true,
    16474 
    16475     /**
    16476      * This option suppresses warnings about functions inside of loops.
    16477      * Defining functions inside of loops can lead to bugs such as this one:
    16478      *
    16479      *     var nums = [];
    16480      *
    16481      *     for (var i = 0; i < 10; i++) {
    16482      *       nums[i] = function (j) {
    16483      *         return i + j;
    16484      *       };
    16485      *     }
    16486      *
    16487      *     nums[0](2); // Prints 12 instead of 2
    16488      *
    16489      * To fix the code above you need to copy the value of `i`:
    16490      *
    16491      *     var nums = [];
    16492      *
    16493      *     for (var i = 0; i < 10; i++) {
    16494      *       (function (i) {
    16495      *         nums[i] = function (j) {
    16496      *             return i + j;
    16497      *         };
    16498      *       }(i));
    16499      *     }
    16500      */
    16501     loopfunc    : true,
    16502 
    16503     /**
    16504      * This option suppresses warnings about the use of expressions where
    16505      * normally you would expect to see assignments or function calls. Most of
    16506      * the time, such code is a typo. However, it is not forbidden by the spec
    16507      * and that's why this warning is optional.
    16508      */
    16509     expr        : true,
    16510 
    16511     /**
    16512      * This option tells JSHint that your code uses ECMAScript 6 specific
    16513      * syntax. Note that not all browsers implement these features.
    16514      *
    16515      * More info:
    16516      *
    16517      * * [Specification for ECMAScript
    16518      *   6](http://www.ecma-international.org/ecma-262/6.0/index.html)
    16519      *
    16520      * @deprecated Use `esversion: 6` instead.
    16521      */
    16522     esnext      : true,
    16523 
    16524     /**
    16525      * This option tells JSHint that your code uses ES3 array elision elements,
    16526      * or empty elements (for example, `[1, , , 4, , , 7]`).
    16527      */
    16528     elision     : true,
    16529   },
    16530 
    16531   // Third party globals
    16532   environments: {
    16533 
    16534     /**
    16535      * This option defines globals exposed by the
    16536      * [MooTools](http://mootools.net/) JavaScript framework.
    16537      */
    16538     mootools    : true,
    16539 
    16540     /**
    16541      * This option defines globals exposed by
    16542      * [CouchDB](http://couchdb.apache.org/). CouchDB is a document-oriented
    16543      * database that can be queried and indexed in a MapReduce fashion using
    16544      * JavaScript.
    16545      */
    16546     couch       : true,
    16547 
    16548     /**
    16549      * This option defines globals exposed by [the Jasmine unit testing
    16550      * framework](https://jasmine.github.io/).
    16551      */
    16552     jasmine     : true,
    16553 
    16554     /**
    16555      * This option defines globals exposed by the [jQuery](http://jquery.com/)
    16556      * JavaScript library.
    16557      */
    16558     jquery      : true,
    16559 
    16560     /**
    16561      * This option defines globals available when your code is running inside
    16562      * of the Node runtime environment. [Node.js](http://nodejs.org/) is a
    16563      * server-side JavaScript environment that uses an asynchronous
    16564      * event-driven model. This option also skips some warnings that make sense
    16565      * in the browser environments but don't make sense in Node such as
    16566      * file-level `use strict` pragmas and `console.log` statements.
    16567      */
    16568     node        : true,
    16569 
    16570     /**
    16571      * This option defines globals exposed by [the QUnit unit testing
    16572      * framework](http://qunitjs.com/).
    16573      */
    16574     qunit       : true,
    16575 
    16576     /**
    16577      * This option defines globals available when your code is running inside
    16578      * of the Rhino runtime environment. [Rhino](http://www.mozilla.org/rhino/)
    16579      * is an open-source implementation of JavaScript written entirely in Java.
    16580      */
    16581     rhino       : true,
    16582 
    16583     /**
    16584      * This option defines globals exposed by [the ShellJS
    16585      * library](http://documentup.com/arturadib/shelljs).
    16586      */
    16587     shelljs     : true,
    16588 
    16589     /**
    16590      * This option defines globals exposed by the
    16591      * [Prototype](http://www.prototypejs.org/) JavaScript framework.
    16592      */
    16593     prototypejs : true,
    16594 
    16595     /**
    16596      * This option defines globals exposed by the [YUI](http://yuilibrary.com/)
    16597      * JavaScript framework.
    16598      */
    16599     yui         : true,
    16600 
    16601     /**
    16602      * This option defines globals exposed by the "BDD" and "TDD" UIs of the
    16603      * [Mocha unit testing framework](http://mochajs.org/).
    16604      */
    16605     mocha       : true,
    16606 
    16607     /**
    16608      * This option informs JSHint that the input code describes an ECMAScript 6
    16609      * module. All module code is interpreted as strict mode code.
    16610      */
    16611     module      : true,
    16612 
    16613     /**
    16614      * This option defines globals available when your code is running as a
    16615      * script for the [Windows Script
    16616      * Host](http://en.wikipedia.org/wiki/Windows_Script_Host).
    16617      */
    16618     wsh         : true,
    16619 
    16620     /**
    16621      * This option defines globals available when your code is running inside
    16622      * of a Web Worker. [Web
    16623      * Workers](https://developer.mozilla.org/en/Using_web_workers) provide a
    16624      * simple means for web content to run scripts in background threads.
    16625      */
    16626     worker      : true,
    16627 
    16628     /**
    16629      * This option defines non-standard but widely adopted globals such as
    16630      * `escape` and `unescape`.
    16631      */
    16632     nonstandard : true,
    16633 
    16634     /**
    16635      * This option defines globals exposed by modern browsers: all the way from
    16636      * good old `document` and `navigator` to the HTML5 `FileReader` and other
    16637      * new developments in the browser world.
    16638      *
    16639      * **Note:** This option doesn't expose variables like `alert` or
    16640      * `console`. See option `devel` for more information.
    16641      */
    16642     browser     : true,
    16643 
    16644     /**
    16645      * This option defines globals available when using [the Browserify
    16646      * tool](http://browserify.org/) to build a project.
    16647      */
    16648     browserify  : true,
    16649 
    16650     /**
    16651      * This option defines globals that are usually used for logging poor-man's
    16652      * debugging: `console`, `alert`, etc. It is usually a good idea to not
    16653      * ship them in production because, for example, `console.log` breaks in
    16654      * legacy versions of Internet Explorer.
    16655      */
    16656     devel       : true,
    16657 
    16658     /**
    16659      * This option defines globals exposed by the [Dojo
    16660      * Toolkit](http://dojotoolkit.org/).
    16661      */
    16662     dojo        : true,
    16663 
    16664     /**
    16665      * This option defines globals for typed array constructors.
    16666      *
    16667      * More info:
    16668      *
    16669      * * [JavaScript typed
    16670      *   arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays)
    16671      */
    16672     typed       : true,
    16673 
    16674     /**
    16675      * This option defines globals available when your core is running inside
    16676      * of the PhantomJS runtime environment. [PhantomJS](http://phantomjs.org/)
    16677      * is a headless WebKit scriptable with a JavaScript API. It has fast and
    16678      * native support for various web standards: DOM handling, CSS selector,
    16679      * JSON, Canvas, and SVG.
    16680      */
    16681     phantom     : true
    16682   },
    16683 
    16684   // Obsolete options
    16685   obsolete: {
    16686     onecase     : true, // if one case switch statements should be allowed
    16687     regexp      : true, // if the . should not be allowed in regexp literals
    16688     regexdash   : true  // if unescaped first/last dash (-) inside brackets
    16689                         // should be tolerated
    16690   }
    16691 };
    16692 
    16693 // These are the JSHint options that can take any value
    16694 // (we use this object to detect invalid options)
    16695 exports.val = {
    16696 
    16697   /**
    16698    * This option lets you set the maximum length of a line.
    16699    *
    16700    * @deprecated JSHint is limiting its scope to issues of code correctness. If
    16701    *             you would like to enforce rules relating to code style, check
    16702    *             out [the JSCS project](https://github.com/jscs-dev/node-jscs).
    16703    */
    16704   maxlen       : false,
    16705 
    16706   /**
    16707    * This option sets a specific tab width for your code.
    16708    *
    16709    * @deprecated JSHint is limiting its scope to issues of code correctness. If
    16710    *             you would like to enforce rules relating to code style, check
    16711    *             out [the JSCS project](https://github.com/jscs-dev/node-jscs).
    16712    */
    16713   indent       : false,
    16714 
    16715   /**
    16716    * This options allows you to set the maximum amount of warnings JSHint will
    16717    * produce before giving up. Default is 50.
    16718    */
    16719   maxerr       : false,
    16720 
    16721   /**
    16722    * This option allows you to control which variables JSHint considers to be
    16723    * implicitly defined in the environment. Configure it with an array of
    16724    * string values. Prefixing a variable name with a hyphen (-) character will
    16725    * remove that name from the collection of predefined variables.
    16726    *
    16727    * JSHint will consider variables declared in this way to be read-only.
    16728    *
    16729    * This option cannot be specified in-line; it may only be used via the
    16730    * JavaScript API or from an external configuration file.
    16731    */
    16732   predef       : false,
    16733 
    16734   /**
    16735    * This option can be used to specify a white list of global variables that
    16736    * are not formally defined in the source code. This is most useful when
    16737    * combined with the `undef` option in order to suppress warnings for
    16738    * project-specific global variables.
    16739    *
    16740    * Setting an entry to `true` enables reading and writing to that variable.
    16741    * Setting it to `false` will trigger JSHint to consider that variable
    16742    * read-only.
    16743    *
    16744    * See also the "environment" options: a set of options to be used as short
    16745    * hand for enabling global variables defined in common JavaScript
    16746    * environments.
    16747    *
    16748    * To configure `globals` within an individual file, see [Inline
    16749    * Configuration](http://jshint.com/docs/#inline-configuration).
    16750    */
    16751   globals      : false,
    16752 
    16753   /**
    16754    * This option enforces the consistency of quotation marks used throughout
    16755    * your code. It accepts three values: `true` if you don't want to enforce
    16756    * one particular style but want some consistency, `"single"` if you want to
    16757    * allow only single quotes and `"double"` if you want to allow only double
    16758    * quotes.
    16759    *
    16760    * @deprecated JSHint is limiting its scope to issues of code correctness. If
    16761    *             you would like to enforce rules relating to code style, check
    16762    *             out [the JSCS project](https://github.com/jscs-dev/node-jscs).
    16763    */
    16764   quotmark     : false,
    16765 
    16766   scope        : false,
    16767 
    16768   /**
    16769    * This option lets you set the max number of statements allowed per function:
    16770    *
    16771    *     // jshint maxstatements:4
    16772    *
    16773    *     function main() {
    16774    *       var i = 0;
    16775    *       var j = 0;
    16776    *
    16777    *       // Function declarations count as one statement. Their bodies
    16778    *       // don't get taken into account for the outer function.
    16779    *       function inner() {
    16780    *         var i2 = 1;
    16781    *         var j2 = 1;
    16782    *
    16783    *         return i2 + j2;
    16784    *       }
    16785    *
    16786    *       j = i + j;
    16787    *       return j; // JSHint: Too many statements per function. (5)
    16788    *     }
    16789    */
    16790   maxstatements: false,
    16791 
    16792   /**
    16793    * This option lets you control how nested do you want your blocks to be:
    16794    *
    16795    *     // jshint maxdepth:2
    16796    *
    16797    *     function main(meaning) {
    16798    *       var day = true;
    16799    *
    16800    *       if (meaning === 42) {
    16801    *         while (day) {
    16802    *           shuffle();
    16803    *
    16804    *           if (tired) { // JSHint: Blocks are nested too deeply (3).
    16805    *               sleep();
    16806    *           }
    16807    *         }
    16808    *       }
    16809    *     }
    16810    */
    16811   maxdepth     : false,
    16812 
    16813   /**
    16814    * This option lets you set the max number of formal parameters allowed per
    16815    * function:
    16816    *
    16817    *     // jshint maxparams:3
    16818    *
    16819    *     function login(request, onSuccess) {
    16820    *       // ...
    16821    *     }
    16822    *
    16823    *     // JSHint: Too many parameters per function (4).
    16824    *     function logout(request, isManual, whereAmI, onSuccess) {
    16825    *       // ...
    16826    *     }
    16827    */
    16828   maxparams    : false,
    16829 
    16830   /**
    16831    * This option lets you control cyclomatic complexity throughout your code.
    16832    * Cyclomatic complexity measures the number of linearly independent paths
    16833    * through a program's source code. Read more about [cyclomatic complexity on
    16834    * Wikipedia](http://en.wikipedia.org/wiki/Cyclomatic_complexity).
    16835    */
    16836   maxcomplexity: false,
    16837 
    16838   /**
    16839    * This option suppresses warnings about variable shadowing i.e. declaring a
    16840    * variable that had been already declared somewhere in the outer scope.
    16841    *
    16842    * - "inner"  - check for variables defined in the same scope only
    16843    * - "outer"  - check for variables defined in outer scopes as well
    16844    * - false    - same as inner
    16845    * - true     - allow variable shadowing
    16846    */
    16847   shadow       : false,
    16848 
    16849   /**
    16850    * This option requires the code to run in ECMAScript 5's strict mode.
    16851    * [Strict mode](https://developer.mozilla.org/en/JavaScript/Strict_mode)
    16852    * is a way to opt in to a restricted variant of JavaScript. Strict mode
    16853    * eliminates some JavaScript pitfalls that didn't cause errors by changing
    16854    * them to produce errors.  It also fixes mistakes that made it difficult
    16855    * for the JavaScript engines to perform certain optimizations.
    16856    *
    16857    * - "global"  - there must be a `"use strict";` directive at global level
    16858    * - "implied" - lint the code as if there is the `"use strict";` directive
    16859    * - false     - disable warnings about strict mode
    16860    * - true      - there must be a `"use strict";` directive at function level;
    16861    *               this is preferable for scripts intended to be loaded in web
    16862    *               browsers directly because enabling strict mode globally
    16863    *               could adversely effect other scripts running on the same
    16864    *               page
    16865    */
    16866   strict      : true,
    16867 
    16868   /**
    16869    * This option warns when you define and never use your variables. It is very
    16870    * useful for general code cleanup, especially when used in addition to
    16871    * `undef`.
    16872    *
    16873    *     // jshint unused:true
    16874    *
    16875    *     function test(a, b) {
    16876    *       var c, d = 2;
    16877    *
    16878    *       return a + d;
    16879    *     }
    16880    *
    16881    *     test(1, 2);
    16882    *
    16883    *     // Line 3: 'b' was defined but never used.
    16884    *     // Line 4: 'c' was defined but never used.
    16885    *
    16886    * In addition to that, this option will warn you about unused global
    16887    * variables declared via the `global` directive.
    16888    *
    16889    * When set to `true`, unused parameters that are followed by a used
    16890    * parameter will not produce warnings. This option can be set to `vars` to
    16891    * only check for variables, not function parameters, or `strict` to check
    16892    * all variables and parameters.
    16893    */
    16894   unused       : true,
    16895 
    16896   /**
    16897    * This option prohibits the use of a variable before it was defined.
    16898    * JavaScript has function scope only and, in addition to that, all variables
    16899    * are always moved—or hoisted— to the top of the function. This behavior can
    16900    * lead to some very nasty bugs and that's why it is safer to always use
    16901    * variable only after they have been explicitly defined.
    16902    *
    16903    * Setting this option to "nofunc" will allow function declarations to be
    16904    * ignored.
    16905    *
    16906    * For more in-depth understanding of scoping and hoisting in JavaScript,
    16907    * read [JavaScript Scoping and
    16908    * Hoisting](http://www.adequatelygood.com/2010/2/JavaScript-Scoping-and-Hoisting)
    16909    * by Ben Cherry.
    16910    */
    16911   latedef      : false,
    16912 
    16913   ignore       : false, // start/end ignoring lines of code, bypassing the lexer
    16914                         //   start    - start ignoring lines, including the current line
    16915                         //   end      - stop ignoring lines, starting on the next line
    16916                         //   line     - ignore warnings / errors for just a single line
    16917                         //              (this option does not bypass the lexer)
    16918 
    16919   ignoreDelimiters: false, // array of start/end delimiters used to ignore
    16920                            // certain chunks from code
    16921 
    16922   /**
    16923    * This option is used to specify the ECMAScript version to which the code
    16924    * must adhere. It can assume one of the following values:
    16925    *  - `3` - If you need your program to be executable
    16926    *    in older browsers—such as Internet Explorer 6/7/8/9—and other legacy
    16927    *    JavaScript environments
    16928    *  - `5` - To enable syntax first defined in [the ECMAScript 5.1
    16929    *    specification](http://www.ecma-international.org/ecma-262/5.1/index.html).
    16930    *    This includes allowing reserved keywords as object properties.
    16931    *  - `6` - To tell JSHint that your code uses [ECMAScript
    16932    *    6](http://www.ecma-international.org/ecma-262/6.0/index.html) specific
    16933    *    syntax. Note that not all browsers implement them.
    16934    */
    16935   esversion: 5
    16936 };
    16937 
    16938 // These are JSHint boolean options which are shared with JSLint
    16939 // where the definition in JSHint is opposite JSLint
    16940 exports.inverted = {
    16941   bitwise : true,
    16942   forin   : true,
    16943   newcap  : true,
    16944   plusplus: true,
    16945   regexp  : true,
    16946   undef   : true,
    16947 
    16948   // Inverted and renamed, use JSHint name here
    16949   eqeqeq  : true,
    16950   strict  : true
    16951 };
    16952 
    16953 exports.validNames = Object.keys(exports.val)
    16954   .concat(Object.keys(exports.bool.relaxing))
    16955   .concat(Object.keys(exports.bool.enforcing))
    16956   .concat(Object.keys(exports.bool.obsolete))
    16957   .concat(Object.keys(exports.bool.environments));
    16958 
    16959 // These are JSHint boolean options which are shared with JSLint
    16960 // where the name has been changed but the effect is unchanged
    16961 exports.renamed = {
    16962   eqeq   : "eqeqeq",
    16963   windows: "wsh",
    16964   sloppy : "strict"
    16965 };
    16966 
    16967 exports.removed = {
    16968   nomen: true,
    16969   onevar: true,
    16970   passfail: true,
    16971   white: true,
    16972   gcl: true,
    16973   smarttabs: true,
    16974   trailing: true
    16975 };
    16976 
    16977 // Add options here which should not be automatically enforced by
    16978 // `enforceall`.
    16979 exports.noenforceall = {
    16980   varstmt: true,
    16981   strict: true
    16982 };
    16983 
    16984 },{}],17:[function(require,module,exports){
    16985 /*
    16986  * Regular expressions. Some of these are stupidly long.
    16987  */
    16988 
    16989 /*jshint maxlen:1000 */
    16990 
    16991 "use strict";
    16992 
    16993 // Unsafe comment or string (ax)
    16994 exports.unsafeString =
    16995   /@cc|<\/?|script|\]\s*\]|<\s*!|&lt/i;
    16996 
    16997 // Unsafe characters that are silently deleted by one or more browsers (cx)
    16998 exports.unsafeChars =
    16999   /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/;
    17000 
    17001 // Characters in strings that need escaping (nx and nxg)
    17002 exports.needEsc =
    17003   /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/;
    17004 
    17005 exports.needEscGlobal =
    17006   /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
    17007 
    17008 // Star slash (lx)
    17009 exports.starSlash = /\*\//;
    17010 
    17011 // Identifier (ix)
    17012 exports.identifier = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/;
    17013 
    17014 // JavaScript URL (jx)
    17015 exports.javascriptURL = /^(?:javascript|jscript|ecmascript|vbscript|livescript)\s*:/i;
    17016 
    17017 // Catches /* falls through */ comments (ft)
    17018 exports.fallsThrough = /^\s*falls?\sthrough\s*$/;
    17019 
    17020 // very conservative rule (eg: only one space between the start of the comment and the first character)
    17021 // to relax the maxlen option
    17022 exports.maxlenException = /^(?:(?:\/\/|\/\*|\*) ?)?[^ ]+$/;
    17023 
    17024 },{}],18:[function(require,module,exports){
    17025 "use strict";
    17026 
    17027 var _      = require("lodash");
    17028 var events = require("events");
    17029 
    17030 // Used to denote membership in lookup tables (a primitive value such as `true`
    17031 // would be silently rejected for the property name "__proto__" in some
    17032 // environments)
    17033 var marker = {};
    17034 
    17035 /**
    17036  * Creates a scope manager that handles variables and labels, storing usages
    17037  * and resolving when variables are used and undefined
    17038  */
    17039 var scopeManager = function(state, predefined, exported, declared) {
    17040 
    17041   var _current;
    17042   var _scopeStack = [];
    17043 
    17044   function _newScope(type) {
    17045     _current = {
    17046       "(labels)": Object.create(null),
    17047       "(usages)": Object.create(null),
    17048       "(breakLabels)": Object.create(null),
    17049       "(parent)": _current,
    17050       "(type)": type,
    17051       "(params)": (type === "functionparams" || type === "catchparams") ? [] : null
    17052     };
    17053     _scopeStack.push(_current);
    17054   }
    17055 
    17056   _newScope("global");
    17057   _current["(predefined)"] = predefined;
    17058 
    17059   var _currentFunctBody = _current; // this is the block after the params = function
    17060 
    17061   var usedPredefinedAndGlobals = Object.create(null);
    17062   var impliedGlobals = Object.create(null);
    17063   var unuseds = [];
    17064   var emitter = new events.EventEmitter();
    17065 
    17066   function warning(code, token) {
    17067     emitter.emit("warning", {
    17068       code: code,
    17069       token: token,
    17070       data: _.slice(arguments, 2)
    17071     });
    17072   }
    17073 
    17074   function error(code, token) {
    17075     emitter.emit("warning", {
    17076       code: code,
    17077       token: token,
    17078       data: _.slice(arguments, 2)
    17079     });
    17080   }
    17081 
    17082   function _setupUsages(labelName) {
    17083     if (!_current["(usages)"][labelName]) {
    17084       _current["(usages)"][labelName] = {
    17085         "(modified)": [],
    17086         "(reassigned)": [],
    17087         "(tokens)": []
    17088       };
    17089     }
    17090   }
    17091 
    17092   var _getUnusedOption = function(unused_opt) {
    17093     if (unused_opt === undefined) {
    17094       unused_opt = state.option.unused;
    17095     }
    17096 
    17097     if (unused_opt === true) {
    17098       unused_opt = "last-param";
    17099     }
    17100 
    17101     return unused_opt;
    17102   };
    17103 
    17104   var _warnUnused = function(name, tkn, type, unused_opt) {
    17105     var line = tkn.line;
    17106     var chr  = tkn.from;
    17107     var raw_name = tkn.raw_text || name;
    17108 
    17109     unused_opt = _getUnusedOption(unused_opt);
    17110 
    17111     var warnable_types = {
    17112       "vars": ["var"],
    17113       "last-param": ["var", "param"],
    17114       "strict": ["var", "param", "last-param"]
    17115     };
    17116 
    17117     if (unused_opt) {
    17118       if (warnable_types[unused_opt] && warnable_types[unused_opt].indexOf(type) !== -1) {
    17119         warning("W098", { line: line, from: chr }, raw_name);
    17120       }
    17121     }
    17122 
    17123     // inconsistent - see gh-1894
    17124     if (unused_opt || type === "var") {
    17125       unuseds.push({
    17126         name: name,
    17127         line: line,
    17128         character: chr
    17129       });
    17130     }
    17131   };
    17132 
    17133   /**
    17134    * Checks the current scope for unused identifiers
    17135    */
    17136   function _checkForUnused() {
    17137     // function params are handled specially
    17138     // assume that parameters are the only thing declared in the param scope
    17139     if (_current["(type)"] === "functionparams") {
    17140       _checkParams();
    17141       return;
    17142     }
    17143     var curentLabels = _current["(labels)"];
    17144     for (var labelName in curentLabels) {
    17145       if (curentLabels[labelName]) {
    17146         if (curentLabels[labelName]["(type)"] !== "exception" &&
    17147           curentLabels[labelName]["(unused)"]) {
    17148           _warnUnused(labelName, curentLabels[labelName]["(token)"], "var");
    17149         }
    17150       }
    17151     }
    17152   }
    17153 
    17154   /**
    17155    * Checks the current scope for unused parameters
    17156    * Must be called in a function parameter scope
    17157    */
    17158   function _checkParams() {
    17159     var params = _current["(params)"];
    17160 
    17161     if (!params) {
    17162       return;
    17163     }
    17164 
    17165     var param = params.pop();
    17166     var unused_opt;
    17167 
    17168     while (param) {
    17169       var label = _current["(labels)"][param];
    17170 
    17171       unused_opt = _getUnusedOption(state.funct["(unusedOption)"]);
    17172 
    17173       // 'undefined' is a special case for (function(window, undefined) { ... })();
    17174       // patterns.
    17175       if (param === "undefined")
    17176         return;
    17177 
    17178       if (label["(unused)"]) {
    17179         _warnUnused(param, label["(token)"], "param", state.funct["(unusedOption)"]);
    17180       } else if (unused_opt === "last-param") {
    17181         return;
    17182       }
    17183 
    17184       param = params.pop();
    17185     }
    17186   }
    17187 
    17188   /**
    17189    * Finds the relevant label's scope, searching from nearest outwards
    17190    * @returns {Object} the scope the label was found in
    17191    */
    17192   function _getLabel(labelName) {
    17193     for (var i = _scopeStack.length - 1 ; i >= 0; --i) {
    17194       var scopeLabels = _scopeStack[i]["(labels)"];
    17195       if (scopeLabels[labelName]) {
    17196         return scopeLabels;
    17197       }
    17198     }
    17199   }
    17200 
    17201   function usedSoFarInCurrentFunction(labelName) {
    17202     // used so far in this whole function and any sub functions
    17203     for (var i = _scopeStack.length - 1; i >= 0; i--) {
    17204       var current = _scopeStack[i];
    17205       if (current["(usages)"][labelName]) {
    17206         return current["(usages)"][labelName];
    17207       }
    17208       if (current === _currentFunctBody) {
    17209         break;
    17210       }
    17211     }
    17212     return false;
    17213   }
    17214 
    17215   function _checkOuterShadow(labelName, token) {
    17216 
    17217     // only check if shadow is outer
    17218     if (state.option.shadow !== "outer") {
    17219       return;
    17220     }
    17221 
    17222     var isGlobal = _currentFunctBody["(type)"] === "global",
    17223       isNewFunction = _current["(type)"] === "functionparams";
    17224 
    17225     var outsideCurrentFunction = !isGlobal;
    17226     for (var i = 0; i < _scopeStack.length; i++) {
    17227       var stackItem = _scopeStack[i];
    17228 
    17229       if (!isNewFunction && _scopeStack[i + 1] === _currentFunctBody) {
    17230         outsideCurrentFunction = false;
    17231       }
    17232       if (outsideCurrentFunction && stackItem["(labels)"][labelName]) {
    17233         warning("W123", token, labelName);
    17234       }
    17235       if (stackItem["(breakLabels)"][labelName]) {
    17236         warning("W123", token, labelName);
    17237       }
    17238     }
    17239   }
    17240 
    17241   function _latedefWarning(type, labelName, token) {
    17242     if (state.option.latedef) {
    17243       // if either latedef is strict and this is a function
    17244       //    or this is not a function
    17245       if ((state.option.latedef === true && type === "function") ||
    17246         type !== "function") {
    17247         warning("W003", token, labelName);
    17248       }
    17249     }
    17250   }
    17251 
    17252   var scopeManagerInst = {
    17253 
    17254     on: function(names, listener) {
    17255       names.split(" ").forEach(function(name) {
    17256         emitter.on(name, listener);
    17257       });
    17258     },
    17259 
    17260     isPredefined: function(labelName) {
    17261       return !this.has(labelName) && _.has(_scopeStack[0]["(predefined)"], labelName);
    17262     },
    17263 
    17264     /**
    17265      * Tell the manager we are entering a new block of code
    17266      * @param {string} [type] - The type of the block. Valid values are
    17267      *                          "functionparams", "catchparams" and
    17268      *                          "functionouter"
    17269      */
    17270     stack: function(type) {
    17271       var previousScope = _current;
    17272       _newScope(type);
    17273 
    17274       if (!type && previousScope["(type)"] === "functionparams") {
    17275 
    17276         _current["(isFuncBody)"] = true;
    17277         _current["(context)"] = _currentFunctBody;
    17278         _currentFunctBody = _current;
    17279       }
    17280     },
    17281 
    17282     unstack: function() {
    17283       // jshint proto: true
    17284       var subScope = _scopeStack.length > 1 ? _scopeStack[_scopeStack.length - 2] : null;
    17285       var isUnstackingFunctionBody = _current === _currentFunctBody,
    17286         isUnstackingFunctionParams = _current["(type)"] === "functionparams",
    17287         isUnstackingFunctionOuter = _current["(type)"] === "functionouter";
    17288 
    17289       var i, j;
    17290       var currentUsages = _current["(usages)"];
    17291       var currentLabels = _current["(labels)"];
    17292       var usedLabelNameList = Object.keys(currentUsages);
    17293 
    17294       if (currentUsages.__proto__ && usedLabelNameList.indexOf("__proto__") === -1) {
    17295         usedLabelNameList.push("__proto__");
    17296       }
    17297 
    17298       for (i = 0; i < usedLabelNameList.length; i++) {
    17299         var usedLabelName = usedLabelNameList[i];
    17300 
    17301         var usage = currentUsages[usedLabelName];
    17302         var usedLabel = currentLabels[usedLabelName];
    17303         if (usedLabel) {
    17304           var usedLabelType = usedLabel["(type)"];
    17305           var isImmutable = usedLabelType === "const" || usedLabelType === "import";
    17306 
    17307           if (usedLabel["(useOutsideOfScope)"] && !state.option.funcscope) {
    17308             var usedTokens = usage["(tokens)"];
    17309             if (usedTokens) {
    17310               for (j = 0; j < usedTokens.length; j++) {
    17311                 // Keep the consistency of https://github.com/jshint/jshint/issues/2409
    17312                 if (usedLabel["(function)"] === usedTokens[j]["(function)"]) {
    17313                   error("W038", usedTokens[j], usedLabelName);
    17314                 }
    17315               }
    17316             }
    17317           }
    17318 
    17319           // mark the label used
    17320           _current["(labels)"][usedLabelName]["(unused)"] = false;
    17321 
    17322           // check for modifying a const
    17323           if (isImmutable && usage["(modified)"]) {
    17324             for (j = 0; j < usage["(modified)"].length; j++) {
    17325               error("E013", usage["(modified)"][j], usedLabelName);
    17326             }
    17327           }
    17328 
    17329           // check for re-assigning a function declaration
    17330           if ((usedLabelType === "function" || usedLabelType === "class") &&
    17331               usage["(reassigned)"]) {
    17332             for (j = 0; j < usage["(reassigned)"].length; j++) {
    17333               if (!usage["(reassigned)"][j].ignoreW021) {
    17334                 warning("W021", usage["(reassigned)"][j], usedLabelName, usedLabelType);
    17335               }
    17336             }
    17337           }
    17338           continue;
    17339         }
    17340 
    17341         if (isUnstackingFunctionOuter) {
    17342           state.funct["(isCapturing)"] = true;
    17343         }
    17344 
    17345         if (subScope) {
    17346           // not exiting the global scope, so copy the usage down in case its an out of scope usage
    17347           if (!subScope["(usages)"][usedLabelName]) {
    17348             subScope["(usages)"][usedLabelName] = usage;
    17349             if (isUnstackingFunctionBody) {
    17350               subScope["(usages)"][usedLabelName]["(onlyUsedSubFunction)"] = true;
    17351             }
    17352           } else {
    17353             var subScopeUsage = subScope["(usages)"][usedLabelName];
    17354             subScopeUsage["(modified)"] = subScopeUsage["(modified)"].concat(usage["(modified)"]);
    17355             subScopeUsage["(tokens)"] = subScopeUsage["(tokens)"].concat(usage["(tokens)"]);
    17356             subScopeUsage["(reassigned)"] =
    17357               subScopeUsage["(reassigned)"].concat(usage["(reassigned)"]);
    17358           }
    17359         } else {
    17360           // this is exiting global scope, so we finalise everything here - we are at the end of the file
    17361           if (typeof _current["(predefined)"][usedLabelName] === "boolean") {
    17362 
    17363             // remove the declared token, so we know it is used
    17364             delete declared[usedLabelName];
    17365 
    17366             // note it as used so it can be reported
    17367             usedPredefinedAndGlobals[usedLabelName] = marker;
    17368 
    17369             // check for re-assigning a read-only (set to false) predefined
    17370             if (_current["(predefined)"][usedLabelName] === false && usage["(reassigned)"]) {
    17371               for (j = 0; j < usage["(reassigned)"].length; j++) {
    17372                 if (!usage["(reassigned)"][j].ignoreW020) {
    17373                   warning("W020", usage["(reassigned)"][j]);
    17374                 }
    17375               }
    17376             }
    17377           }
    17378           else {
    17379             // label usage is not predefined and we have not found a declaration
    17380             // so report as undeclared
    17381             if (usage["(tokens)"]) {
    17382               for (j = 0; j < usage["(tokens)"].length; j++) {
    17383                 var undefinedToken = usage["(tokens)"][j];
    17384                 // if its not a forgiven undefined (e.g. typof x)
    17385                 if (!undefinedToken.forgiveUndef) {
    17386                   // if undef is on and undef was on when the token was defined
    17387                   if (state.option.undef && !undefinedToken.ignoreUndef) {
    17388                     warning("W117", undefinedToken, usedLabelName);
    17389                   }
    17390                   if (impliedGlobals[usedLabelName]) {
    17391                     impliedGlobals[usedLabelName].line.push(undefinedToken.line);
    17392                   } else {
    17393                     impliedGlobals[usedLabelName] = {
    17394                       name: usedLabelName,
    17395                       line: [undefinedToken.line]
    17396                     };
    17397                   }
    17398                 }
    17399               }
    17400             }
    17401           }
    17402         }
    17403       }
    17404 
    17405       // if exiting the global scope, we can warn about declared globals that haven't been used yet
    17406       if (!subScope) {
    17407         Object.keys(declared)
    17408           .forEach(function(labelNotUsed) {
    17409             _warnUnused(labelNotUsed, declared[labelNotUsed], "var");
    17410           });
    17411       }
    17412 
    17413       // If this is not a function boundary, transfer function-scoped labels to
    17414       // the parent block (a rough simulation of variable hoisting). Previously
    17415       // existing labels in the parent block should take precedence so that things and stuff.
    17416       if (subScope && !isUnstackingFunctionBody &&
    17417         !isUnstackingFunctionParams && !isUnstackingFunctionOuter) {
    17418         var labelNames = Object.keys(currentLabels);
    17419         for (i = 0; i < labelNames.length; i++) {
    17420 
    17421           var defLabelName = labelNames[i];
    17422           var defLabel = currentLabels[defLabelName];
    17423 
    17424           if (!defLabel["(blockscoped)"] && defLabel["(type)"] !== "exception") {
    17425             var shadowed = subScope["(labels)"][defLabelName];
    17426 
    17427             // Do not overwrite a label if it exists in the parent scope
    17428             // because it is shared by adjacent blocks. Copy the `unused`
    17429             // property so that any references found within the current block
    17430             // are counted toward that higher-level declaration.
    17431             if (shadowed) {
    17432               shadowed["(unused)"] &= defLabel["(unused)"];
    17433 
    17434             // "Hoist" the variable to the parent block, decorating the label
    17435             // so that future references, though technically valid, can be
    17436             // reported as "out-of-scope" in the absence of the `funcscope`
    17437             // option.
    17438             } else {
    17439               defLabel["(useOutsideOfScope)"] =
    17440                 // Do not warn about out-of-scope usages in the global scope
    17441                 _currentFunctBody["(type)"] !== "global" &&
    17442                 // When a higher scope contains a binding for the label, the
    17443                 // label is a re-declaration and should not prompt "used
    17444                 // out-of-scope" warnings.
    17445                 !this.funct.has(defLabelName, { excludeCurrent: true });
    17446 
    17447               subScope["(labels)"][defLabelName] = defLabel;
    17448             }
    17449 
    17450             delete currentLabels[defLabelName];
    17451           }
    17452         }
    17453       }
    17454 
    17455       _checkForUnused();
    17456 
    17457       _scopeStack.pop();
    17458       if (isUnstackingFunctionBody) {
    17459         _currentFunctBody = _scopeStack[_.findLastIndex(_scopeStack, function(scope) {
    17460           // if function or if global (which is at the bottom so it will only return true if we call back)
    17461           return scope["(isFuncBody)"] || scope["(type)"] === "global";
    17462         })];
    17463       }
    17464 
    17465       _current = subScope;
    17466     },
    17467 
    17468     /**
    17469      * Add a param to the current scope
    17470      * @param {string} labelName
    17471      * @param {Token} token
    17472      * @param {string} [type="param"] param type
    17473      */
    17474     addParam: function(labelName, token, type) {
    17475       type = type || "param";
    17476 
    17477       if (type === "exception") {
    17478         // if defined in the current function
    17479         var previouslyDefinedLabelType = this.funct.labeltype(labelName);
    17480         if (previouslyDefinedLabelType && previouslyDefinedLabelType !== "exception") {
    17481           // and has not been used yet in the current function scope
    17482           if (!state.option.node) {
    17483             warning("W002", state.tokens.next, labelName);
    17484           }
    17485         }
    17486       }
    17487 
    17488       // The variable was declared in the current scope
    17489       if (_.has(_current["(labels)"], labelName)) {
    17490         _current["(labels)"][labelName].duplicated = true;
    17491 
    17492       // The variable was declared in an outer scope
    17493       } else {
    17494         // if this scope has the variable defined, it's a re-definition error
    17495         _checkOuterShadow(labelName, token, type);
    17496 
    17497         _current["(labels)"][labelName] = {
    17498           "(type)" : type,
    17499           "(token)": token,
    17500           "(unused)": true };
    17501 
    17502         _current["(params)"].push(labelName);
    17503       }
    17504 
    17505       if (_.has(_current["(usages)"], labelName)) {
    17506         var usage = _current["(usages)"][labelName];
    17507         // if its in a sub function it is not necessarily an error, just latedef
    17508         if (usage["(onlyUsedSubFunction)"]) {
    17509           _latedefWarning(type, labelName, token);
    17510         } else {
    17511           // this is a clear illegal usage for block scoped variables
    17512           warning("E056", token, labelName, type);
    17513         }
    17514       }
    17515     },
    17516 
    17517     validateParams: function() {
    17518       // This method only concerns errors for function parameters
    17519       if (_currentFunctBody["(type)"] === "global") {
    17520         return;
    17521       }
    17522 
    17523       var isStrict = state.isStrict();
    17524       var currentFunctParamScope = _currentFunctBody["(parent)"];
    17525 
    17526       if (!currentFunctParamScope["(params)"]) {
    17527         return;
    17528       }
    17529 
    17530       currentFunctParamScope["(params)"].forEach(function(labelName) {
    17531         var label = currentFunctParamScope["(labels)"][labelName];
    17532 
    17533         if (label && label.duplicated) {
    17534           if (isStrict) {
    17535             warning("E011", label["(token)"], labelName);
    17536           } else if (state.option.shadow !== true) {
    17537             warning("W004", label["(token)"], labelName);
    17538           }
    17539         }
    17540       });
    17541     },
    17542 
    17543     getUsedOrDefinedGlobals: function() {
    17544       // jshint proto: true
    17545       var list = Object.keys(usedPredefinedAndGlobals);
    17546 
    17547       // If `__proto__` is used as a global variable name, its entry in the
    17548       // lookup table may not be enumerated by `Object.keys` (depending on the
    17549       // environment).
    17550       if (usedPredefinedAndGlobals.__proto__ === marker &&
    17551         list.indexOf("__proto__") === -1) {
    17552         list.push("__proto__");
    17553       }
    17554 
    17555       return list;
    17556     },
    17557 
    17558     /**
    17559      * Gets an array of implied globals
    17560      * @returns {Array.<{ name: string, line: Array.<number>}>}
    17561      */
    17562     getImpliedGlobals: function() {
    17563       // jshint proto: true
    17564       var values = _.values(impliedGlobals);
    17565       var hasProto = false;
    17566 
    17567       // If `__proto__` is an implied global variable, its entry in the lookup
    17568       // table may not be enumerated by `_.values` (depending on the
    17569       // environment).
    17570       if (impliedGlobals.__proto__) {
    17571         hasProto = values.some(function(value) {
    17572           return value.name === "__proto__";
    17573         });
    17574 
    17575         if (!hasProto) {
    17576           values.push(impliedGlobals.__proto__);
    17577         }
    17578       }
    17579 
    17580       return values;
    17581     },
    17582 
    17583     /**
    17584      * Returns a list of unused variables
    17585      * @returns {Array}
    17586      */
    17587     getUnuseds: function() {
    17588       return unuseds;
    17589     },
    17590 
    17591     has: function(labelName) {
    17592       return Boolean(_getLabel(labelName));
    17593     },
    17594 
    17595     labeltype: function(labelName) {
    17596       // returns a labels type or null if not present
    17597       var scopeLabels = _getLabel(labelName);
    17598       if (scopeLabels) {
    17599         return scopeLabels[labelName]["(type)"];
    17600       }
    17601       return null;
    17602     },
    17603 
    17604     /**
    17605      * for the exported options, indicating a variable is used outside the file
    17606      */
    17607     addExported: function(labelName) {
    17608       var globalLabels = _scopeStack[0]["(labels)"];
    17609       if (_.has(declared, labelName)) {
    17610         // remove the declared token, so we know it is used
    17611         delete declared[labelName];
    17612       } else if (_.has(globalLabels, labelName)) {
    17613         globalLabels[labelName]["(unused)"] = false;
    17614       } else {
    17615         for (var i = 1; i < _scopeStack.length; i++) {
    17616           var scope = _scopeStack[i];
    17617           // if `scope.(type)` is not defined, it is a block scope
    17618           if (!scope["(type)"]) {
    17619             if (_.has(scope["(labels)"], labelName) &&
    17620                 !scope["(labels)"][labelName]["(blockscoped)"]) {
    17621               scope["(labels)"][labelName]["(unused)"] = false;
    17622               return;
    17623             }
    17624           } else {
    17625             break;
    17626           }
    17627         }
    17628         exported[labelName] = true;
    17629       }
    17630     },
    17631 
    17632     /**
    17633      * Mark an indentifier as es6 module exported
    17634      */
    17635     setExported: function(labelName, token) {
    17636       this.block.use(labelName, token);
    17637     },
    17638 
    17639     initialize: function(labelName) {
    17640       if (_current["(labels)"][labelName]) {
    17641         _current["(labels)"][labelName]["(initialized)"] = true;
    17642       }
    17643     },
    17644 
    17645     /**
    17646      * adds an indentifier to the relevant current scope and creates warnings/errors as necessary
    17647      * @param {string} labelName
    17648      * @param {Object} opts
    17649      * @param {String} opts.type - the type of the label e.g. "param", "var", "let, "const", "import", "function"
    17650      * @param {Token} opts.token - the token pointing at the declaration
    17651      * @param {boolean} opts.initialized - whether the binding should be created in an "initialized" state.
    17652      */
    17653     addlabel: function(labelName, opts) {
    17654 
    17655       var type  = opts.type;
    17656       var token = opts.token;
    17657       var isblockscoped = type === "let" || type === "const" ||
    17658         type === "class" || type === "import";
    17659       var ishoisted = type === "function" || type === "import";
    17660       var isexported    = (isblockscoped ? _current : _currentFunctBody)["(type)"] === "global" &&
    17661                           _.has(exported, labelName);
    17662 
    17663       // outer shadow check (inner is only on non-block scoped)
    17664       _checkOuterShadow(labelName, token, type);
    17665 
    17666       if (isblockscoped) {
    17667 
    17668         var declaredInCurrentScope = _current["(labels)"][labelName];
    17669         // for block scoped variables, params are seen in the current scope as the root function
    17670         // scope, so check these too.
    17671         if (!declaredInCurrentScope && _current === _currentFunctBody &&
    17672           _current["(type)"] !== "global") {
    17673           declaredInCurrentScope = !!_currentFunctBody["(parent)"]["(labels)"][labelName];
    17674         }
    17675 
    17676         // if its not already defined (which is an error, so ignore) and is used in TDZ
    17677         if (!declaredInCurrentScope && _current["(usages)"][labelName]) {
    17678           var usage = _current["(usages)"][labelName];
    17679           // if its in a sub function it is not necessarily an error, just latedef
    17680           if (usage["(onlyUsedSubFunction)"] || ishoisted) {
    17681             _latedefWarning(type, labelName, token);
    17682           } else if (!ishoisted) {
    17683             // this is a clear illegal usage for block scoped variables
    17684             warning("E056", token, labelName, type);
    17685           }
    17686         }
    17687 
    17688         // if this scope has the variable defined, its a re-definition error
    17689         if (declaredInCurrentScope) {
    17690           warning("E011", token, labelName);
    17691         }
    17692         else if (state.option.shadow === "outer") {
    17693 
    17694           // if shadow is outer, for block scope we want to detect any shadowing within this function
    17695           if (scopeManagerInst.funct.has(labelName)) {
    17696             warning("W004", token, labelName);
    17697           }
    17698         }
    17699 
    17700         scopeManagerInst.block.add(
    17701           labelName, type, token, !isexported, opts.initialized
    17702         );
    17703 
    17704       } else {
    17705 
    17706         var declaredInCurrentFunctionScope = scopeManagerInst.funct.has(labelName);
    17707 
    17708         // check for late definition, ignore if already declared
    17709         if (!declaredInCurrentFunctionScope && usedSoFarInCurrentFunction(labelName)) {
    17710           _latedefWarning(type, labelName, token);
    17711         }
    17712 
    17713         // defining with a var or a function when a block scope variable of the same name
    17714         // is in scope is an error
    17715         if (scopeManagerInst.funct.has(labelName, { onlyBlockscoped: true })) {
    17716           warning("E011", token, labelName);
    17717         } else if (state.option.shadow !== true) {
    17718           // now since we didn't get any block scope variables, test for var/function
    17719           // shadowing
    17720           if (declaredInCurrentFunctionScope && labelName !== "__proto__") {
    17721 
    17722             // see https://github.com/jshint/jshint/issues/2400
    17723             if (_currentFunctBody["(type)"] !== "global") {
    17724               warning("W004", token, labelName);
    17725             }
    17726           }
    17727         }
    17728 
    17729         scopeManagerInst.funct.add(labelName, type, token, !isexported);
    17730 
    17731         if (_currentFunctBody["(type)"] === "global" && !state.impliedClosure()) {
    17732           usedPredefinedAndGlobals[labelName] = marker;
    17733         }
    17734       }
    17735     },
    17736 
    17737     funct: {
    17738       /**
    17739        * Returns the label type given certain options
    17740        * @param labelName
    17741        * @param {Object=} options
    17742        * @param {Boolean=} options.onlyBlockscoped - only include block scoped labels
    17743        * @param {Boolean=} options.excludeParams - exclude the param scope
    17744        * @param {Boolean=} options.excludeCurrent - exclude the current scope
    17745        * @returns {String}
    17746        */
    17747       labeltype: function(labelName, options) {
    17748         var onlyBlockscoped = options && options.onlyBlockscoped;
    17749         var excludeParams = options && options.excludeParams;
    17750         var currentScopeIndex = _scopeStack.length - (options && options.excludeCurrent ? 2 : 1);
    17751         for (var i = currentScopeIndex; i >= 0; i--) {
    17752           var current = _scopeStack[i];
    17753           if (current["(labels)"][labelName] &&
    17754             (!onlyBlockscoped || current["(labels)"][labelName]["(blockscoped)"])) {
    17755             return current["(labels)"][labelName]["(type)"];
    17756           }
    17757           var scopeCheck = excludeParams ? _scopeStack[ i - 1 ] : current;
    17758           if (scopeCheck && scopeCheck["(type)"] === "functionparams") {
    17759             return null;
    17760           }
    17761         }
    17762         return null;
    17763       },
    17764       /**
    17765        * Returns if a break label exists in the function scope
    17766        * @param {string} labelName
    17767        * @returns {boolean}
    17768        */
    17769       hasBreakLabel: function(labelName) {
    17770         for (var i = _scopeStack.length - 1; i >= 0; i--) {
    17771           var current = _scopeStack[i];
    17772 
    17773           if (current["(breakLabels)"][labelName]) {
    17774             return true;
    17775           }
    17776           if (current["(type)"] === "functionparams") {
    17777             return false;
    17778           }
    17779         }
    17780         return false;
    17781       },
    17782       /**
    17783        * Returns if the label is in the current function scope
    17784        * See scopeManager.funct.labelType for options
    17785        */
    17786       has: function(labelName, options) {
    17787         return Boolean(this.labeltype(labelName, options));
    17788       },
    17789 
    17790       /**
    17791        * Adds a new function scoped variable
    17792        * see block.add for block scoped
    17793        */
    17794       add: function(labelName, type, tok, unused) {
    17795         _current["(labels)"][labelName] = {
    17796           "(type)" : type,
    17797           "(token)": tok,
    17798           "(blockscoped)": false,
    17799           "(function)": _currentFunctBody,
    17800           "(unused)": unused };
    17801       }
    17802     },
    17803 
    17804     block: {
    17805 
    17806       /**
    17807        * is the current block global?
    17808        * @returns Boolean
    17809        */
    17810       isGlobal: function() {
    17811         return _current["(type)"] === "global";
    17812       },
    17813 
    17814       use: function(labelName, token) {
    17815 
    17816         // if resolves to current function params, then do not store usage just resolve
    17817         // this is because function(a) { var a; a = a; } will resolve to the param, not
    17818         // to the unset var
    17819         // first check the param is used
    17820         var paramScope = _currentFunctBody["(parent)"];
    17821         if (paramScope && paramScope["(labels)"][labelName] &&
    17822           paramScope["(labels)"][labelName]["(type)"] === "param") {
    17823 
    17824           // then check its not declared by a block scope variable
    17825           if (!scopeManagerInst.funct.has(labelName,
    17826                 { excludeParams: true, onlyBlockscoped: true })) {
    17827             paramScope["(labels)"][labelName]["(unused)"] = false;
    17828           }
    17829         }
    17830 
    17831         if (token && (state.ignored.W117 || state.option.undef === false)) {
    17832           token.ignoreUndef = true;
    17833         }
    17834 
    17835         _setupUsages(labelName);
    17836 
    17837         _current["(usages)"][labelName]["(onlyUsedSubFunction)"] = false;
    17838 
    17839         if (token) {
    17840           token["(function)"] = _currentFunctBody;
    17841           _current["(usages)"][labelName]["(tokens)"].push(token);
    17842         }
    17843 
    17844         // blockscoped vars can't be used within their initializer (TDZ)
    17845         var label = _current["(labels)"][labelName];
    17846         if (label && label["(blockscoped)"] && !label["(initialized)"]) {
    17847           error("E056", token, labelName, label["(type)"]);
    17848         }
    17849       },
    17850 
    17851       reassign: function(labelName, token) {
    17852         token.ignoreW020 = state.ignored.W020;
    17853         token.ignoreW021 = state.ignored.W021;
    17854 
    17855         this.modify(labelName, token);
    17856 
    17857         _current["(usages)"][labelName]["(reassigned)"].push(token);
    17858       },
    17859 
    17860       modify: function(labelName, token) {
    17861 
    17862         _setupUsages(labelName);
    17863 
    17864         _current["(usages)"][labelName]["(onlyUsedSubFunction)"] = false;
    17865         _current["(usages)"][labelName]["(modified)"].push(token);
    17866       },
    17867 
    17868       /**
    17869        * Adds a new variable
    17870        */
    17871       add: function(labelName, type, tok, unused, initialized) {
    17872         _current["(labels)"][labelName] = {
    17873           "(type)" : type,
    17874           "(token)": tok,
    17875           "(initialized)": !!initialized,
    17876           "(blockscoped)": true,
    17877           "(unused)": unused };
    17878       },
    17879 
    17880       addBreakLabel: function(labelName, opts) {
    17881         var token = opts.token;
    17882         if (scopeManagerInst.funct.hasBreakLabel(labelName)) {
    17883           warning("E011", token, labelName);
    17884         }
    17885         else if (state.option.shadow === "outer") {
    17886           if (scopeManagerInst.funct.has(labelName)) {
    17887             warning("W004", token, labelName);
    17888           } else {
    17889             _checkOuterShadow(labelName, token);
    17890           }
    17891         }
    17892         _current["(breakLabels)"][labelName] = token;
    17893       }
    17894     }
    17895   };
    17896   return scopeManagerInst;
    17897 };
    17898 
    17899 module.exports = scopeManager;
    17900 
    17901 },{"events":5,"lodash":12}],19:[function(require,module,exports){
    17902 "use strict";
    17903 var NameStack = require("./name-stack.js");
    17904 
    17905 var state = {
    17906   syntax: {},
    17907 
    17908   /**
    17909    * Determine if the code currently being linted is strict mode code.
    17910    *
    17911    * @returns {boolean}
    17912    */
    17913   isStrict: function() {
    17914     return this.directive["use strict"] || this.inClassBody ||
    17915       this.option.module || this.option.strict === "implied";
    17916   },
    17917 
    17918   /**
    17919    * Determine if the current state warrants a warning for statements outside
    17920    * of strict mode code.
    17921    *
    17922    * While emitting warnings based on function scope would be more intuitive
    17923    * (and less noisy), JSHint observes statement-based semantics in order to
    17924    * preserve legacy behavior.
    17925    *
    17926    * This method does not take the state of the parser into account, making no
    17927    * distinction between global code and function code. Because the "missing
    17928    * 'use strict'" warning is *also* reported at function boundaries, this
    17929    * function interprets `strict` option values `true` and `undefined` as
    17930    * equivalent.
    17931    */
    17932   stmtMissingStrict: function() {
    17933     if (this.option.strict === "global") {
    17934       return true;
    17935     }
    17936 
    17937     if (this.option.strict === false) {
    17938       return false;
    17939     }
    17940 
    17941     if (this.option.globalstrict) {
    17942       return true;
    17943     }
    17944 
    17945     return false;
    17946   },
    17947 
    17948   allowsGlobalUsd: function() {
    17949     return this.option.strict === "global" || this.option.globalstrict ||
    17950       this.option.module || this.impliedClosure();
    17951   },
    17952 
    17953   /**
    17954    * Determine if the current configuration describes an environment that is
    17955    * wrapped in an immediately-invoked function expression prior to evaluation.
    17956    *
    17957    * @returns {boolean}
    17958    */
    17959   impliedClosure: function() {
    17960     return this.option.node || this.option.phantom || this.option.browserify;
    17961   },
    17962 
    17963   // Assumption: chronologically ES3 < ES5 < ES6 < Moz
    17964 
    17965   inMoz: function() {
    17966     return this.option.moz;
    17967   },
    17968 
    17969   /**
    17970    * @param {boolean} strict - When `true`, only consider ES6 when in
    17971    *                           "esversion: 6" code.
    17972    */
    17973   inES6: function(strict) {
    17974     if (strict) {
    17975       return this.esVersion === 6;
    17976     }
    17977     return this.option.moz || this.esVersion >= 6;
    17978   },
    17979 
    17980   /**
    17981    * @param {boolean} strict - When `true`, return `true` only when
    17982    *                           esVersion is exactly 5
    17983    */
    17984   inES5: function(strict) {
    17985     if (strict) {
    17986       return (!this.esVersion || this.esVersion === 5) && !this.option.moz;
    17987     }
    17988     return !this.esVersion || this.esVersion >= 5 || this.option.moz;
    17989   },
    17990 
    17991   /**
    17992    * Determine the current version of the input language by inspecting the
    17993    * value of all ECMAScript-version-related options. This logic is necessary
    17994    * to ensure compatibility with deprecated options `es3`, `es5`, and
    17995    * `esnext`, and it may be drastically simplified when those options are
    17996    * removed.
    17997    *
    17998    * @returns {string|null} - the name of any incompatible option detected,
    17999    *                          `null` otherwise
    18000    */
    18001   inferEsVersion: function() {
    18002     var badOpt = null;
    18003 
    18004     if (this.option.esversion) {
    18005       if (this.option.es3) {
    18006         badOpt = "es3";
    18007       } else if (this.option.es5) {
    18008         badOpt = "es5";
    18009       } else if (this.option.esnext) {
    18010         badOpt = "esnext";
    18011       }
    18012 
    18013       if (badOpt) {
    18014         return badOpt;
    18015       }
    18016 
    18017       if (this.option.esversion === 2015) {
    18018         this.esVersion = 6;
    18019       } else {
    18020         this.esVersion = this.option.esversion;
    18021       }
    18022     } else if (this.option.es3) {
    18023       this.esVersion = 3;
    18024     } else if (this.option.esnext) {
    18025       this.esVersion = 6;
    18026     }
    18027 
    18028     return null;
    18029   },
    18030 
    18031   reset: function() {
    18032     this.tokens = {
    18033       prev: null,
    18034       next: null,
    18035       curr: null
    18036     };
    18037 
    18038     this.option = {};
    18039     this.esVersion = 5;
    18040     this.funct = null;
    18041     this.ignored = {};
    18042     this.directive = {};
    18043     this.jsonMode = false;
    18044     this.jsonWarnings = [];
    18045     this.lines = [];
    18046     this.tab = "";
    18047     this.cache = {}; // Node.JS doesn't have Map. Sniff.
    18048     this.ignoredLines = {};
    18049     this.forinifcheckneeded = false;
    18050     this.nameStack = new NameStack();
    18051     this.inClassBody = false;
    18052   }
    18053 };
    18054 
    18055 exports.state = state;
    18056 
    18057 },{"./name-stack.js":15}],20:[function(require,module,exports){
    18058 "use strict";
    18059 
    18060 exports.register = function(linter) {
    18061   // Check for properties named __proto__. This special property was
    18062   // deprecated and then re-introduced for ES6.
    18063 
    18064   linter.on("Identifier", function style_scanProto(data) {
    18065     if (linter.getOption("proto")) {
    18066       return;
    18067     }
    18068 
    18069     if (data.name === "__proto__") {
    18070       linter.warn("W103", {
    18071         line: data.line,
    18072         char: data.char,
    18073         data: [ data.name, "6" ]
    18074       });
    18075     }
    18076   });
    18077 
    18078   // Check for properties named __iterator__. This is a special property
    18079   // available only in browsers with JavaScript 1.7 implementation, but
    18080   // it is deprecated for ES6
    18081 
    18082   linter.on("Identifier", function style_scanIterator(data) {
    18083     if (linter.getOption("iterator")) {
    18084       return;
    18085     }
    18086 
    18087     if (data.name === "__iterator__") {
    18088       linter.warn("W103", {
    18089         line: data.line,
    18090         char: data.char,
    18091         data: [ data.name ]
    18092       });
    18093     }
    18094   });
    18095 
    18096   // Check that all identifiers are using camelCase notation.
    18097   // Exceptions: names like MY_VAR and _myVar.
    18098 
    18099   linter.on("Identifier", function style_scanCamelCase(data) {
    18100     if (!linter.getOption("camelcase")) {
    18101       return;
    18102     }
    18103 
    18104     if (data.name.replace(/^_+|_+$/g, "").indexOf("_") > -1 && !data.name.match(/^[A-Z0-9_]*$/)) {
    18105       linter.warn("W106", {
    18106         line: data.line,
    18107         char: data.char,
    18108         data: [ data.name ]
    18109       });
    18110     }
    18111   });
    18112 
    18113   // Enforce consistency in style of quoting.
    18114 
    18115   linter.on("String", function style_scanQuotes(data) {
    18116     var quotmark = linter.getOption("quotmark");
    18117     var code;
    18118 
    18119     if (!quotmark) {
    18120       return;
    18121     }
    18122 
    18123     // If quotmark is set to 'single' warn about all double-quotes.
    18124 
    18125     if (quotmark === "single" && data.quote !== "'") {
    18126       code = "W109";
    18127     }
    18128 
    18129     // If quotmark is set to 'double' warn about all single-quotes.
    18130 
    18131     if (quotmark === "double" && data.quote !== "\"") {
    18132       code = "W108";
    18133     }
    18134 
    18135     // If quotmark is set to true, remember the first quotation style
    18136     // and then warn about all others.
    18137 
    18138     if (quotmark === true) {
    18139       if (!linter.getCache("quotmark")) {
    18140         linter.setCache("quotmark", data.quote);
    18141       }
    18142 
    18143       if (linter.getCache("quotmark") !== data.quote) {
    18144         code = "W110";
    18145       }
    18146     }
    18147 
    18148     if (code) {
    18149       linter.warn(code, {
    18150         line: data.line,
    18151         char: data.char,
    18152       });
    18153     }
    18154   });
    18155 
    18156   linter.on("Number", function style_scanNumbers(data) {
    18157     if (data.value.charAt(0) === ".") {
    18158       // Warn about a leading decimal point.
    18159       linter.warn("W008", {
    18160         line: data.line,
    18161         char: data.char,
    18162         data: [ data.value ]
    18163       });
    18164     }
    18165 
    18166     if (data.value.substr(data.value.length - 1) === ".") {
    18167       // Warn about a trailing decimal point.
    18168       linter.warn("W047", {
    18169         line: data.line,
    18170         char: data.char,
    18171         data: [ data.value ]
    18172       });
    18173     }
    18174 
    18175     if (/^00+/.test(data.value)) {
    18176       // Multiple leading zeroes.
    18177       linter.warn("W046", {
    18178         line: data.line,
    18179         char: data.char,
    18180         data: [ data.value ]
    18181       });
    18182     }
    18183   });
    18184 
    18185   // Warn about script URLs.
    18186 
    18187   linter.on("String", function style_scanJavaScriptURLs(data) {
    18188     var re = /^(?:javascript|jscript|ecmascript|vbscript|livescript)\s*:/i;
    18189 
    18190     if (linter.getOption("scripturl")) {
    18191       return;
    18192     }
    18193 
    18194     if (re.test(data.value)) {
    18195       linter.warn("W107", {
    18196         line: data.line,
    18197         char: data.char
    18198       });
    18199     }
    18200   });
    18201 };
    18202 
    18203 },{}],21:[function(require,module,exports){
    18204 // jshint -W001
    18205 
    18206 "use strict";
    18207 
    18208 // Identifiers provided by the ECMAScript standard.
    18209 
    18210 exports.reservedVars = {
    18211   arguments : false,
    18212   NaN       : false
    18213 };
    18214 
    18215 exports.ecmaIdentifiers = {
    18216   3: {
    18217     Array              : false,
    18218     Boolean            : false,
    18219     Date               : false,
    18220     decodeURI          : false,
    18221     decodeURIComponent : false,
    18222     encodeURI          : false,
    18223     encodeURIComponent : false,
    18224     Error              : false,
    18225     "eval"             : false,
    18226     EvalError          : false,
    18227     Function           : false,
    18228     hasOwnProperty     : false,
    18229     isFinite           : false,
    18230     isNaN              : false,
    18231     Math               : false,
    18232     Number             : false,
    18233     Object             : false,
    18234     parseInt           : false,
    18235     parseFloat         : false,
    18236     RangeError         : false,
    18237     ReferenceError     : false,
    18238     RegExp             : false,
    18239     String             : false,
    18240     SyntaxError        : false,
    18241     TypeError          : false,
    18242     URIError           : false
    18243   },
    18244   5: {
    18245     JSON               : false
    18246   },
    18247   6: {
    18248     ArrayBuffer        : false,
    18249     DataView           : false,
    18250     Float32Array       : false,
    18251     Float64Array       : false,
    18252     Int8Array          : false,
    18253     Int16Array         : false,
    18254     Int32Array         : false,
    18255     Map                : false,
    18256     Promise            : false,
    18257     Proxy              : false,
    18258     Reflect            : false,
    18259     Set                : false,
    18260     Symbol             : false,
    18261     Uint8Array         : false,
    18262     Uint16Array        : false,
    18263     Uint32Array        : false,
    18264     Uint8ClampledArray : false,
    18265     WeakMap            : false,
    18266     WeakSet            : false
    18267   }
    18268 };
    18269 
    18270 // Global variables commonly provided by a web browser environment.
    18271 
    18272 exports.browser = {
    18273   Audio                : false,
    18274   Blob                 : false,
    18275   addEventListener     : false,
    18276   applicationCache     : false,
    18277   atob                 : false,
    18278   blur                 : false,
    18279   btoa                 : false,
    18280   cancelAnimationFrame : false,
    18281   CanvasGradient       : false,
    18282   CanvasPattern        : false,
    18283   CanvasRenderingContext2D: false,
    18284   CSS                  : false,
    18285   clearInterval        : false,
    18286   clearTimeout         : false,
    18287   close                : false,
    18288   closed               : false,
    18289   Comment              : false,
    18290   CompositionEvent     : false,
    18291   CustomEvent          : false,
    18292   DOMParser            : false,
    18293   defaultStatus        : false,
    18294   Document             : false,
    18295   document             : false,
    18296   DocumentFragment     : false,
    18297   Element              : false,
    18298   ElementTimeControl   : false,
    18299   Event                : false,
    18300   event                : false,
    18301   fetch                : false,
    18302   File                 : false,
    18303   FileList             : false,
    18304   FileReader           : false,
    18305   FormData             : false,
    18306   focus                : false,
    18307   frames               : false,
    18308   getComputedStyle     : false,
    18309   HTMLElement          : false,
    18310   HTMLAnchorElement    : false,
    18311   HTMLBaseElement      : false,
    18312   HTMLBlockquoteElement: false,
    18313   HTMLBodyElement      : false,
    18314   HTMLBRElement        : false,
    18315   HTMLButtonElement    : false,
    18316   HTMLCanvasElement    : false,
    18317   HTMLCollection       : false,
    18318   HTMLDirectoryElement : false,
    18319   HTMLDivElement       : false,
    18320   HTMLDListElement     : false,
    18321   HTMLFieldSetElement  : false,
    18322   HTMLFontElement      : false,
    18323   HTMLFormElement      : false,
    18324   HTMLFrameElement     : false,
    18325   HTMLFrameSetElement  : false,
    18326   HTMLHeadElement      : false,
    18327   HTMLHeadingElement   : false,
    18328   HTMLHRElement        : false,
    18329   HTMLHtmlElement      : false,
    18330   HTMLIFrameElement    : false,
    18331   HTMLImageElement     : false,
    18332   HTMLInputElement     : false,
    18333   HTMLIsIndexElement   : false,
    18334   HTMLLabelElement     : false,
    18335   HTMLLayerElement     : false,
    18336   HTMLLegendElement    : false,
    18337   HTMLLIElement        : false,
    18338   HTMLLinkElement      : false,
    18339   HTMLMapElement       : false,
    18340   HTMLMenuElement      : false,
    18341   HTMLMetaElement      : false,
    18342   HTMLModElement       : false,
    18343   HTMLObjectElement    : false,
    18344   HTMLOListElement     : false,
    18345   HTMLOptGroupElement  : false,
    18346   HTMLOptionElement    : false,
    18347   HTMLParagraphElement : false,
    18348   HTMLParamElement     : false,
    18349   HTMLPreElement       : false,
    18350   HTMLQuoteElement     : false,
    18351   HTMLScriptElement    : false,
    18352   HTMLSelectElement    : false,
    18353   HTMLStyleElement     : false,
    18354   HTMLTableCaptionElement: false,
    18355   HTMLTableCellElement : false,
    18356   HTMLTableColElement  : false,
    18357   HTMLTableElement     : false,
    18358   HTMLTableRowElement  : false,
    18359   HTMLTableSectionElement: false,
    18360   HTMLTemplateElement  : false,
    18361   HTMLTextAreaElement  : false,
    18362   HTMLTitleElement     : false,
    18363   HTMLUListElement     : false,
    18364   HTMLVideoElement     : false,
    18365   history              : false,
    18366   Image                : false,
    18367   Intl                 : false,
    18368   length               : false,
    18369   localStorage         : false,
    18370   location             : false,
    18371   matchMedia           : false,
    18372   MediaRecorder        : false,
    18373   MessageChannel       : false,
    18374   MessageEvent         : false,
    18375   MessagePort          : false,
    18376   MouseEvent           : false,
    18377   moveBy               : false,
    18378   moveTo               : false,
    18379   MutationObserver     : false,
    18380   name                 : false,
    18381   Node                 : false,
    18382   NodeFilter           : false,
    18383   NodeList             : false,
    18384   Notification         : false,
    18385   navigator            : false,
    18386   onbeforeunload       : true,
    18387   onblur               : true,
    18388   onerror              : true,
    18389   onfocus              : true,
    18390   onload               : true,
    18391   onresize             : true,
    18392   onunload             : true,
    18393   open                 : false,
    18394   openDatabase         : false,
    18395   opener               : false,
    18396   Option               : false,
    18397   parent               : false,
    18398   performance          : false,
    18399   print                : false,
    18400   Range                : false,
    18401   requestAnimationFrame : false,
    18402   removeEventListener  : false,
    18403   resizeBy             : false,
    18404   resizeTo             : false,
    18405   screen               : false,
    18406   scroll               : false,
    18407   scrollBy             : false,
    18408   scrollTo             : false,
    18409   sessionStorage       : false,
    18410   setInterval          : false,
    18411   setTimeout           : false,
    18412   SharedWorker         : false,
    18413   status               : false,
    18414   Storage              : false,
    18415   SVGAElement          : false,
    18416   SVGAltGlyphDefElement: false,
    18417   SVGAltGlyphElement   : false,
    18418   SVGAltGlyphItemElement: false,
    18419   SVGAngle             : false,
    18420   SVGAnimateColorElement: false,
    18421   SVGAnimateElement    : false,
    18422   SVGAnimateMotionElement: false,
    18423   SVGAnimateTransformElement: false,
    18424   SVGAnimatedAngle     : false,
    18425   SVGAnimatedBoolean   : false,
    18426   SVGAnimatedEnumeration: false,
    18427   SVGAnimatedInteger   : false,
    18428   SVGAnimatedLength    : false,
    18429   SVGAnimatedLengthList: false,
    18430   SVGAnimatedNumber    : false,
    18431   SVGAnimatedNumberList: false,
    18432   SVGAnimatedPathData  : false,
    18433   SVGAnimatedPoints    : false,
    18434   SVGAnimatedPreserveAspectRatio: false,
    18435   SVGAnimatedRect      : false,
    18436   SVGAnimatedString    : false,
    18437   SVGAnimatedTransformList: false,
    18438   SVGAnimationElement  : false,
    18439   SVGCSSRule           : false,
    18440   SVGCircleElement     : false,
    18441   SVGClipPathElement   : false,
    18442   SVGColor             : false,
    18443   SVGColorProfileElement: false,
    18444   SVGColorProfileRule  : false,
    18445   SVGComponentTransferFunctionElement: false,
    18446   SVGCursorElement     : false,
    18447   SVGDefsElement       : false,
    18448   SVGDescElement       : false,
    18449   SVGDocument          : false,
    18450   SVGElement           : false,
    18451   SVGElementInstance   : false,
    18452   SVGElementInstanceList: false,
    18453   SVGEllipseElement    : false,
    18454   SVGExternalResourcesRequired: false,
    18455   SVGFEBlendElement    : false,
    18456   SVGFEColorMatrixElement: false,
    18457   SVGFEComponentTransferElement: false,
    18458   SVGFECompositeElement: false,
    18459   SVGFEConvolveMatrixElement: false,
    18460   SVGFEDiffuseLightingElement: false,
    18461   SVGFEDisplacementMapElement: false,
    18462   SVGFEDistantLightElement: false,
    18463   SVGFEFloodElement    : false,
    18464   SVGFEFuncAElement    : false,
    18465   SVGFEFuncBElement    : false,
    18466   SVGFEFuncGElement    : false,
    18467   SVGFEFuncRElement    : false,
    18468   SVGFEGaussianBlurElement: false,
    18469   SVGFEImageElement    : false,
    18470   SVGFEMergeElement    : false,
    18471   SVGFEMergeNodeElement: false,
    18472   SVGFEMorphologyElement: false,
    18473   SVGFEOffsetElement   : false,
    18474   SVGFEPointLightElement: false,
    18475   SVGFESpecularLightingElement: false,
    18476   SVGFESpotLightElement: false,
    18477   SVGFETileElement     : false,
    18478   SVGFETurbulenceElement: false,
    18479   SVGFilterElement     : false,
    18480   SVGFilterPrimitiveStandardAttributes: false,
    18481   SVGFitToViewBox      : false,
    18482   SVGFontElement       : false,
    18483   SVGFontFaceElement   : false,
    18484   SVGFontFaceFormatElement: false,
    18485   SVGFontFaceNameElement: false,
    18486   SVGFontFaceSrcElement: false,
    18487   SVGFontFaceUriElement: false,
    18488   SVGForeignObjectElement: false,
    18489   SVGGElement          : false,
    18490   SVGGlyphElement      : false,
    18491   SVGGlyphRefElement   : false,
    18492   SVGGradientElement   : false,
    18493   SVGHKernElement      : false,
    18494   SVGICCColor          : false,
    18495   SVGImageElement      : false,
    18496   SVGLangSpace         : false,
    18497   SVGLength            : false,
    18498   SVGLengthList        : false,
    18499   SVGLineElement       : false,
    18500   SVGLinearGradientElement: false,
    18501   SVGLocatable         : false,
    18502   SVGMPathElement      : false,
    18503   SVGMarkerElement     : false,
    18504   SVGMaskElement       : false,
    18505   SVGMatrix            : false,
    18506   SVGMetadataElement   : false,
    18507   SVGMissingGlyphElement: false,
    18508   SVGNumber            : false,
    18509   SVGNumberList        : false,
    18510   SVGPaint             : false,
    18511   SVGPathElement       : false,
    18512   SVGPathSeg           : false,
    18513   SVGPathSegArcAbs     : false,
    18514   SVGPathSegArcRel     : false,
    18515   SVGPathSegClosePath  : false,
    18516   SVGPathSegCurvetoCubicAbs: false,
    18517   SVGPathSegCurvetoCubicRel: false,
    18518   SVGPathSegCurvetoCubicSmoothAbs: false,
    18519   SVGPathSegCurvetoCubicSmoothRel: false,
    18520   SVGPathSegCurvetoQuadraticAbs: false,
    18521   SVGPathSegCurvetoQuadraticRel: false,
    18522   SVGPathSegCurvetoQuadraticSmoothAbs: false,
    18523   SVGPathSegCurvetoQuadraticSmoothRel: false,
    18524   SVGPathSegLinetoAbs  : false,
    18525   SVGPathSegLinetoHorizontalAbs: false,
    18526   SVGPathSegLinetoHorizontalRel: false,
    18527   SVGPathSegLinetoRel  : false,
    18528   SVGPathSegLinetoVerticalAbs: false,
    18529   SVGPathSegLinetoVerticalRel: false,
    18530   SVGPathSegList       : false,
    18531   SVGPathSegMovetoAbs  : false,
    18532   SVGPathSegMovetoRel  : false,
    18533   SVGPatternElement    : false,
    18534   SVGPoint             : false,
    18535   SVGPointList         : false,
    18536   SVGPolygonElement    : false,
    18537   SVGPolylineElement   : false,
    18538   SVGPreserveAspectRatio: false,
    18539   SVGRadialGradientElement: false,
    18540   SVGRect              : false,
    18541   SVGRectElement       : false,
    18542   SVGRenderingIntent   : false,
    18543   SVGSVGElement        : false,
    18544   SVGScriptElement     : false,
    18545   SVGSetElement        : false,
    18546   SVGStopElement       : false,
    18547   SVGStringList        : false,
    18548   SVGStylable          : false,
    18549   SVGStyleElement      : false,
    18550   SVGSwitchElement     : false,
    18551   SVGSymbolElement     : false,
    18552   SVGTRefElement       : false,
    18553   SVGTSpanElement      : false,
    18554   SVGTests             : false,
    18555   SVGTextContentElement: false,
    18556   SVGTextElement       : false,
    18557   SVGTextPathElement   : false,
    18558   SVGTextPositioningElement: false,
    18559   SVGTitleElement      : false,
    18560   SVGTransform         : false,
    18561   SVGTransformList     : false,
    18562   SVGTransformable     : false,
    18563   SVGURIReference      : false,
    18564   SVGUnitTypes         : false,
    18565   SVGUseElement        : false,
    18566   SVGVKernElement      : false,
    18567   SVGViewElement       : false,
    18568   SVGViewSpec          : false,
    18569   SVGZoomAndPan        : false,
    18570   Text                 : false,
    18571   TextDecoder          : false,
    18572   TextEncoder          : false,
    18573   TimeEvent            : false,
    18574   top                  : false,
    18575   URL                  : false,
    18576   WebGLActiveInfo      : false,
    18577   WebGLBuffer          : false,
    18578   WebGLContextEvent    : false,
    18579   WebGLFramebuffer     : false,
    18580   WebGLProgram         : false,
    18581   WebGLRenderbuffer    : false,
    18582   WebGLRenderingContext: false,
    18583   WebGLShader          : false,
    18584   WebGLShaderPrecisionFormat: false,
    18585   WebGLTexture         : false,
    18586   WebGLUniformLocation : false,
    18587   WebSocket            : false,
    18588   window               : false,
    18589   Window               : false,
    18590   Worker               : false,
    18591   XDomainRequest       : false,
    18592   XMLHttpRequest       : false,
    18593   XMLSerializer        : false,
    18594   XPathEvaluator       : false,
    18595   XPathException       : false,
    18596   XPathExpression      : false,
    18597   XPathNamespace       : false,
    18598   XPathNSResolver      : false,
    18599   XPathResult          : false
    18600 };
    18601 
    18602 exports.devel = {
    18603   alert  : false,
    18604   confirm: false,
    18605   console: false,
    18606   Debug  : false,
    18607   opera  : false,
    18608   prompt : false
    18609 };
    18610 
    18611 exports.worker = {
    18612   importScripts  : true,
    18613   onmessage      : true,
    18614   postMessage    : true,
    18615   self           : true,
    18616   FileReaderSync : true
    18617 };
    18618 
    18619 // Widely adopted global names that are not part of ECMAScript standard
    18620 exports.nonstandard = {
    18621   escape  : false,
    18622   unescape: false
    18623 };
    18624 
    18625 // Globals provided by popular JavaScript environments.
    18626 
    18627 exports.couch = {
    18628   "require" : false,
    18629   respond   : false,
    18630   getRow    : false,
    18631   emit      : false,
    18632   send      : false,
    18633   start     : false,
    18634   sum       : false,
    18635   log       : false,
    18636   exports   : false,
    18637   module    : false,
    18638   provides  : false
    18639 };
    18640 
    18641 exports.node = {
    18642   __filename    : false,
    18643   __dirname     : false,
    18644   GLOBAL        : false,
    18645   global        : false,
    18646   module        : false,
    18647   require       : false,
    18648 
    18649   // These globals are writeable because Node allows the following
    18650   // usage pattern: var Buffer = require("buffer").Buffer;
    18651 
    18652   Buffer        : true,
    18653   console       : true,
    18654   exports       : true,
    18655   process       : true,
    18656   setTimeout    : true,
    18657   clearTimeout  : true,
    18658   setInterval   : true,
    18659   clearInterval : true,
    18660   setImmediate  : true, // v0.9.1+
    18661   clearImmediate: true  // v0.9.1+
    18662 };
    18663 
    18664 exports.browserify = {
    18665   __filename    : false,
    18666   __dirname     : false,
    18667   global        : false,
    18668   module        : false,
    18669   require       : false,
    18670   Buffer        : true,
    18671   exports       : true,
    18672   process       : true
    18673 };
    18674 
    18675 exports.phantom = {
    18676   phantom      : true,
    18677   require      : true,
    18678   WebPage      : true,
    18679   console      : true, // in examples, but undocumented
    18680   exports      : true  // v1.7+
    18681 };
    18682 
    18683 exports.qunit = {
    18684   asyncTest      : false,
    18685   deepEqual      : false,
    18686   equal          : false,
    18687   expect         : false,
    18688   module         : false,
    18689   notDeepEqual   : false,
    18690   notEqual       : false,
    18691   notOk          : false,
    18692   notPropEqual   : false,
    18693   notStrictEqual : false,
    18694   ok             : false,
    18695   propEqual      : false,
    18696   QUnit          : false,
    18697   raises         : false,
    18698   start          : false,
    18699   stop           : false,
    18700   strictEqual    : false,
    18701   test           : false,
    18702   "throws"       : false
    18703 };
    18704 
    18705 exports.rhino = {
    18706   defineClass  : false,
    18707   deserialize  : false,
    18708   gc           : false,
    18709   help         : false,
    18710   importClass  : false,
    18711   importPackage: false,
    18712   "java"       : false,
    18713   load         : false,
    18714   loadClass    : false,
    18715   Packages     : false,
    18716   print        : false,
    18717   quit         : false,
    18718   readFile     : false,
    18719   readUrl      : false,
    18720   runCommand   : false,
    18721   seal         : false,
    18722   serialize    : false,
    18723   spawn        : false,
    18724   sync         : false,
    18725   toint32      : false,
    18726   version      : false
    18727 };
    18728 
    18729 exports.shelljs = {
    18730   target       : false,
    18731   echo         : false,
    18732   exit         : false,
    18733   cd           : false,
    18734   pwd          : false,
    18735   ls           : false,
    18736   find         : false,
    18737   cp           : false,
    18738   rm           : false,
    18739   mv           : false,
    18740   mkdir        : false,
    18741   test         : false,
    18742   cat          : false,
    18743   sed          : false,
    18744   grep         : false,
    18745   which        : false,
    18746   dirs         : false,
    18747   pushd        : false,
    18748   popd         : false,
    18749   env          : false,
    18750   exec         : false,
    18751   chmod        : false,
    18752   config       : false,
    18753   error        : false,
    18754   tempdir      : false
    18755 };
    18756 
    18757 exports.typed = {
    18758   ArrayBuffer         : false,
    18759   ArrayBufferView     : false,
    18760   DataView            : false,
    18761   Float32Array        : false,
    18762   Float64Array        : false,
    18763   Int16Array          : false,
    18764   Int32Array          : false,
    18765   Int8Array           : false,
    18766   Uint16Array         : false,
    18767   Uint32Array         : false,
    18768   Uint8Array          : false,
    18769   Uint8ClampedArray   : false
    18770 };
    18771 
    18772 exports.wsh = {
    18773   ActiveXObject            : true,
    18774   Enumerator               : true,
    18775   GetObject                : true,
    18776   ScriptEngine             : true,
    18777   ScriptEngineBuildVersion : true,
    18778   ScriptEngineMajorVersion : true,
    18779   ScriptEngineMinorVersion : true,
    18780   VBArray                  : true,
    18781   WSH                      : true,
    18782   WScript                  : true,
    18783   XDomainRequest           : true
    18784 };
    18785 
    18786 // Globals provided by popular JavaScript libraries.
    18787 
    18788 exports.dojo = {
    18789   dojo     : false,
    18790   dijit    : false,
    18791   dojox    : false,
    18792   define   : false,
    18793   "require": false
    18794 };
    18795 
    18796 exports.jquery = {
    18797   "$"    : false,
    18798   jQuery : false
    18799 };
    18800 
    18801 exports.mootools = {
    18802   "$"           : false,
    18803   "$$"          : false,
    18804   Asset         : false,
    18805   Browser       : false,
    18806   Chain         : false,
    18807   Class         : false,
    18808   Color         : false,
    18809   Cookie        : false,
    18810   Core          : false,
    18811   Document      : false,
    18812   DomReady      : false,
    18813   DOMEvent      : false,
    18814   DOMReady      : false,
    18815   Drag          : false,
    18816   Element       : false,
    18817   Elements      : false,
    18818   Event         : false,
    18819   Events        : false,
    18820   Fx            : false,
    18821   Group         : false,
    18822   Hash          : false,
    18823   HtmlTable     : false,
    18824   IFrame        : false,
    18825   IframeShim    : false,
    18826   InputValidator: false,
    18827   instanceOf    : false,
    18828   Keyboard      : false,
    18829   Locale        : false,
    18830   Mask          : false,
    18831   MooTools      : false,
    18832   Native        : false,
    18833   Options       : false,
    18834   OverText      : false,
    18835   Request       : false,
    18836   Scroller      : false,
    18837   Slick         : false,
    18838   Slider        : false,
    18839   Sortables     : false,
    18840   Spinner       : false,
    18841   Swiff         : false,
    18842   Tips          : false,
    18843   Type          : false,
    18844   typeOf        : false,
    18845   URI           : false,
    18846   Window        : false
    18847 };
    18848 
    18849 exports.prototypejs = {
    18850   "$"               : false,
    18851   "$$"              : false,
    18852   "$A"              : false,
    18853   "$F"              : false,
    18854   "$H"              : false,
    18855   "$R"              : false,
    18856   "$break"          : false,
    18857   "$continue"       : false,
    18858   "$w"              : false,
    18859   Abstract          : false,
    18860   Ajax              : false,
    18861   Class             : false,
    18862   Enumerable        : false,
    18863   Element           : false,
    18864   Event             : false,
    18865   Field             : false,
    18866   Form              : false,
    18867   Hash              : false,
    18868   Insertion         : false,
    18869   ObjectRange       : false,
    18870   PeriodicalExecuter: false,
    18871   Position          : false,
    18872   Prototype         : false,
    18873   Selector          : false,
    18874   Template          : false,
    18875   Toggle            : false,
    18876   Try               : false,
    18877   Autocompleter     : false,
    18878   Builder           : false,
    18879   Control           : false,
    18880   Draggable         : false,
    18881   Draggables        : false,
    18882   Droppables        : false,
    18883   Effect            : false,
    18884   Sortable          : false,
    18885   SortableObserver  : false,
    18886   Sound             : false,
    18887   Scriptaculous     : false
    18888 };
    18889 
    18890 exports.yui = {
    18891   YUI       : false,
    18892   Y         : false,
    18893   YUI_config: false
    18894 };
    18895 
    18896 exports.mocha = {
    18897   // Global (for config etc.)
    18898   mocha       : false,
    18899   // BDD
    18900   describe    : false,
    18901   xdescribe   : false,
    18902   it          : false,
    18903   xit         : false,
    18904   context     : false,
    18905   xcontext    : false,
    18906   before      : false,
    18907   after       : false,
    18908   beforeEach  : false,
    18909   afterEach   : false,
    18910   // TDD
    18911   suite         : false,
    18912   test          : false,
    18913   setup         : false,
    18914   teardown      : false,
    18915   suiteSetup    : false,
    18916   suiteTeardown : false
    18917 };
    18918 
    18919 exports.jasmine = {
    18920   jasmine     : false,
    18921   describe    : false,
    18922   xdescribe   : false,
    18923   it          : false,
    18924   xit         : false,
    18925   beforeEach  : false,
    18926   afterEach   : false,
    18927   setFixtures : false,
    18928   loadFixtures: false,
    18929   spyOn       : false,
    18930   expect      : false,
    18931   // Jasmine 1.3
    18932   runs        : false,
    18933   waitsFor    : false,
    18934   waits       : false,
    18935   // Jasmine 2.1
    18936   beforeAll   : false,
    18937   afterAll    : false,
    18938   fail        : false,
    18939   fdescribe   : false,
    18940   fit         : false,
    18941   pending     : false
    18942 };
    18943 
    18944 },{}],"jshint":[function(require,module,exports){
    18945 /*!
    18946  * JSHint, by JSHint Community.
    18947  *
    18948  * This file (and this file only) is licensed under the same slightly modified
    18949  * MIT license that JSLint is. It stops evil-doers everywhere:
    18950  *
    18951  *   Copyright (c) 2002 Douglas Crockford  (www.JSLint.com)
    18952  *
    18953  *   Permission is hereby granted, free of charge, to any person obtaining
    18954  *   a copy of this software and associated documentation files (the "Software"),
    18955  *   to deal in the Software without restriction, including without limitation
    18956  *   the rights to use, copy, modify, merge, publish, distribute, sublicense,
    18957  *   and/or sell copies of the Software, and to permit persons to whom
    18958  *   the Software is furnished to do so, subject to the following conditions:
    18959  *
    18960  *   The above copyright notice and this permission notice shall be included
    18961  *   in all copies or substantial portions of the Software.
    18962  *
    18963  *   The Software shall be used for Good, not Evil.
    18964  *
    18965  *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    18966  *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    18967  *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    18968  *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    18969  *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    18970  *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    18971  *   DEALINGS IN THE SOFTWARE.
    18972  *
    18973  */
    18974 
    18975 /*jshint quotmark:double */
    18976 /*exported console */
    18977 
    18978 var _            = require("lodash");
    18979 var events       = require("events");
    18980 var vars         = require("./vars.js");
    18981 var messages     = require("./messages.js");
    18982 var Lexer        = require("./lex.js").Lexer;
    18983 var reg          = require("./reg.js");
    18984 var state        = require("./state.js").state;
    18985 var style        = require("./style.js");
    18986 var options      = require("./options.js");
    18987 var scopeManager = require("./scope-manager.js");
    18988 
    18989 // We need this module here because environments such as IE and Rhino
    18990 // don't necessarilly expose the 'console' API and browserify uses
    18991 // it to log things. It's a sad state of affair, really.
    18992 var console = require("console-browserify");
    18993 
    18994 // We build the application inside a function so that we produce only a singleton
    18995 // variable. That function will be invoked immediately, and its return value is
    18996 // the JSHINT function itself.
    18997 
    18998 var JSHINT = (function() {
    18999   "use strict";
    19000 
    19001   var api, // Extension API
    19002 
    19003     // These are operators that should not be used with the ! operator.
    19004     bang = {
    19005       "<"  : true,
    19006       "<=" : true,
    19007       "==" : true,
    19008       "===": true,
    19009       "!==": true,
    19010       "!=" : true,
    19011       ">"  : true,
    19012       ">=" : true,
    19013       "+"  : true,
    19014       "-"  : true,
    19015       "*"  : true,
    19016       "/"  : true,
    19017       "%"  : true
    19018     },
    19019 
    19020     declared, // Globals that were declared using /*global ... */ syntax.
    19021 
    19022     functionicity = [
    19023       "closure", "exception", "global", "label",
    19024       "outer", "unused", "var"
    19025     ],
    19026 
    19027     functions, // All of the functions
    19028 
    19029     inblock,
    19030     indent,
    19031     lookahead,
    19032     lex,
    19033     member,
    19034     membersOnly,
    19035     predefined,    // Global variables defined by option
    19036 
    19037     stack,
    19038     urls,
    19039 
    19040     extraModules = [],
    19041     emitter = new events.EventEmitter();
    19042 
    19043   function checkOption(name, t) {
    19044     name = name.trim();
    19045 
    19046     if (/^[+-]W\d{3}$/g.test(name)) {
    19047       return true;
    19048     }
    19049 
    19050     if (options.validNames.indexOf(name) === -1) {
    19051       if (t.type !== "jslint" && !_.has(options.removed, name)) {
    19052         error("E001", t, name);
    19053         return false;
    19054       }
    19055     }
    19056 
    19057     return true;
    19058   }
    19059 
    19060   function isString(obj) {
    19061     return Object.prototype.toString.call(obj) === "[object String]";
    19062   }
    19063 
    19064   function isIdentifier(tkn, value) {
    19065     if (!tkn)
    19066       return false;
    19067 
    19068     if (!tkn.identifier || tkn.value !== value)
    19069       return false;
    19070 
    19071     return true;
    19072   }
    19073 
    19074   function isReserved(token) {
    19075     if (!token.reserved) {
    19076       return false;
    19077     }
    19078     var meta = token.meta;
    19079 
    19080     if (meta && meta.isFutureReservedWord) {
    19081       if (meta.moduleOnly && !state.option.module) {
    19082         return false;
    19083       }
    19084 
    19085       if (state.inES5()) {
    19086         // ES3 FutureReservedWord in an ES5 environment.
    19087         if (!meta.es5) {
    19088           return false;
    19089         }
    19090 
    19091         // Some ES5 FutureReservedWord identifiers are active only
    19092         // within a strict mode environment.
    19093         if (meta.strictOnly) {
    19094           if (!state.option.strict && !state.isStrict()) {
    19095             return false;
    19096           }
    19097         }
    19098 
    19099         if (token.isProperty) {
    19100           return false;
    19101         }
    19102       }
    19103     }
    19104 
    19105     return true;
    19106   }
    19107 
    19108   function supplant(str, data) {
    19109     return str.replace(/\{([^{}]*)\}/g, function(a, b) {
    19110       var r = data[b];
    19111       return typeof r === "string" || typeof r === "number" ? r : a;
    19112     });
    19113   }
    19114 
    19115   function combine(dest, src) {
    19116     Object.keys(src).forEach(function(name) {
    19117       if (_.has(JSHINT.blacklist, name)) return;
    19118       dest[name] = src[name];
    19119     });
    19120   }
    19121 
    19122   function processenforceall() {
    19123     if (state.option.enforceall) {
    19124       for (var enforceopt in options.bool.enforcing) {
    19125         if (state.option[enforceopt] === undefined &&
    19126             !options.noenforceall[enforceopt]) {
    19127           state.option[enforceopt] = true;
    19128         }
    19129       }
    19130       for (var relaxopt in options.bool.relaxing) {
    19131         if (state.option[relaxopt] === undefined) {
    19132           state.option[relaxopt] = false;
    19133         }
    19134       }
    19135     }
    19136   }
    19137 
    19138   /**
    19139    * Apply all linting options according to the status of the `state` object.
    19140    */
    19141   function applyOptions() {
    19142     var badESOpt = null;
    19143     processenforceall();
    19144 
    19145     /**
    19146      * TODO: Remove in JSHint 3
    19147      */
    19148     badESOpt = state.inferEsVersion();
    19149     if (badESOpt) {
    19150       quit("E059", state.tokens.next, "esversion", badESOpt);
    19151     }
    19152 
    19153     if (state.inES5()) {
    19154       combine(predefined, vars.ecmaIdentifiers[5]);
    19155     }
    19156 
    19157     if (state.inES6()) {
    19158       combine(predefined, vars.ecmaIdentifiers[6]);
    19159     }
    19160 
    19161     /**
    19162      * Use `in` to check for the presence of any explicitly-specified value for
    19163      * `globalstrict` because both `true` and `false` should trigger an error.
    19164      */
    19165     if (state.option.strict === "global" && "globalstrict" in state.option) {
    19166       quit("E059", state.tokens.next, "strict", "globalstrict");
    19167     }
    19168 
    19169     if (state.option.module) {
    19170       /**
    19171        * TODO: Extend this restriction to *all* ES6-specific options.
    19172        */
    19173       if (!state.inES6()) {
    19174         warning("W134", state.tokens.next, "module", 6);
    19175       }
    19176     }
    19177 
    19178     if (state.option.couch) {
    19179       combine(predefined, vars.couch);
    19180     }
    19181 
    19182     if (state.option.qunit) {
    19183       combine(predefined, vars.qunit);
    19184     }
    19185 
    19186     if (state.option.rhino) {
    19187       combine(predefined, vars.rhino);
    19188     }
    19189 
    19190     if (state.option.shelljs) {
    19191       combine(predefined, vars.shelljs);
    19192       combine(predefined, vars.node);
    19193     }
    19194     if (state.option.typed) {
    19195       combine(predefined, vars.typed);
    19196     }
    19197 
    19198     if (state.option.phantom) {
    19199       combine(predefined, vars.phantom);
    19200     }
    19201 
    19202     if (state.option.prototypejs) {
    19203       combine(predefined, vars.prototypejs);
    19204     }
    19205 
    19206     if (state.option.node) {
    19207       combine(predefined, vars.node);
    19208       combine(predefined, vars.typed);
    19209     }
    19210 
    19211     if (state.option.devel) {
    19212       combine(predefined, vars.devel);
    19213     }
    19214 
    19215     if (state.option.dojo) {
    19216       combine(predefined, vars.dojo);
    19217     }
    19218 
    19219     if (state.option.browser) {
    19220       combine(predefined, vars.browser);
    19221       combine(predefined, vars.typed);
    19222     }
    19223 
    19224     if (state.option.browserify) {
    19225       combine(predefined, vars.browser);
    19226       combine(predefined, vars.typed);
    19227       combine(predefined, vars.browserify);
    19228     }
    19229 
    19230     if (state.option.nonstandard) {
    19231       combine(predefined, vars.nonstandard);
    19232     }
    19233 
    19234     if (state.option.jasmine) {
    19235       combine(predefined, vars.jasmine);
    19236     }
    19237 
    19238     if (state.option.jquery) {
    19239       combine(predefined, vars.jquery);
    19240     }
    19241 
    19242     if (state.option.mootools) {
    19243       combine(predefined, vars.mootools);
    19244     }
    19245 
    19246     if (state.option.worker) {
    19247       combine(predefined, vars.worker);
    19248     }
    19249 
    19250     if (state.option.wsh) {
    19251       combine(predefined, vars.wsh);
    19252     }
    19253 
    19254     if (state.option.yui) {
    19255       combine(predefined, vars.yui);
    19256     }
    19257 
    19258     if (state.option.mocha) {
    19259       combine(predefined, vars.mocha);
    19260     }
    19261   }
    19262 
    19263   // Produce an error warning.
    19264   function quit(code, token, a, b) {
    19265     var percentage = Math.floor((token.line / state.lines.length) * 100);
    19266     var message = messages.errors[code].desc;
    19267 
    19268     var exception = {
    19269       name: "JSHintError",
    19270       line: token.line,
    19271       character: token.from,
    19272       message: message + " (" + percentage + "% scanned).",
    19273       raw: message,
    19274       code: code,
    19275       a: a,
    19276       b: b
    19277     };
    19278 
    19279     exception.reason = supplant(message, exception) + " (" + percentage +
    19280       "% scanned).";
    19281 
    19282     throw exception;
    19283   }
    19284 
    19285   function removeIgnoredMessages() {
    19286     var ignored = state.ignoredLines;
    19287 
    19288     if (_.isEmpty(ignored)) return;
    19289     JSHINT.errors = _.reject(JSHINT.errors, function(err) { return ignored[err.line] });
    19290   }
    19291 
    19292   function warning(code, t, a, b, c, d) {
    19293     var ch, l, w, msg;
    19294 
    19295     if (/^W\d{3}$/.test(code)) {
    19296       if (state.ignored[code])
    19297         return;
    19298 
    19299       msg = messages.warnings[code];
    19300     } else if (/E\d{3}/.test(code)) {
    19301       msg = messages.errors[code];
    19302     } else if (/I\d{3}/.test(code)) {
    19303       msg = messages.info[code];
    19304     }
    19305 
    19306     t = t || state.tokens.next || {};
    19307     if (t.id === "(end)") {  // `~
    19308       t = state.tokens.curr;
    19309     }
    19310 
    19311     l = t.line;
    19312     ch = t.from;
    19313 
    19314     w = {
    19315       id: "(error)",
    19316       raw: msg.desc,
    19317       code: msg.code,
    19318       evidence: state.lines[l - 1] || "",
    19319       line: l,
    19320       character: ch,
    19321       scope: JSHINT.scope,
    19322       a: a,
    19323       b: b,
    19324       c: c,
    19325       d: d
    19326     };
    19327 
    19328     w.reason = supplant(msg.desc, w);
    19329     JSHINT.errors.push(w);
    19330 
    19331     removeIgnoredMessages();
    19332 
    19333     if (JSHINT.errors.length >= state.option.maxerr)
    19334       quit("E043", t);
    19335 
    19336     return w;
    19337   }
    19338 
    19339   function warningAt(m, l, ch, a, b, c, d) {
    19340     return warning(m, {
    19341       line: l,
    19342       from: ch
    19343     }, a, b, c, d);
    19344   }
    19345 
    19346   function error(m, t, a, b, c, d) {
    19347     warning(m, t, a, b, c, d);
    19348   }
    19349 
    19350   function errorAt(m, l, ch, a, b, c, d) {
    19351     return error(m, {
    19352       line: l,
    19353       from: ch
    19354     }, a, b, c, d);
    19355   }
    19356 
    19357   // Tracking of "internal" scripts, like eval containing a static string
    19358   function addEvalCode(elem, token) {
    19359     JSHINT.internals.push({
    19360       id: "(internal)",
    19361       elem: elem,
    19362       token: token,
    19363       code: token.value.replace(/([^\\])(\\*)\2\\n/g, "$1\n")
    19364     });
    19365   }
    19366 
    19367   /**
    19368    * Process an inline linting directive
    19369    *
    19370    * @param {Token} directiveToken - the directive-bearing comment token
    19371    * @param {Token} previous - the token that preceeds the directive
    19372    */
    19373   function lintingDirective(directiveToken, previous) {
    19374     var body = directiveToken.body.split(",")
    19375       .map(function(s) { return s.trim(); });
    19376     var predef = {};
    19377 
    19378     if (directiveToken.type === "falls through") {
    19379       previous.caseFallsThrough = true;
    19380       return;
    19381     }
    19382 
    19383     if (directiveToken.type === "globals") {
    19384       body.forEach(function(g, idx) {
    19385         g = g.split(":");
    19386         var key = (g[0] || "").trim();
    19387         var val = (g[1] || "").trim();
    19388 
    19389         if (key === "-" || !key.length) {
    19390           // Ignore trailing comma
    19391           if (idx > 0 && idx === body.length - 1) {
    19392             return;
    19393           }
    19394           error("E002", directiveToken);
    19395           return;
    19396         }
    19397 
    19398         if (key.charAt(0) === "-") {
    19399           key = key.slice(1);
    19400           val = false;
    19401 
    19402           JSHINT.blacklist[key] = key;
    19403           delete predefined[key];
    19404         } else {
    19405           predef[key] = (val === "true");
    19406         }
    19407       });
    19408 
    19409       combine(predefined, predef);
    19410 
    19411       for (var key in predef) {
    19412         if (_.has(predef, key)) {
    19413           declared[key] = directiveToken;
    19414         }
    19415       }
    19416     }
    19417 
    19418     if (directiveToken.type === "exported") {
    19419       body.forEach(function(e, idx) {
    19420         if (!e.length) {
    19421           // Ignore trailing comma
    19422           if (idx > 0 && idx === body.length - 1) {
    19423             return;
    19424           }
    19425           error("E002", directiveToken);
    19426           return;
    19427         }
    19428 
    19429         state.funct["(scope)"].addExported(e);
    19430       });
    19431     }
    19432 
    19433     if (directiveToken.type === "members") {
    19434       membersOnly = membersOnly || {};
    19435 
    19436       body.forEach(function(m) {
    19437         var ch1 = m.charAt(0);
    19438         var ch2 = m.charAt(m.length - 1);
    19439 
    19440         if (ch1 === ch2 && (ch1 === "\"" || ch1 === "'")) {
    19441           m = m
    19442             .substr(1, m.length - 2)
    19443             .replace("\\\"", "\"");
    19444         }
    19445 
    19446         membersOnly[m] = false;
    19447       });
    19448     }
    19449 
    19450     var numvals = [
    19451       "maxstatements",
    19452       "maxparams",
    19453       "maxdepth",
    19454       "maxcomplexity",
    19455       "maxerr",
    19456       "maxlen",
    19457       "indent"
    19458     ];
    19459 
    19460     if (directiveToken.type === "jshint" || directiveToken.type === "jslint") {
    19461       body.forEach(function(g) {
    19462         g = g.split(":");
    19463         var key = (g[0] || "").trim();
    19464         var val = (g[1] || "").trim();
    19465 
    19466         if (!checkOption(key, directiveToken)) {
    19467           return;
    19468         }
    19469 
    19470         if (numvals.indexOf(key) >= 0) {
    19471           // GH988 - numeric options can be disabled by setting them to `false`
    19472           if (val !== "false") {
    19473             val = +val;
    19474 
    19475             if (typeof val !== "number" || !isFinite(val) || val <= 0 || Math.floor(val) !== val) {
    19476               error("E032", directiveToken, g[1].trim());
    19477               return;
    19478             }
    19479 
    19480             state.option[key] = val;
    19481           } else {
    19482             state.option[key] = key === "indent" ? 4 : false;
    19483           }
    19484 
    19485           return;
    19486         }
    19487 
    19488         if (key === "validthis") {
    19489           // `validthis` is valid only within a function scope.
    19490 
    19491           if (state.funct["(global)"])
    19492             return void error("E009");
    19493 
    19494           if (val !== "true" && val !== "false")
    19495             return void error("E002", directiveToken);
    19496 
    19497           state.option.validthis = (val === "true");
    19498           return;
    19499         }
    19500 
    19501         if (key === "quotmark") {
    19502           switch (val) {
    19503           case "true":
    19504           case "false":
    19505             state.option.quotmark = (val === "true");
    19506             break;
    19507           case "double":
    19508           case "single":
    19509             state.option.quotmark = val;
    19510             break;
    19511           default:
    19512             error("E002", directiveToken);
    19513           }
    19514           return;
    19515         }
    19516 
    19517         if (key === "shadow") {
    19518           switch (val) {
    19519           case "true":
    19520             state.option.shadow = true;
    19521             break;
    19522           case "outer":
    19523             state.option.shadow = "outer";
    19524             break;
    19525           case "false":
    19526           case "inner":
    19527             state.option.shadow = "inner";
    19528             break;
    19529           default:
    19530             error("E002", directiveToken);
    19531           }
    19532           return;
    19533         }
    19534 
    19535         if (key === "unused") {
    19536           switch (val) {
    19537           case "true":
    19538             state.option.unused = true;
    19539             break;
    19540           case "false":
    19541             state.option.unused = false;
    19542             break;
    19543           case "vars":
    19544           case "strict":
    19545             state.option.unused = val;
    19546             break;
    19547           default:
    19548             error("E002", directiveToken);
    19549           }
    19550           return;
    19551         }
    19552 
    19553         if (key === "latedef") {
    19554           switch (val) {
    19555           case "true":
    19556             state.option.latedef = true;
    19557             break;
    19558           case "false":
    19559             state.option.latedef = false;
    19560             break;
    19561           case "nofunc":
    19562             state.option.latedef = "nofunc";
    19563             break;
    19564           default:
    19565             error("E002", directiveToken);
    19566           }
    19567           return;
    19568         }
    19569 
    19570         if (key === "ignore") {
    19571           switch (val) {
    19572           case "line":
    19573             state.ignoredLines[directiveToken.line] = true;
    19574             removeIgnoredMessages();
    19575             break;
    19576           default:
    19577             error("E002", directiveToken);
    19578           }
    19579           return;
    19580         }
    19581 
    19582         if (key === "strict") {
    19583           switch (val) {
    19584           case "true":
    19585             state.option.strict = true;
    19586             break;
    19587           case "false":
    19588             state.option.strict = false;
    19589             break;
    19590           case "global":
    19591           case "implied":
    19592             state.option.strict = val;
    19593             break;
    19594           default:
    19595             error("E002", directiveToken);
    19596           }
    19597           return;
    19598         }
    19599 
    19600         if (key === "module") {
    19601           /**
    19602            * TODO: Extend this restriction to *all* "environmental" options.
    19603            */
    19604           if (!hasParsedCode(state.funct)) {
    19605             error("E055", directiveToken, "module");
    19606           }
    19607         }
    19608 
    19609         if (key === "esversion") {
    19610           switch (val) {
    19611           case "3":
    19612           case "5":
    19613           case "6":
    19614           case "2015":
    19615             state.option.moz = false;
    19616             state.option.esversion = +val;
    19617             break;
    19618           default:
    19619             error("E002", directiveToken);
    19620           }
    19621           if (!hasParsedCode(state.funct)) {
    19622             error("E055", directiveToken, "esversion");
    19623           }
    19624           return;
    19625         }
    19626 
    19627         var match = /^([+-])(W\d{3})$/g.exec(key);
    19628         if (match) {
    19629           // ignore for -W..., unignore for +W...
    19630           state.ignored[match[2]] = (match[1] === "-");
    19631           return;
    19632         }
    19633 
    19634         var tn;
    19635         if (val === "true" || val === "false") {
    19636           if (directiveToken.type === "jslint") {
    19637             tn = options.renamed[key] || key;
    19638             state.option[tn] = (val === "true");
    19639 
    19640             if (options.inverted[tn] !== undefined) {
    19641               state.option[tn] = !state.option[tn];
    19642             }
    19643           } else {
    19644             state.option[key] = (val === "true");
    19645           }
    19646 
    19647           return;
    19648         }
    19649 
    19650         error("E002", directiveToken);
    19651       });
    19652 
    19653       applyOptions();
    19654     }
    19655   }
    19656 
    19657   /**
    19658    * Return a token beyond the token available in `state.tokens.next`. If no
    19659    * such token exists, return the "(end)" token. This function is used to
    19660    * determine parsing strategies in cases where the value of the next token
    19661    * does not provide sufficient information, as is the case with `for` loops,
    19662    * e.g.:
    19663    *
    19664    *     for ( var i in ...
    19665    *
    19666    * versus:
    19667    *
    19668    *     for ( var i = ...
    19669    *
    19670    * @param {number} [p] - offset of desired token; defaults to 0
    19671    *
    19672    * @returns {token}
    19673    */
    19674   function peek(p) {
    19675     var i = p || 0, j = lookahead.length, t;
    19676 
    19677     if (i < j) {
    19678       return lookahead[i];
    19679     }
    19680 
    19681     while (j <= i) {
    19682       t = lex.token();
    19683 
    19684       // When the lexer is exhausted, this function should produce the "(end)"
    19685       // token, even in cases where the requested token is beyond the end of
    19686       // the input stream.
    19687       if (!t) {
    19688         // If the lookahead buffer is empty, the expected "(end)" token was
    19689         // already emitted by the most recent invocation of `advance` and is
    19690         // available as the next token.
    19691         if (!lookahead.length) {
    19692           return state.tokens.next;
    19693         }
    19694 
    19695         return lookahead[j - 1];
    19696       }
    19697 
    19698       lookahead[j] = t;
    19699       j += 1;
    19700     }
    19701 
    19702     return t;
    19703   }
    19704 
    19705   function peekIgnoreEOL() {
    19706     var i = 0;
    19707     var t;
    19708     do {
    19709       t = peek(i++);
    19710     } while (t.id === "(endline)");
    19711     return t;
    19712   }
    19713 
    19714   // Produce the next token. It looks for programming errors.
    19715 
    19716   function advance(id, t) {
    19717 
    19718     switch (state.tokens.curr.id) {
    19719     case "(number)":
    19720       if (state.tokens.next.id === ".") {
    19721         warning("W005", state.tokens.curr);
    19722       }
    19723       break;
    19724     case "-":
    19725       if (state.tokens.next.id === "-" || state.tokens.next.id === "--") {
    19726         warning("W006");
    19727       }
    19728       break;
    19729     case "+":
    19730       if (state.tokens.next.id === "+" || state.tokens.next.id === "++") {
    19731         warning("W007");
    19732       }
    19733       break;
    19734     }
    19735 
    19736     if (id && state.tokens.next.id !== id) {
    19737       if (t) {
    19738         if (state.tokens.next.id === "(end)") {
    19739           error("E019", t, t.id);
    19740         } else {
    19741           error("E020", state.tokens.next, id, t.id, t.line, state.tokens.next.value);
    19742         }
    19743       } else if (state.tokens.next.type !== "(identifier)" || state.tokens.next.value !== id) {
    19744         warning("W116", state.tokens.next, id, state.tokens.next.value);
    19745       }
    19746     }
    19747 
    19748     state.tokens.prev = state.tokens.curr;
    19749     state.tokens.curr = state.tokens.next;
    19750     for (;;) {
    19751       state.tokens.next = lookahead.shift() || lex.token();
    19752 
    19753       if (!state.tokens.next) { // No more tokens left, give up
    19754         quit("E041", state.tokens.curr);
    19755       }
    19756 
    19757       if (state.tokens.next.id === "(end)" || state.tokens.next.id === "(error)") {
    19758         return;
    19759       }
    19760 
    19761       if (state.tokens.next.check) {
    19762         state.tokens.next.check();
    19763       }
    19764 
    19765       if (state.tokens.next.isSpecial) {
    19766         lintingDirective(state.tokens.next, state.tokens.curr);
    19767       } else {
    19768         if (state.tokens.next.id !== "(endline)") {
    19769           break;
    19770         }
    19771       }
    19772     }
    19773   }
    19774 
    19775   /**
    19776    * Determine whether a given token is an operator.
    19777    *
    19778    * @param {token} token
    19779    *
    19780    * @returns {boolean}
    19781    */
    19782   function isOperator(token) {
    19783     return token.first || token.right || token.left || token.id === "yield";
    19784   }
    19785 
    19786   function isEndOfExpr(curr, next) {
    19787     if (arguments.length === 0) {
    19788       curr = state.tokens.curr;
    19789       next = state.tokens.next;
    19790     }
    19791 
    19792     if (next.id === ";" || next.id === "}" || next.id === ":") {
    19793       return true;
    19794     }
    19795     if (next.infix === curr.infix || curr.ltBoundary === "after" ||
    19796       next.ltBoundary === "before") {
    19797       return curr.line !== startLine(next);
    19798     }
    19799     return false;
    19800   }
    19801 
    19802   // This is the heart of JSHINT, the Pratt parser. In addition to parsing, it
    19803   // is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
    19804   // like .nud except that it is only used on the first token of a statement.
    19805   // Having .fud makes it much easier to define statement-oriented languages like
    19806   // JavaScript. I retained Pratt's nomenclature.
    19807 
    19808   // .nud  Null denotation
    19809   // .fud  First null denotation
    19810   // .led  Left denotation
    19811   //  lbp  Left binding power
    19812   //  rbp  Right binding power
    19813 
    19814   // They are elements of the parsing method called Top Down Operator Precedence.
    19815 
    19816   function expression(rbp, initial) {
    19817     var left, isArray = false, isObject = false, isLetExpr = false;
    19818 
    19819     state.nameStack.push();
    19820 
    19821     // if current expression is a let expression
    19822     if (!initial && state.tokens.next.value === "let" && peek(0).value === "(") {
    19823       if (!state.inMoz()) {
    19824         warning("W118", state.tokens.next, "let expressions");
    19825       }
    19826       isLetExpr = true;
    19827       // create a new block scope we use only for the current expression
    19828       state.funct["(scope)"].stack();
    19829       advance("let");
    19830       advance("(");
    19831       state.tokens.prev.fud();
    19832       advance(")");
    19833     }
    19834 
    19835     if (state.tokens.next.id === "(end)")
    19836       error("E006", state.tokens.curr);
    19837 
    19838     var isDangerous =
    19839       state.option.asi &&
    19840       state.tokens.prev.line !== startLine(state.tokens.curr) &&
    19841       _.contains(["]", ")"], state.tokens.prev.id) &&
    19842       _.contains(["[", "("], state.tokens.curr.id);
    19843 
    19844     if (isDangerous)
    19845       warning("W014", state.tokens.curr, state.tokens.curr.id);
    19846 
    19847     advance();
    19848 
    19849     if (initial) {
    19850       state.funct["(verb)"] = state.tokens.curr.value;
    19851       state.tokens.curr.beginsStmt = true;
    19852     }
    19853 
    19854     if (initial === true && state.tokens.curr.fud) {
    19855       left = state.tokens.curr.fud();
    19856     } else {
    19857       if (state.tokens.curr.nud) {
    19858         left = state.tokens.curr.nud(rbp);
    19859       } else {
    19860         error("E030", state.tokens.curr, state.tokens.curr.id);
    19861       }
    19862 
    19863       while (rbp < state.tokens.next.lbp && !isEndOfExpr()) {
    19864         isArray = state.tokens.curr.value === "Array";
    19865         isObject = state.tokens.curr.value === "Object";
    19866 
    19867         // #527, new Foo.Array(), Foo.Array(), new Foo.Object(), Foo.Object()
    19868         // Line breaks in IfStatement heads exist to satisfy the checkJSHint
    19869         // "Line too long." error.
    19870         if (left && (left.value || (left.first && left.first.value))) {
    19871           // If the left.value is not "new", or the left.first.value is a "."
    19872           // then safely assume that this is not "new Array()" and possibly
    19873           // not "new Object()"...
    19874           if (left.value !== "new" ||
    19875             (left.first && left.first.value && left.first.value === ".")) {
    19876             isArray = false;
    19877             // ...In the case of Object, if the left.value and state.tokens.curr.value
    19878             // are not equal, then safely assume that this not "new Object()"
    19879             if (left.value !== state.tokens.curr.value) {
    19880               isObject = false;
    19881             }
    19882           }
    19883         }
    19884 
    19885         advance();
    19886 
    19887         if (isArray && state.tokens.curr.id === "(" && state.tokens.next.id === ")") {
    19888           warning("W009", state.tokens.curr);
    19889         }
    19890 
    19891         if (isObject && state.tokens.curr.id === "(" && state.tokens.next.id === ")") {
    19892           warning("W010", state.tokens.curr);
    19893         }
    19894 
    19895         if (left && state.tokens.curr.led) {
    19896           left = state.tokens.curr.led(left);
    19897         } else {
    19898           error("E033", state.tokens.curr, state.tokens.curr.id);
    19899         }
    19900       }
    19901     }
    19902     if (isLetExpr) {
    19903       state.funct["(scope)"].unstack();
    19904     }
    19905 
    19906     state.nameStack.pop();
    19907 
    19908     return left;
    19909   }
    19910 
    19911 
    19912   // Functions for conformance of style.
    19913 
    19914   function startLine(token) {
    19915     return token.startLine || token.line;
    19916   }
    19917 
    19918   function nobreaknonadjacent(left, right) {
    19919     left = left || state.tokens.curr;
    19920     right = right || state.tokens.next;
    19921     if (!state.option.laxbreak && left.line !== startLine(right)) {
    19922       warning("W014", right, right.value);
    19923     }
    19924   }
    19925 
    19926   function nolinebreak(t) {
    19927     t = t || state.tokens.curr;
    19928     if (t.line !== startLine(state.tokens.next)) {
    19929       warning("E022", t, t.value);
    19930     }
    19931   }
    19932 
    19933   function nobreakcomma(left, right) {
    19934     if (left.line !== startLine(right)) {
    19935       if (!state.option.laxcomma) {
    19936         if (parseComma.first) {
    19937           warning("I001");
    19938           parseComma.first = false;
    19939         }
    19940         warning("W014", left, right.value);
    19941       }
    19942     }
    19943   }
    19944 
    19945   function parseComma(opts) {
    19946     opts = opts || {};
    19947 
    19948     if (!opts.peek) {
    19949       nobreakcomma(state.tokens.curr, state.tokens.next);
    19950       advance(",");
    19951     } else {
    19952       nobreakcomma(state.tokens.prev, state.tokens.curr);
    19953     }
    19954 
    19955     if (state.tokens.next.identifier && !(opts.property && state.inES5())) {
    19956       // Keywords that cannot follow a comma operator.
    19957       switch (state.tokens.next.value) {
    19958       case "break":
    19959       case "case":
    19960       case "catch":
    19961       case "continue":
    19962       case "default":
    19963       case "do":
    19964       case "else":
    19965       case "finally":
    19966       case "for":
    19967       case "if":
    19968       case "in":
    19969       case "instanceof":
    19970       case "return":
    19971       case "switch":
    19972       case "throw":
    19973       case "try":
    19974       case "var":
    19975       case "let":
    19976       case "while":
    19977       case "with":
    19978         error("E024", state.tokens.next, state.tokens.next.value);
    19979         return false;
    19980       }
    19981     }
    19982 
    19983     if (state.tokens.next.type === "(punctuator)") {
    19984       switch (state.tokens.next.value) {
    19985       case "}":
    19986       case "]":
    19987       case ",":
    19988         if (opts.allowTrailing) {
    19989           return true;
    19990         }
    19991 
    19992         /* falls through */
    19993       case ")":
    19994         error("E024", state.tokens.next, state.tokens.next.value);
    19995         return false;
    19996       }
    19997     }
    19998     return true;
    19999   }
    20000 
    20001   // Functional constructors for making the symbols that will be inherited by
    20002   // tokens.
    20003 
    20004   function symbol(s, p) {
    20005     var x = state.syntax[s];
    20006     if (!x || typeof x !== "object") {
    20007       state.syntax[s] = x = {
    20008         id: s,
    20009         lbp: p,
    20010         value: s
    20011       };
    20012     }
    20013     return x;
    20014   }
    20015 
    20016   function delim(s) {
    20017     var x = symbol(s, 0);
    20018     x.delim = true;
    20019     return x;
    20020   }
    20021 
    20022   function stmt(s, f) {
    20023     var x = delim(s);
    20024     x.identifier = x.reserved = true;
    20025     x.fud = f;
    20026     return x;
    20027   }
    20028 
    20029   function blockstmt(s, f) {
    20030     var x = stmt(s, f);
    20031     x.block = true;
    20032     return x;
    20033   }
    20034 
    20035   function reserveName(x) {
    20036     var c = x.id.charAt(0);
    20037     if ((c >= "a" && c <= "z") || (c >= "A" && c <= "Z")) {
    20038       x.identifier = x.reserved = true;
    20039     }
    20040     return x;
    20041   }
    20042 
    20043   function prefix(s, f) {
    20044     var x = symbol(s, 150);
    20045     reserveName(x);
    20046 
    20047     x.nud = (typeof f === "function") ? f : function() {
    20048       this.arity = "unary";
    20049       this.right = expression(150);
    20050 
    20051       if (this.id === "++" || this.id === "--") {
    20052         if (state.option.plusplus) {
    20053           warning("W016", this, this.id);
    20054         } else if (this.right && (!this.right.identifier || isReserved(this.right)) &&
    20055             this.right.id !== "." && this.right.id !== "[") {
    20056           warning("W017", this);
    20057         }
    20058 
    20059         if (this.right && this.right.isMetaProperty) {
    20060           error("E031", this);
    20061         // detect increment/decrement of a const
    20062         // in the case of a.b, right will be the "." punctuator
    20063         } else if (this.right && this.right.identifier) {
    20064           state.funct["(scope)"].block.modify(this.right.value, this);
    20065         }
    20066       }
    20067 
    20068       return this;
    20069     };
    20070 
    20071     return x;
    20072   }
    20073 
    20074   function type(s, f) {
    20075     var x = delim(s);
    20076     x.type = s;
    20077     x.nud = f;
    20078     return x;
    20079   }
    20080 
    20081   function reserve(name, func) {
    20082     var x = type(name, func);
    20083     x.identifier = true;
    20084     x.reserved = true;
    20085     return x;
    20086   }
    20087 
    20088   function FutureReservedWord(name, meta) {
    20089     var x = type(name, (meta && meta.nud) || function() {
    20090       return this;
    20091     });
    20092 
    20093     meta = meta || {};
    20094     meta.isFutureReservedWord = true;
    20095 
    20096     x.value = name;
    20097     x.identifier = true;
    20098     x.reserved = true;
    20099     x.meta = meta;
    20100 
    20101     return x;
    20102   }
    20103 
    20104   function reservevar(s, v) {
    20105     return reserve(s, function() {
    20106       if (typeof v === "function") {
    20107         v(this);
    20108       }
    20109       return this;
    20110     });
    20111   }
    20112 
    20113   function infix(s, f, p, w) {
    20114     var x = symbol(s, p);
    20115     reserveName(x);
    20116     x.infix = true;
    20117     x.led = function(left) {
    20118       if (!w) {
    20119         nobreaknonadjacent(state.tokens.prev, state.tokens.curr);
    20120       }
    20121       if ((s === "in" || s === "instanceof") && left.id === "!") {
    20122         warning("W018", left, "!");
    20123       }
    20124       if (typeof f === "function") {
    20125         return f(left, this);
    20126       } else {
    20127         this.left = left;
    20128         this.right = expression(p);
    20129         return this;
    20130       }
    20131     };
    20132     return x;
    20133   }
    20134 
    20135   function application(s) {
    20136     var x = symbol(s, 42);
    20137 
    20138     x.infix = true;
    20139     x.led = function(left) {
    20140       nobreaknonadjacent(state.tokens.prev, state.tokens.curr);
    20141 
    20142       this.left = left;
    20143       this.right = doFunction({ type: "arrow", loneArg: left });
    20144       return this;
    20145     };
    20146     return x;
    20147   }
    20148 
    20149   function relation(s, f) {
    20150     var x = symbol(s, 100);
    20151 
    20152     x.infix = true;
    20153     x.led = function(left) {
    20154       nobreaknonadjacent(state.tokens.prev, state.tokens.curr);
    20155       this.left = left;
    20156       var right = this.right = expression(100);
    20157 
    20158       if (isIdentifier(left, "NaN") || isIdentifier(right, "NaN")) {
    20159         warning("W019", this);
    20160       } else if (f) {
    20161         f.apply(this, [left, right]);
    20162       }
    20163 
    20164       if (!left || !right) {
    20165         quit("E041", state.tokens.curr);
    20166       }
    20167 
    20168       if (left.id === "!") {
    20169         warning("W018", left, "!");
    20170       }
    20171 
    20172       if (right.id === "!") {
    20173         warning("W018", right, "!");
    20174       }
    20175 
    20176       return this;
    20177     };
    20178     return x;
    20179   }
    20180 
    20181   var typeofValues = {};
    20182   typeofValues.legacy = [
    20183     // E4X extended the `typeof` operator to return "xml" for the XML and
    20184     // XMLList types it introduced.
    20185     // Ref: 11.3.2 The typeof Operator
    20186     // http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-357.pdf
    20187     "xml",
    20188     // IE<9 reports "unknown" when the `typeof` operator is applied to an
    20189     // object existing across a COM+ bridge. In lieu of official documentation
    20190     // (which does not exist), see:
    20191     // http://robertnyman.com/2005/12/21/what-is-typeof-unknown/
    20192     "unknown"
    20193   ];
    20194   typeofValues.es3 = [
    20195     "undefined", "boolean", "number", "string", "function", "object",
    20196   ];
    20197   typeofValues.es3 = typeofValues.es3.concat(typeofValues.legacy);
    20198   typeofValues.es6 = typeofValues.es3.concat("symbol");
    20199 
    20200   // Checks whether the 'typeof' operator is used with the correct
    20201   // value. For docs on 'typeof' see:
    20202   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof
    20203   function isTypoTypeof(left, right, state) {
    20204     var values;
    20205 
    20206     if (state.option.notypeof)
    20207       return false;
    20208 
    20209     if (!left || !right)
    20210       return false;
    20211 
    20212     values = state.inES6() ? typeofValues.es6 : typeofValues.es3;
    20213 
    20214     if (right.type === "(identifier)" && right.value === "typeof" && left.type === "(string)")
    20215       return !_.contains(values, left.value);
    20216 
    20217     return false;
    20218   }
    20219 
    20220   function isGlobalEval(left, state) {
    20221     var isGlobal = false;
    20222 
    20223     // permit methods to refer to an "eval" key in their own context
    20224     if (left.type === "this" && state.funct["(context)"] === null) {
    20225       isGlobal = true;
    20226     }
    20227     // permit use of "eval" members of objects
    20228     else if (left.type === "(identifier)") {
    20229       if (state.option.node && left.value === "global") {
    20230         isGlobal = true;
    20231       }
    20232 
    20233       else if (state.option.browser && (left.value === "window" || left.value === "document")) {
    20234         isGlobal = true;
    20235       }
    20236     }
    20237 
    20238     return isGlobal;
    20239   }
    20240 
    20241   function findNativePrototype(left) {
    20242     var natives = [
    20243       "Array", "ArrayBuffer", "Boolean", "Collator", "DataView", "Date",
    20244       "DateTimeFormat", "Error", "EvalError", "Float32Array", "Float64Array",
    20245       "Function", "Infinity", "Intl", "Int16Array", "Int32Array", "Int8Array",
    20246       "Iterator", "Number", "NumberFormat", "Object", "RangeError",
    20247       "ReferenceError", "RegExp", "StopIteration", "String", "SyntaxError",
    20248       "TypeError", "Uint16Array", "Uint32Array", "Uint8Array", "Uint8ClampedArray",
    20249       "URIError"
    20250     ];
    20251 
    20252     function walkPrototype(obj) {
    20253       if (typeof obj !== "object") return;
    20254       return obj.right === "prototype" ? obj : walkPrototype(obj.left);
    20255     }
    20256 
    20257     function walkNative(obj) {
    20258       while (!obj.identifier && typeof obj.left === "object")
    20259         obj = obj.left;
    20260 
    20261       if (obj.identifier && natives.indexOf(obj.value) >= 0 &&
    20262           state.funct["(scope)"].isPredefined(obj.value)) {
    20263         return obj.value;
    20264       }
    20265     }
    20266 
    20267     var prototype = walkPrototype(left);
    20268     if (prototype) return walkNative(prototype);
    20269   }
    20270 
    20271   /**
    20272    * Checks the left hand side of an assignment for issues, returns if ok
    20273    * @param {token} left - the left hand side of the assignment
    20274    * @param {token=} assignToken - the token for the assignment, used for reporting
    20275    * @param {object=} options - optional object
    20276    * @param {boolean} options.allowDestructuring - whether to allow destructuting binding
    20277    * @returns {boolean} Whether the left hand side is OK
    20278    */
    20279   function checkLeftSideAssign(left, assignToken, options) {
    20280 
    20281     var allowDestructuring = options && options.allowDestructuring;
    20282 
    20283     assignToken = assignToken || left;
    20284 
    20285     if (state.option.freeze) {
    20286       var nativeObject = findNativePrototype(left);
    20287       if (nativeObject)
    20288         warning("W121", left, nativeObject);
    20289     }
    20290     if (checkPunctuator(left, "...")) {
    20291       left = left.right;
    20292     }
    20293 
    20294     if (left.identifier && !left.isMetaProperty) {
    20295       // reassign also calls modify
    20296       // but we are specific in order to catch function re-assignment
    20297       // and globals re-assignment
    20298       state.funct["(scope)"].block.reassign(left.value, left);
    20299     }
    20300 
    20301     if (left.id === ".") {
    20302       if (!left.left || left.left.value === "arguments" && !state.isStrict()) {
    20303         warning("E031", assignToken);
    20304       }
    20305 
    20306       state.nameStack.set(state.tokens.prev);
    20307       return true;
    20308     } else if (left.id === "{" || left.id === "[") {
    20309       if (!allowDestructuring || !left.destructAssign) {
    20310         if (left.id === "{" || !left.left) {
    20311           warning("E031", assignToken);
    20312         } else if (left.left.value === "arguments" && !state.isStrict()) {
    20313           warning("E031", assignToken);
    20314         }
    20315       }
    20316 
    20317       if (left.id === "[") {
    20318         state.nameStack.set(left.right);
    20319       }
    20320 
    20321       return true;
    20322     } else if (left.identifier && !isReserved(left) && !left.isMetaProperty) {
    20323       if (state.funct["(scope)"].labeltype(left.value) === "exception") {
    20324         warning("W022", left);
    20325       }
    20326       state.nameStack.set(left);
    20327       return true;
    20328     }
    20329 
    20330     if (left === state.syntax["function"]) {
    20331       warning("W023", state.tokens.curr);
    20332     } else {
    20333       error("E031", assignToken);
    20334     }
    20335 
    20336     return false;
    20337   }
    20338 
    20339   function assignop(s, f, p) {
    20340     var x = infix(s, typeof f === "function" ? f : function(left, that) {
    20341       that.left = left;
    20342 
    20343       checkLeftSideAssign(left, that, { allowDestructuring: true });
    20344 
    20345       that.right = expression(10);
    20346 
    20347       return that;
    20348     }, p);
    20349 
    20350     x.exps = true;
    20351     x.assign = true;
    20352     return x;
    20353   }
    20354 
    20355 
    20356   function bitwise(s, f, p) {
    20357     var x = symbol(s, p);
    20358     reserveName(x);
    20359     x.infix = true;
    20360     x.led = (typeof f === "function") ? f : function(left) {
    20361       if (state.option.bitwise) {
    20362         warning("W016", this, this.id);
    20363       }
    20364       this.left = left;
    20365       this.right = expression(p);
    20366       return this;
    20367     };
    20368     return x;
    20369   }
    20370 
    20371   function bitwiseassignop(s) {
    20372     return assignop(s, function(left, that) {
    20373       if (state.option.bitwise) {
    20374         warning("W016", that, that.id);
    20375       }
    20376 
    20377       checkLeftSideAssign(left, that);
    20378 
    20379       that.right = expression(10);
    20380 
    20381       return that;
    20382     }, 20);
    20383   }
    20384 
    20385   function suffix(s) {
    20386     var x = symbol(s, 150);
    20387 
    20388     x.led = function(left) {
    20389       // this = suffix e.g. "++" punctuator
    20390       // left = symbol operated e.g. "a" identifier or "a.b" punctuator
    20391       if (state.option.plusplus) {
    20392         warning("W016", this, this.id);
    20393       } else if ((!left.identifier || isReserved(left)) && left.id !== "." && left.id !== "[") {
    20394         warning("W017", this);
    20395       }
    20396 
    20397       if (left.isMetaProperty) {
    20398         error("E031", this);
    20399       // detect increment/decrement of a const
    20400       // in the case of a.b, left will be the "." punctuator
    20401       } else if (left && left.identifier) {
    20402         state.funct["(scope)"].block.modify(left.value, left);
    20403       }
    20404 
    20405       this.left = left;
    20406       return this;
    20407     };
    20408     return x;
    20409   }
    20410 
    20411   // fnparam means that this identifier is being defined as a function
    20412   // argument (see identifier())
    20413   // prop means that this identifier is that of an object property
    20414 
    20415   function optionalidentifier(fnparam, prop, preserve) {
    20416     if (!state.tokens.next.identifier) {
    20417       return;
    20418     }
    20419 
    20420     if (!preserve) {
    20421       advance();
    20422     }
    20423 
    20424     var curr = state.tokens.curr;
    20425     var val  = state.tokens.curr.value;
    20426 
    20427     if (!isReserved(curr)) {
    20428       return val;
    20429     }
    20430 
    20431     if (prop) {
    20432       if (state.inES5()) {
    20433         return val;
    20434       }
    20435     }
    20436 
    20437     if (fnparam && val === "undefined") {
    20438       return val;
    20439     }
    20440 
    20441     warning("W024", state.tokens.curr, state.tokens.curr.id);
    20442     return val;
    20443   }
    20444 
    20445   // fnparam means that this identifier is being defined as a function
    20446   // argument
    20447   // prop means that this identifier is that of an object property
    20448   function identifier(fnparam, prop) {
    20449     var i = optionalidentifier(fnparam, prop, false);
    20450     if (i) {
    20451       return i;
    20452     }
    20453 
    20454     // parameter destructuring with rest operator
    20455     if (state.tokens.next.value === "...") {
    20456       if (!state.inES6(true)) {
    20457         warning("W119", state.tokens.next, "spread/rest operator", "6");
    20458       }
    20459       advance();
    20460 
    20461       if (checkPunctuator(state.tokens.next, "...")) {
    20462         warning("E024", state.tokens.next, "...");
    20463         while (checkPunctuator(state.tokens.next, "...")) {
    20464           advance();
    20465         }
    20466       }
    20467 
    20468       if (!state.tokens.next.identifier) {
    20469         warning("E024", state.tokens.curr, state.tokens.next.id);
    20470         return;
    20471       }
    20472 
    20473       return identifier(fnparam, prop);
    20474     } else {
    20475       error("E030", state.tokens.next, state.tokens.next.value);
    20476 
    20477       // The token should be consumed after a warning is issued so the parser
    20478       // can continue as though an identifier were found. The semicolon token
    20479       // should not be consumed in this way so that the parser interprets it as
    20480       // a statement delimeter;
    20481       if (state.tokens.next.id !== ";") {
    20482         advance();
    20483       }
    20484     }
    20485   }
    20486 
    20487 
    20488   function reachable(controlToken) {
    20489     var i = 0, t;
    20490     if (state.tokens.next.id !== ";" || controlToken.inBracelessBlock) {
    20491       return;
    20492     }
    20493     for (;;) {
    20494       do {
    20495         t = peek(i);
    20496         i += 1;
    20497       } while (t.id !== "(end)" && t.id === "(comment)");
    20498 
    20499       if (t.reach) {
    20500         return;
    20501       }
    20502       if (t.id !== "(endline)") {
    20503         if (t.id === "function") {
    20504           if (state.option.latedef === true) {
    20505             warning("W026", t);
    20506           }
    20507           break;
    20508         }
    20509 
    20510         warning("W027", t, t.value, controlToken.value);
    20511         break;
    20512       }
    20513     }
    20514   }
    20515 
    20516   /**
    20517    * Consume the semicolon that delimits the statement currently being parsed,
    20518    * emitting relevant warnings/errors as appropriate.
    20519    *
    20520    * @param {token} stmt - token describing the statement under consideration
    20521    */
    20522   function parseFinalSemicolon(stmt) {
    20523     if (state.tokens.next.id !== ";") {
    20524       // don't complain about unclosed templates / strings
    20525       if (state.tokens.next.isUnclosed) return advance();
    20526 
    20527       var sameLine = startLine(state.tokens.next) === state.tokens.curr.line &&
    20528                      state.tokens.next.id !== "(end)";
    20529       var blockEnd = checkPunctuator(state.tokens.next, "}");
    20530 
    20531       if (sameLine && !blockEnd && !(stmt.id === "do" && state.inES6(true))) {
    20532         errorAt("E058", state.tokens.curr.line, state.tokens.curr.character);
    20533       } else if (!state.option.asi) {
    20534         // If this is the last statement in a block that ends on
    20535         // the same line *and* option lastsemic is on, ignore the warning.
    20536         // Otherwise, complain about missing semicolon.
    20537         if (!(blockEnd && sameLine && state.option.lastsemic)) {
    20538           warningAt("W033", state.tokens.curr.line, state.tokens.curr.character);
    20539         }
    20540       }
    20541     } else {
    20542       advance(";");
    20543     }
    20544   }
    20545 
    20546   function statement() {
    20547     var i = indent, r, t = state.tokens.next, hasOwnScope = false;
    20548 
    20549     if (t.id === ";") {
    20550       advance(";");
    20551       return;
    20552     }
    20553 
    20554     // Is this a labelled statement?
    20555     var res = isReserved(t);
    20556 
    20557     // We're being more tolerant here: if someone uses
    20558     // a FutureReservedWord as a label, we warn but proceed
    20559     // anyway.
    20560 
    20561     if (res && t.meta && t.meta.isFutureReservedWord && peek().id === ":") {
    20562       warning("W024", t, t.id);
    20563       res = false;
    20564     }
    20565 
    20566     if (t.identifier && !res && peek().id === ":") {
    20567       advance();
    20568       advance(":");
    20569 
    20570       hasOwnScope = true;
    20571       state.funct["(scope)"].stack();
    20572       state.funct["(scope)"].block.addBreakLabel(t.value, { token: state.tokens.curr });
    20573 
    20574       if (!state.tokens.next.labelled && state.tokens.next.value !== "{") {
    20575         warning("W028", state.tokens.next, t.value, state.tokens.next.value);
    20576       }
    20577 
    20578       state.tokens.next.label = t.value;
    20579       t = state.tokens.next;
    20580     }
    20581 
    20582     // Is it a lonely block?
    20583 
    20584     if (t.id === "{") {
    20585       // Is it a switch case block?
    20586       //
    20587       //  switch (foo) {
    20588       //    case bar: { <= here.
    20589       //      ...
    20590       //    }
    20591       //  }
    20592       var iscase = (state.funct["(verb)"] === "case" && state.tokens.curr.value === ":");
    20593       block(true, true, false, false, iscase);
    20594 
    20595       if (hasOwnScope) {
    20596         state.funct["(scope)"].unstack();
    20597       }
    20598 
    20599       return;
    20600     }
    20601 
    20602     // Parse the statement.
    20603 
    20604     r = expression(0, true);
    20605 
    20606     if (r && !(r.identifier && r.value === "function") &&
    20607         !(r.type === "(punctuator)" && r.left &&
    20608           r.left.identifier && r.left.value === "function")) {
    20609       if (!state.isStrict() && state.stmtMissingStrict()) {
    20610         warning("E007");
    20611       }
    20612     }
    20613 
    20614     // Look for the final semicolon.
    20615 
    20616     if (!t.block) {
    20617       if (!state.option.expr && (!r || !r.exps)) {
    20618         warning("W030", state.tokens.curr);
    20619       } else if (state.option.nonew && r && r.left && r.id === "(" && r.left.id === "new") {
    20620         warning("W031", t);
    20621       }
    20622       parseFinalSemicolon(t);
    20623     }
    20624 
    20625 
    20626     // Restore the indentation.
    20627 
    20628     indent = i;
    20629     if (hasOwnScope) {
    20630       state.funct["(scope)"].unstack();
    20631     }
    20632     return r;
    20633   }
    20634 
    20635 
    20636   function statements() {
    20637     var a = [], p;
    20638 
    20639     while (!state.tokens.next.reach && state.tokens.next.id !== "(end)") {
    20640       if (state.tokens.next.id === ";") {
    20641         p = peek();
    20642 
    20643         if (!p || (p.id !== "(" && p.id !== "[")) {
    20644           warning("W032");
    20645         }
    20646 
    20647         advance(";");
    20648       } else {
    20649         a.push(statement());
    20650       }
    20651     }
    20652     return a;
    20653   }
    20654 
    20655 
    20656   /*
    20657    * read all directives
    20658    */
    20659   function directives() {
    20660     var current = state.tokens.next;
    20661     while (state.tokens.next.id === "(string)") {
    20662       var next = peekIgnoreEOL();
    20663       if (!isEndOfExpr(current, next)) {
    20664         break;
    20665       }
    20666       current = next;
    20667 
    20668       advance();
    20669       var directive = state.tokens.curr.value;
    20670       if (state.directive[directive] ||
    20671           (directive === "use strict" && state.option.strict === "implied")) {
    20672         warning("W034", state.tokens.curr, directive);
    20673       }
    20674 
    20675       // there's no directive negation, so always set to true
    20676       state.directive[directive] = true;
    20677 
    20678       parseFinalSemicolon(current);
    20679     }
    20680 
    20681     if (state.isStrict()) {
    20682       state.option.undef = true;
    20683     }
    20684   }
    20685 
    20686 
    20687   /*
    20688    * Parses a single block. A block is a sequence of statements wrapped in
    20689    * braces.
    20690    *
    20691    * ordinary   - true for everything but function bodies and try blocks.
    20692    * stmt       - true if block can be a single statement (e.g. in if/for/while).
    20693    * isfunc     - true if block is a function body
    20694    * isfatarrow - true if its a body of a fat arrow function
    20695    * iscase      - true if block is a switch case block
    20696    */
    20697   function block(ordinary, stmt, isfunc, isfatarrow, iscase) {
    20698     var a,
    20699       b = inblock,
    20700       old_indent = indent,
    20701       m,
    20702       t,
    20703       line,
    20704       d;
    20705 
    20706     inblock = ordinary;
    20707 
    20708     t = state.tokens.next;
    20709 
    20710     var metrics = state.funct["(metrics)"];
    20711     metrics.nestedBlockDepth += 1;
    20712     metrics.verifyMaxNestedBlockDepthPerFunction();
    20713 
    20714     if (state.tokens.next.id === "{") {
    20715       advance("{");
    20716 
    20717       // create a new block scope
    20718       state.funct["(scope)"].stack();
    20719       state.funct["(noblockscopedvar)"] = false;
    20720 
    20721       line = state.tokens.curr.line;
    20722       if (state.tokens.next.id !== "}") {
    20723         indent += state.option.indent;
    20724         while (!ordinary && state.tokens.next.from > indent) {
    20725           indent += state.option.indent;
    20726         }
    20727 
    20728         if (isfunc) {
    20729           m = {};
    20730           for (d in state.directive) {
    20731             if (_.has(state.directive, d)) {
    20732               m[d] = state.directive[d];
    20733             }
    20734           }
    20735           directives();
    20736 
    20737           if (state.option.strict && state.funct["(context)"]["(global)"]) {
    20738             if (!m["use strict"] && !state.isStrict()) {
    20739               warning("E007");
    20740             }
    20741           }
    20742         }
    20743 
    20744         a = statements();
    20745 
    20746         metrics.statementCount += a.length;
    20747 
    20748         indent -= state.option.indent;
    20749       }
    20750 
    20751       advance("}", t);
    20752 
    20753       if (isfunc) {
    20754         state.funct["(scope)"].validateParams();
    20755         if (m) {
    20756           state.directive = m;
    20757         }
    20758       }
    20759 
    20760       state.funct["(scope)"].unstack();
    20761 
    20762       indent = old_indent;
    20763     } else if (!ordinary) {
    20764       if (isfunc) {
    20765         state.funct["(scope)"].stack();
    20766 
    20767         m = {};
    20768         if (stmt && !isfatarrow && !state.inMoz()) {
    20769           error("W118", state.tokens.curr, "function closure expressions");
    20770         }
    20771 
    20772         if (!stmt) {
    20773           for (d in state.directive) {
    20774             if (_.has(state.directive, d)) {
    20775               m[d] = state.directive[d];
    20776             }
    20777           }
    20778         }
    20779         expression(10);
    20780 
    20781         if (state.option.strict && state.funct["(context)"]["(global)"]) {
    20782           if (!m["use strict"] && !state.isStrict()) {
    20783             warning("E007");
    20784           }
    20785         }
    20786 
    20787         state.funct["(scope)"].unstack();
    20788       } else {
    20789         error("E021", state.tokens.next, "{", state.tokens.next.value);
    20790       }
    20791     } else {
    20792 
    20793       // check to avoid let declaration not within a block
    20794       // though is fine inside for loop initializer section
    20795       state.funct["(noblockscopedvar)"] = state.tokens.next.id !== "for";
    20796       state.funct["(scope)"].stack();
    20797 
    20798       if (!stmt || state.option.curly) {
    20799         warning("W116", state.tokens.next, "{", state.tokens.next.value);
    20800       }
    20801 
    20802       state.tokens.next.inBracelessBlock = true;
    20803       indent += state.option.indent;
    20804       // test indentation only if statement is in new line
    20805       a = [statement()];
    20806       indent -= state.option.indent;
    20807 
    20808       state.funct["(scope)"].unstack();
    20809       delete state.funct["(noblockscopedvar)"];
    20810     }
    20811 
    20812     // Don't clear and let it propagate out if it is "break", "return" or similar in switch case
    20813     switch (state.funct["(verb)"]) {
    20814     case "break":
    20815     case "continue":
    20816     case "return":
    20817     case "throw":
    20818       if (iscase) {
    20819         break;
    20820       }
    20821 
    20822       /* falls through */
    20823     default:
    20824       state.funct["(verb)"] = null;
    20825     }
    20826 
    20827     inblock = b;
    20828     if (ordinary && state.option.noempty && (!a || a.length === 0)) {
    20829       warning("W035", state.tokens.prev);
    20830     }
    20831     metrics.nestedBlockDepth -= 1;
    20832     return a;
    20833   }
    20834 
    20835 
    20836   function countMember(m) {
    20837     if (membersOnly && typeof membersOnly[m] !== "boolean") {
    20838       warning("W036", state.tokens.curr, m);
    20839     }
    20840     if (typeof member[m] === "number") {
    20841       member[m] += 1;
    20842     } else {
    20843       member[m] = 1;
    20844     }
    20845   }
    20846 
    20847   // Build the syntax table by declaring the syntactic elements of the language.
    20848 
    20849   type("(number)", function() {
    20850     return this;
    20851   });
    20852 
    20853   type("(string)", function() {
    20854     return this;
    20855   });
    20856 
    20857   state.syntax["(identifier)"] = {
    20858     type: "(identifier)",
    20859     lbp: 0,
    20860     identifier: true,
    20861 
    20862     nud: function() {
    20863       var v = this.value;
    20864 
    20865       // If this identifier is the lone parameter to a shorthand "fat arrow"
    20866       // function definition, i.e.
    20867       //
    20868       //     x => x;
    20869       //
    20870       // ...it should not be considered as a variable in the current scope. It
    20871       // will be added to the scope of the new function when the next token is
    20872       // parsed, so it can be safely ignored for now.
    20873       if (state.tokens.next.id === "=>") {
    20874         return this;
    20875       }
    20876 
    20877       if (!state.funct["(comparray)"].check(v)) {
    20878         state.funct["(scope)"].block.use(v, state.tokens.curr);
    20879       }
    20880       return this;
    20881     },
    20882 
    20883     led: function() {
    20884       error("E033", state.tokens.next, state.tokens.next.value);
    20885     }
    20886   };
    20887 
    20888   var baseTemplateSyntax = {
    20889     identifier: false,
    20890     template: true,
    20891   };
    20892   state.syntax["(template)"] = _.extend({
    20893     lbp: 155,
    20894     type: "(template)",
    20895     nud: doTemplateLiteral,
    20896     led: doTemplateLiteral,
    20897     noSubst: false
    20898   }, baseTemplateSyntax);
    20899 
    20900   state.syntax["(template middle)"] = _.extend({
    20901     lbp: 0,
    20902     type: "(template middle)",
    20903     middle: true,
    20904     noSubst: false
    20905   }, baseTemplateSyntax);
    20906 
    20907   state.syntax["(template tail)"] = _.extend({
    20908     lbp: 0,
    20909     type: "(template tail)",
    20910     tail: true,
    20911     noSubst: false
    20912   }, baseTemplateSyntax);
    20913 
    20914   state.syntax["(no subst template)"] = _.extend({
    20915     lbp: 155,
    20916     type: "(template)",
    20917     nud: doTemplateLiteral,
    20918     led: doTemplateLiteral,
    20919     noSubst: true,
    20920     tail: true // mark as tail, since it's always the last component
    20921   }, baseTemplateSyntax);
    20922 
    20923   type("(regexp)", function() {
    20924     return this;
    20925   });
    20926 
    20927   // ECMAScript parser
    20928 
    20929   delim("(endline)");
    20930   (function(x) {
    20931     x.line = x.from = 0;
    20932   })(delim("(begin)"));
    20933   delim("(end)").reach = true;
    20934   delim("(error)").reach = true;
    20935   delim("}").reach = true;
    20936   delim(")");
    20937   delim("]");
    20938   delim("\"").reach = true;
    20939   delim("'").reach = true;
    20940   delim(";");
    20941   delim(":").reach = true;
    20942   delim("#");
    20943 
    20944   reserve("else");
    20945   reserve("case").reach = true;
    20946   reserve("catch");
    20947   reserve("default").reach = true;
    20948   reserve("finally");
    20949   reservevar("arguments", function(x) {
    20950     if (state.isStrict() && state.funct["(global)"]) {
    20951       warning("E008", x);
    20952     }
    20953   });
    20954   reservevar("eval");
    20955   reservevar("false");
    20956   reservevar("Infinity");
    20957   reservevar("null");
    20958   reservevar("this", function(x) {
    20959     if (state.isStrict() && !isMethod() &&
    20960         !state.option.validthis && ((state.funct["(statement)"] &&
    20961         state.funct["(name)"].charAt(0) > "Z") || state.funct["(global)"])) {
    20962       warning("W040", x);
    20963     }
    20964   });
    20965   reservevar("true");
    20966   reservevar("undefined");
    20967 
    20968   assignop("=", "assign", 20);
    20969   assignop("+=", "assignadd", 20);
    20970   assignop("-=", "assignsub", 20);
    20971   assignop("*=", "assignmult", 20);
    20972   assignop("/=", "assigndiv", 20).nud = function() {
    20973     error("E014");
    20974   };
    20975   assignop("%=", "assignmod", 20);
    20976 
    20977   bitwiseassignop("&=");
    20978   bitwiseassignop("|=");
    20979   bitwiseassignop("^=");
    20980   bitwiseassignop("<<=");
    20981   bitwiseassignop(">>=");
    20982   bitwiseassignop(">>>=");
    20983   infix(",", function(left, that) {
    20984     var expr;
    20985     that.exprs = [left];
    20986 
    20987     if (state.option.nocomma) {
    20988       warning("W127");
    20989     }
    20990 
    20991     if (!parseComma({ peek: true })) {
    20992       return that;
    20993     }
    20994     while (true) {
    20995       if (!(expr = expression(10))) {
    20996         break;
    20997       }
    20998       that.exprs.push(expr);
    20999       if (state.tokens.next.value !== "," || !parseComma()) {
    21000         break;
    21001       }
    21002     }
    21003     return that;
    21004   }, 10, true);
    21005 
    21006   infix("?", function(left, that) {
    21007     increaseComplexityCount();
    21008     that.left = left;
    21009     that.right = expression(10);
    21010     advance(":");
    21011     that["else"] = expression(10);
    21012     return that;
    21013   }, 30);
    21014 
    21015   var orPrecendence = 40;
    21016   infix("||", function(left, that) {
    21017     increaseComplexityCount();
    21018     that.left = left;
    21019     that.right = expression(orPrecendence);
    21020     return that;
    21021   }, orPrecendence);
    21022   infix("&&", "and", 50);
    21023   bitwise("|", "bitor", 70);
    21024   bitwise("^", "bitxor", 80);
    21025   bitwise("&", "bitand", 90);
    21026   relation("==", function(left, right) {
    21027     var eqnull = state.option.eqnull &&
    21028       ((left && left.value) === "null" || (right && right.value) === "null");
    21029 
    21030     switch (true) {
    21031       case !eqnull && state.option.eqeqeq:
    21032         this.from = this.character;
    21033         warning("W116", this, "===", "==");
    21034         break;
    21035       case isTypoTypeof(right, left, state):
    21036         warning("W122", this, right.value);
    21037         break;
    21038       case isTypoTypeof(left, right, state):
    21039         warning("W122", this, left.value);
    21040         break;
    21041     }
    21042 
    21043     return this;
    21044   });
    21045   relation("===", function(left, right) {
    21046     if (isTypoTypeof(right, left, state)) {
    21047       warning("W122", this, right.value);
    21048     } else if (isTypoTypeof(left, right, state)) {
    21049       warning("W122", this, left.value);
    21050     }
    21051     return this;
    21052   });
    21053   relation("!=", function(left, right) {
    21054     var eqnull = state.option.eqnull &&
    21055         ((left && left.value) === "null" || (right && right.value) === "null");
    21056 
    21057     if (!eqnull && state.option.eqeqeq) {
    21058       this.from = this.character;
    21059       warning("W116", this, "!==", "!=");
    21060     } else if (isTypoTypeof(right, left, state)) {
    21061       warning("W122", this, right.value);
    21062     } else if (isTypoTypeof(left, right, state)) {
    21063       warning("W122", this, left.value);
    21064     }
    21065     return this;
    21066   });
    21067   relation("!==", function(left, right) {
    21068     if (isTypoTypeof(right, left, state)) {
    21069       warning("W122", this, right.value);
    21070     } else if (isTypoTypeof(left, right, state)) {
    21071       warning("W122", this, left.value);
    21072     }
    21073     return this;
    21074   });
    21075   relation("<");
    21076   relation(">");
    21077   relation("<=");
    21078   relation(">=");
    21079   bitwise("<<", "shiftleft", 120);
    21080   bitwise(">>", "shiftright", 120);
    21081   bitwise(">>>", "shiftrightunsigned", 120);
    21082   infix("in", "in", 120);
    21083   infix("instanceof", function(left, token) {
    21084     var right;
    21085     var scope = state.funct["(scope)"];
    21086     token.left = left;
    21087     token.right = right = expression(120);
    21088 
    21089     // This condition reflects a syntax error which will be reported by the
    21090     // `expression` function.
    21091     if (!right) {
    21092       return token;
    21093     }
    21094 
    21095     if (right.id === "(number)" ||
    21096         right.id === "(string)" ||
    21097         right.value === "null" ||
    21098         (right.value === "undefined" && !scope.has("undefined")) ||
    21099         right.arity === "unary" ||
    21100         right.id === "{" ||
    21101         (right.id === "[" && !right.right) ||
    21102         right.id === "(regexp)" ||
    21103         (right.id === "(template)" && !right.tag)) {
    21104       error("E060");
    21105     }
    21106 
    21107     if (right.id === "function") {
    21108       warning("W139");
    21109     }
    21110 
    21111     return token;
    21112   }, 120);
    21113   infix("+", function(left, that) {
    21114     var right;
    21115     that.left = left;
    21116     that.right = right = expression(130);
    21117 
    21118     if (left && right && left.id === "(string)" && right.id === "(string)") {
    21119       left.value += right.value;
    21120       left.character = right.character;
    21121       if (!state.option.scripturl && reg.javascriptURL.test(left.value)) {
    21122         warning("W050", left);
    21123       }
    21124       return left;
    21125     }
    21126 
    21127     return that;
    21128   }, 130);
    21129   prefix("+", "num");
    21130   prefix("+++", function() {
    21131     warning("W007");
    21132     this.arity = "unary";
    21133     this.right = expression(150);
    21134     return this;
    21135   });
    21136   infix("+++", function(left) {
    21137     warning("W007");
    21138     this.left = left;
    21139     this.right = expression(130);
    21140     return this;
    21141   }, 130);
    21142   infix("-", "sub", 130);
    21143   prefix("-", "neg");
    21144   prefix("---", function() {
    21145     warning("W006");
    21146     this.arity = "unary";
    21147     this.right = expression(150);
    21148     return this;
    21149   });
    21150   infix("---", function(left) {
    21151     warning("W006");
    21152     this.left = left;
    21153     this.right = expression(130);
    21154     return this;
    21155   }, 130);
    21156   infix("*", "mult", 140);
    21157   infix("/", "div", 140);
    21158   infix("%", "mod", 140);
    21159 
    21160   suffix("++");
    21161   prefix("++", "preinc");
    21162   state.syntax["++"].exps = true;
    21163   state.syntax["++"].ltBoundary = "before";
    21164 
    21165   suffix("--");
    21166   prefix("--", "predec");
    21167   state.syntax["--"].exps = true;
    21168   state.syntax["--"].ltBoundary = "before";
    21169 
    21170   prefix("delete", function() {
    21171     var p = expression(10);
    21172     if (!p) {
    21173       return this;
    21174     }
    21175 
    21176     if (p.id !== "." && p.id !== "[") {
    21177       warning("W051");
    21178     }
    21179     this.first = p;
    21180 
    21181     // The `delete` operator accepts unresolvable references when not in strict
    21182     // mode, so the operand may be undefined.
    21183     if (p.identifier && !state.isStrict()) {
    21184       p.forgiveUndef = true;
    21185     }
    21186     return this;
    21187   }).exps = true;
    21188 
    21189   prefix("~", function() {
    21190     if (state.option.bitwise) {
    21191       warning("W016", this, "~");
    21192     }
    21193     this.arity = "unary";
    21194     this.right = expression(150);
    21195     return this;
    21196   });
    21197 
    21198   prefix("...", function() {
    21199     if (!state.inES6(true)) {
    21200       warning("W119", this, "spread/rest operator", "6");
    21201     }
    21202 
    21203     // TODO: Allow all AssignmentExpression
    21204     // once parsing permits.
    21205     //
    21206     // How to handle eg. number, boolean when the built-in
    21207     // prototype of may have an @@iterator definition?
    21208     //
    21209     // Number.prototype[Symbol.iterator] = function * () {
    21210     //   yield this.valueOf();
    21211     // };
    21212     //
    21213     // var a = [ ...1 ];
    21214     // console.log(a); // [1];
    21215     //
    21216     // for (let n of [...10]) {
    21217     //    console.log(n);
    21218     // }
    21219     // // 10
    21220     //
    21221     //
    21222     // Boolean.prototype[Symbol.iterator] = function * () {
    21223     //   yield this.valueOf();
    21224     // };
    21225     //
    21226     // var a = [ ...true ];
    21227     // console.log(a); // [true];
    21228     //
    21229     // for (let n of [...false]) {
    21230     //    console.log(n);
    21231     // }
    21232     // // false
    21233     //
    21234     if (!state.tokens.next.identifier &&
    21235         state.tokens.next.type !== "(string)" &&
    21236           !checkPunctuators(state.tokens.next, ["[", "("])) {
    21237 
    21238       error("E030", state.tokens.next, state.tokens.next.value);
    21239     }
    21240     this.right = expression(150);
    21241     return this;
    21242   });
    21243 
    21244   prefix("!", function() {
    21245     this.arity = "unary";
    21246     this.right = expression(150);
    21247 
    21248     if (!this.right) { // '!' followed by nothing? Give up.
    21249       quit("E041", this);
    21250     }
    21251 
    21252     if (bang[this.right.id] === true) {
    21253       warning("W018", this, "!");
    21254     }
    21255     return this;
    21256   });
    21257 
    21258   prefix("typeof", (function() {
    21259     var p = expression(150);
    21260     this.first = this.right = p;
    21261 
    21262     if (!p) { // 'typeof' followed by nothing? Give up.
    21263       quit("E041", this);
    21264     }
    21265 
    21266     // The `typeof` operator accepts unresolvable references, so the operand
    21267     // may be undefined.
    21268     if (p.identifier) {
    21269       p.forgiveUndef = true;
    21270     }
    21271     return this;
    21272   }));
    21273   prefix("new", function() {
    21274     var mp = metaProperty("target", function() {
    21275       if (!state.inES6(true)) {
    21276         warning("W119", state.tokens.prev, "new.target", "6");
    21277       }
    21278       var inFunction, c = state.funct;
    21279       while (c) {
    21280         inFunction = !c["(global)"];
    21281         if (!c["(arrow)"]) { break; }
    21282         c = c["(context)"];
    21283       }
    21284       if (!inFunction) {
    21285         warning("W136", state.tokens.prev, "new.target");
    21286       }
    21287     });
    21288     if (mp) { return mp; }
    21289 
    21290     var c = expression(155), i;
    21291     if (c && c.id !== "function") {
    21292       if (c.identifier) {
    21293         c["new"] = true;
    21294         switch (c.value) {
    21295         case "Number":
    21296         case "String":
    21297         case "Boolean":
    21298         case "Math":
    21299         case "JSON":
    21300           warning("W053", state.tokens.prev, c.value);
    21301           break;
    21302         case "Symbol":
    21303           if (state.inES6()) {
    21304             warning("W053", state.tokens.prev, c.value);
    21305           }
    21306           break;
    21307         case "Function":
    21308           if (!state.option.evil) {
    21309             warning("W054");
    21310           }
    21311           break;
    21312         case "Date":
    21313         case "RegExp":
    21314         case "this":
    21315           break;
    21316         default:
    21317           if (c.id !== "function") {
    21318             i = c.value.substr(0, 1);
    21319             if (state.option.newcap && (i < "A" || i > "Z") &&
    21320               !state.funct["(scope)"].isPredefined(c.value)) {
    21321               warning("W055", state.tokens.curr);
    21322             }
    21323           }
    21324         }
    21325       } else {
    21326         if (c.id !== "." && c.id !== "[" && c.id !== "(") {
    21327           warning("W056", state.tokens.curr);
    21328         }
    21329       }
    21330     } else {
    21331       if (!state.option.supernew)
    21332         warning("W057", this);
    21333     }
    21334     if (state.tokens.next.id !== "(" && !state.option.supernew) {
    21335       warning("W058", state.tokens.curr, state.tokens.curr.value);
    21336     }
    21337     this.first = this.right = c;
    21338     return this;
    21339   });
    21340   state.syntax["new"].exps = true;
    21341 
    21342   prefix("void").exps = true;
    21343 
    21344   infix(".", function(left, that) {
    21345     var m = identifier(false, true);
    21346 
    21347     if (typeof m === "string") {
    21348       countMember(m);
    21349     }
    21350 
    21351     that.left = left;
    21352     that.right = m;
    21353 
    21354     if (m && m === "hasOwnProperty" && state.tokens.next.value === "=") {
    21355       warning("W001");
    21356     }
    21357 
    21358     if (left && left.value === "arguments" && (m === "callee" || m === "caller")) {
    21359       if (state.option.noarg)
    21360         warning("W059", left, m);
    21361       else if (state.isStrict())
    21362         error("E008");
    21363     } else if (!state.option.evil && left && left.value === "document" &&
    21364         (m === "write" || m === "writeln")) {
    21365       warning("W060", left);
    21366     }
    21367 
    21368     if (!state.option.evil && (m === "eval" || m === "execScript")) {
    21369       if (isGlobalEval(left, state)) {
    21370         warning("W061");
    21371       }
    21372     }
    21373 
    21374     return that;
    21375   }, 160, true);
    21376 
    21377   infix("(", function(left, that) {
    21378     if (state.option.immed && left && !left.immed && left.id === "function") {
    21379       warning("W062");
    21380     }
    21381 
    21382     var n = 0;
    21383     var p = [];
    21384 
    21385     if (left) {
    21386       if (left.type === "(identifier)") {
    21387         if (left.value.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
    21388           if ("Array Number String Boolean Date Object Error Symbol".indexOf(left.value) === -1) {
    21389             if (left.value === "Math") {
    21390               warning("W063", left);
    21391             } else if (state.option.newcap) {
    21392               warning("W064", left);
    21393             }
    21394           }
    21395         }
    21396       }
    21397     }
    21398 
    21399     if (state.tokens.next.id !== ")") {
    21400       for (;;) {
    21401         p[p.length] = expression(10);
    21402         n += 1;
    21403         if (state.tokens.next.id !== ",") {
    21404           break;
    21405         }
    21406         parseComma();
    21407       }
    21408     }
    21409 
    21410     advance(")");
    21411 
    21412     if (typeof left === "object") {
    21413       if (!state.inES5() && left.value === "parseInt" && n === 1) {
    21414         warning("W065", state.tokens.curr);
    21415       }
    21416       if (!state.option.evil) {
    21417         if (left.value === "eval" || left.value === "Function" ||
    21418             left.value === "execScript") {
    21419           warning("W061", left);
    21420 
    21421           // This conditional expression was initially implemented with a typo
    21422           // which prevented the branch's execution in all cases. While
    21423           // enabling the code will produce behavior that is consistent with
    21424           // the other forms of code evaluation that follow, such a change is
    21425           // also technically incompatable with prior versions of JSHint (due
    21426           // to the fact that the behavior was never formally documented). This
    21427           // branch should be enabled as part of a major release.
    21428           //if (p[0] && p[0].id === "(string)") {
    21429           //  addEvalCode(left, p[0]);
    21430           //}
    21431         } else if (p[0] && p[0].id === "(string)" &&
    21432              (left.value === "setTimeout" ||
    21433             left.value === "setInterval")) {
    21434           warning("W066", left);
    21435           addEvalCode(left, p[0]);
    21436 
    21437         // window.setTimeout/setInterval
    21438         } else if (p[0] && p[0].id === "(string)" &&
    21439              left.value === "." &&
    21440              left.left.value === "window" &&
    21441              (left.right === "setTimeout" ||
    21442             left.right === "setInterval")) {
    21443           warning("W066", left);
    21444           addEvalCode(left, p[0]);
    21445         }
    21446       }
    21447       if (!left.identifier && left.id !== "." && left.id !== "[" && left.id !== "=>" &&
    21448           left.id !== "(" && left.id !== "&&" && left.id !== "||" && left.id !== "?" &&
    21449           !(state.inES6() && left["(name)"])) {
    21450         warning("W067", that);
    21451       }
    21452     }
    21453 
    21454     that.left = left;
    21455     return that;
    21456   }, 155, true).exps = true;
    21457 
    21458   prefix("(", function(rbp) {
    21459     var pn = state.tokens.next, pn1, i = -1;
    21460     var ret, triggerFnExpr, first, last;
    21461     var parens = 1;
    21462     var opening = state.tokens.curr;
    21463     var preceeding = state.tokens.prev;
    21464     var isNecessary = !state.option.singleGroups;
    21465 
    21466     do {
    21467       if (pn.value === "(") {
    21468         parens += 1;
    21469       } else if (pn.value === ")") {
    21470         parens -= 1;
    21471       }
    21472 
    21473       i += 1;
    21474       pn1 = pn;
    21475       pn = peek(i);
    21476     } while (!(parens === 0 && pn1.value === ")") && pn.type !== "(end)");
    21477 
    21478     if (state.tokens.next.id === "function") {
    21479       triggerFnExpr = state.tokens.next.immed = true;
    21480     }
    21481 
    21482     // If the balanced grouping operator is followed by a "fat arrow", the
    21483     // current token marks the beginning of a "fat arrow" function and parsing
    21484     // should proceed accordingly.
    21485     if (pn.value === "=>") {
    21486       return doFunction({ type: "arrow", parsedOpening: true });
    21487     }
    21488 
    21489     var exprs = [];
    21490 
    21491     if (state.tokens.next.id !== ")") {
    21492       for (;;) {
    21493         exprs.push(expression(10));
    21494 
    21495         if (state.tokens.next.id !== ",") {
    21496           break;
    21497         }
    21498 
    21499         if (state.option.nocomma) {
    21500           warning("W127");
    21501         }
    21502 
    21503         parseComma();
    21504       }
    21505     }
    21506 
    21507     advance(")", this);
    21508     if (state.option.immed && exprs[0] && exprs[0].id === "function") {
    21509       if (state.tokens.next.id !== "(" &&
    21510         state.tokens.next.id !== "." && state.tokens.next.id !== "[") {
    21511         warning("W068", this);
    21512       }
    21513     }
    21514 
    21515     if (!exprs.length) {
    21516       return;
    21517     }
    21518     if (exprs.length > 1) {
    21519       ret = Object.create(state.syntax[","]);
    21520       ret.exprs = exprs;
    21521 
    21522       first = exprs[0];
    21523       last = exprs[exprs.length - 1];
    21524     } else {
    21525       ret = first = last = exprs[0];
    21526 
    21527       if (!isNecessary) {
    21528         isNecessary =
    21529           // Used to distinguish from an ExpressionStatement which may not
    21530           // begin with the `{` and `function` tokens
    21531           (opening.beginsStmt && (ret.id === "{" || triggerFnExpr || isFunctor(ret))) ||
    21532           // Used to signal that a function expression is being supplied to
    21533           // some other operator.
    21534           (triggerFnExpr &&
    21535             // For parenthesis wrapping a function expression to be considered
    21536             // necessary, the grouping operator should be the left-hand-side of
    21537             // some other operator--either within the parenthesis or directly
    21538             // following them.
    21539             (!isEndOfExpr() || state.tokens.prev.id !== "}")) ||
    21540           // Used to demarcate an arrow function as the left-hand side of some
    21541           // operator.
    21542           (isFunctor(ret) && !isEndOfExpr()) ||
    21543           // Used as the return value of a single-statement arrow function
    21544           (ret.id === "{" && preceeding.id === "=>") ||
    21545           // Used to delineate an integer number literal from a dereferencing
    21546           // punctuator (otherwise interpreted as a decimal point)
    21547           (ret.type === "(number)" &&
    21548             checkPunctuator(pn, ".") && /^\d+$/.test(ret.value)) ||
    21549           // Used to wrap object destructuring assignment
    21550           (opening.beginsStmt && ret.id === "=" && ret.left.id === "{");
    21551       }
    21552     }
    21553 
    21554     if (ret) {
    21555       // The operator may be necessary to override the default binding power of
    21556       // neighboring operators (whenever there is an operator in use within the
    21557       // first expression *or* the current group contains multiple expressions)
    21558       if (!isNecessary && (isOperator(first) || ret.exprs)) {
    21559         isNecessary =
    21560           (rbp > first.lbp) ||
    21561           (rbp > 0 && rbp === first.lbp) ||
    21562           (!isEndOfExpr() && last.lbp < state.tokens.next.lbp);
    21563       }
    21564 
    21565       if (!isNecessary) {
    21566         warning("W126", opening);
    21567       }
    21568 
    21569       ret.paren = true;
    21570     }
    21571 
    21572     return ret;
    21573   });
    21574 
    21575   application("=>");
    21576 
    21577   infix("[", function(left, that) {
    21578     var e = expression(10), s;
    21579     if (e && e.type === "(string)") {
    21580       if (!state.option.evil && (e.value === "eval" || e.value === "execScript")) {
    21581         if (isGlobalEval(left, state)) {
    21582           warning("W061");
    21583         }
    21584       }
    21585 
    21586       countMember(e.value);
    21587       if (!state.option.sub && reg.identifier.test(e.value)) {
    21588         s = state.syntax[e.value];
    21589         if (!s || !isReserved(s)) {
    21590           warning("W069", state.tokens.prev, e.value);
    21591         }
    21592       }
    21593     }
    21594     advance("]", that);
    21595 
    21596     if (e && e.value === "hasOwnProperty" && state.tokens.next.value === "=") {
    21597       warning("W001");
    21598     }
    21599 
    21600     that.left = left;
    21601     that.right = e;
    21602     return that;
    21603   }, 160, true);
    21604 
    21605   function comprehensiveArrayExpression() {
    21606     var res = {};
    21607     res.exps = true;
    21608     state.funct["(comparray)"].stack();
    21609 
    21610     // Handle reversed for expressions, used in spidermonkey
    21611     var reversed = false;
    21612     if (state.tokens.next.value !== "for") {
    21613       reversed = true;
    21614       if (!state.inMoz()) {
    21615         warning("W116", state.tokens.next, "for", state.tokens.next.value);
    21616       }
    21617       state.funct["(comparray)"].setState("use");
    21618       res.right = expression(10);
    21619     }
    21620 
    21621     advance("for");
    21622     if (state.tokens.next.value === "each") {
    21623       advance("each");
    21624       if (!state.inMoz()) {
    21625         warning("W118", state.tokens.curr, "for each");
    21626       }
    21627     }
    21628     advance("(");
    21629     state.funct["(comparray)"].setState("define");
    21630     res.left = expression(130);
    21631     if (_.contains(["in", "of"], state.tokens.next.value)) {
    21632       advance();
    21633     } else {
    21634       error("E045", state.tokens.curr);
    21635     }
    21636     state.funct["(comparray)"].setState("generate");
    21637     expression(10);
    21638 
    21639     advance(")");
    21640     if (state.tokens.next.value === "if") {
    21641       advance("if");
    21642       advance("(");
    21643       state.funct["(comparray)"].setState("filter");
    21644       res.filter = expression(10);
    21645       advance(")");
    21646     }
    21647 
    21648     if (!reversed) {
    21649       state.funct["(comparray)"].setState("use");
    21650       res.right = expression(10);
    21651     }
    21652 
    21653     advance("]");
    21654     state.funct["(comparray)"].unstack();
    21655     return res;
    21656   }
    21657 
    21658   prefix("[", function() {
    21659     var blocktype = lookupBlockType();
    21660     if (blocktype.isCompArray) {
    21661       if (!state.option.esnext && !state.inMoz()) {
    21662         warning("W118", state.tokens.curr, "array comprehension");
    21663       }
    21664       return comprehensiveArrayExpression();
    21665     } else if (blocktype.isDestAssign) {
    21666       this.destructAssign = destructuringPattern({ openingParsed: true, assignment: true });
    21667       return this;
    21668     }
    21669     var b = state.tokens.curr.line !== startLine(state.tokens.next);
    21670     this.first = [];
    21671     if (b) {
    21672       indent += state.option.indent;
    21673       if (state.tokens.next.from === indent + state.option.indent) {
    21674         indent += state.option.indent;
    21675       }
    21676     }
    21677     while (state.tokens.next.id !== "(end)") {
    21678       while (state.tokens.next.id === ",") {
    21679         if (!state.option.elision) {
    21680           if (!state.inES5()) {
    21681             // Maintain compat with old options --- ES5 mode without
    21682             // elision=true will warn once per comma
    21683             warning("W070");
    21684           } else {
    21685             warning("W128");
    21686             do {
    21687               advance(",");
    21688             } while (state.tokens.next.id === ",");
    21689             continue;
    21690           }
    21691         }
    21692         advance(",");
    21693       }
    21694 
    21695       if (state.tokens.next.id === "]") {
    21696         break;
    21697       }
    21698 
    21699       this.first.push(expression(10));
    21700       if (state.tokens.next.id === ",") {
    21701         parseComma({ allowTrailing: true });
    21702         if (state.tokens.next.id === "]" && !state.inES5()) {
    21703           warning("W070", state.tokens.curr);
    21704           break;
    21705         }
    21706       } else {
    21707         if (state.option.trailingcomma && state.inES5()) {
    21708           warningAt("W140", state.tokens.curr.line, state.tokens.curr.character);
    21709         }
    21710         break;
    21711       }
    21712     }
    21713     if (b) {
    21714       indent -= state.option.indent;
    21715     }
    21716     advance("]", this);
    21717     return this;
    21718   });
    21719 
    21720 
    21721   function isMethod() {
    21722     return state.funct["(statement)"] && state.funct["(statement)"].type === "class" ||
    21723            state.funct["(context)"] && state.funct["(context)"]["(verb)"] === "class";
    21724   }
    21725 
    21726 
    21727   function isPropertyName(token) {
    21728     return token.identifier || token.id === "(string)" || token.id === "(number)";
    21729   }
    21730 
    21731 
    21732   function propertyName(preserveOrToken) {
    21733     var id;
    21734     var preserve = true;
    21735     if (typeof preserveOrToken === "object") {
    21736       id = preserveOrToken;
    21737     } else {
    21738       preserve = preserveOrToken;
    21739       id = optionalidentifier(false, true, preserve);
    21740     }
    21741 
    21742     if (!id) {
    21743       if (state.tokens.next.id === "(string)") {
    21744         id = state.tokens.next.value;
    21745         if (!preserve) {
    21746           advance();
    21747         }
    21748       } else if (state.tokens.next.id === "(number)") {
    21749         id = state.tokens.next.value.toString();
    21750         if (!preserve) {
    21751           advance();
    21752         }
    21753       }
    21754     } else if (typeof id === "object") {
    21755       if (id.id === "(string)" || id.id === "(identifier)") id = id.value;
    21756       else if (id.id === "(number)") id = id.value.toString();
    21757     }
    21758 
    21759     if (id === "hasOwnProperty") {
    21760       warning("W001");
    21761     }
    21762 
    21763     return id;
    21764   }
    21765 
    21766   /**
    21767    * @param {Object} [options]
    21768    * @param {token} [options.loneArg] The argument to the function in cases
    21769    *                                  where it was defined using the
    21770    *                                  single-argument shorthand.
    21771    * @param {bool} [options.parsedOpening] Whether the opening parenthesis has
    21772    *                                       already been parsed.
    21773    * @returns {{ arity: number, params: Array.<string>}}
    21774    */
    21775   function functionparams(options) {
    21776     var next;
    21777     var paramsIds = [];
    21778     var ident;
    21779     var tokens = [];
    21780     var t;
    21781     var pastDefault = false;
    21782     var pastRest = false;
    21783     var arity = 0;
    21784     var loneArg = options && options.loneArg;
    21785 
    21786     if (loneArg && loneArg.identifier === true) {
    21787       state.funct["(scope)"].addParam(loneArg.value, loneArg);
    21788       return { arity: 1, params: [ loneArg.value ] };
    21789     }
    21790 
    21791     next = state.tokens.next;
    21792 
    21793     if (!options || !options.parsedOpening) {
    21794       advance("(");
    21795     }
    21796 
    21797     if (state.tokens.next.id === ")") {
    21798       advance(")");
    21799       return;
    21800     }
    21801 
    21802     function addParam(addParamArgs) {
    21803       state.funct["(scope)"].addParam.apply(state.funct["(scope)"], addParamArgs);
    21804     }
    21805 
    21806     for (;;) {
    21807       arity++;
    21808       // are added to the param scope
    21809       var currentParams = [];
    21810 
    21811       if (_.contains(["{", "["], state.tokens.next.id)) {
    21812         tokens = destructuringPattern();
    21813         for (t in tokens) {
    21814           t = tokens[t];
    21815           if (t.id) {
    21816             paramsIds.push(t.id);
    21817             currentParams.push([t.id, t.token]);
    21818           }
    21819         }
    21820       } else {
    21821         if (checkPunctuator(state.tokens.next, "...")) pastRest = true;
    21822         ident = identifier(true);
    21823         if (ident) {
    21824           paramsIds.push(ident);
    21825           currentParams.push([ident, state.tokens.curr]);
    21826         } else {
    21827           // Skip invalid parameter.
    21828           while (!checkPunctuators(state.tokens.next, [",", ")"])) advance();
    21829         }
    21830       }
    21831 
    21832       // It is valid to have a regular argument after a default argument
    21833       // since undefined can be used for missing parameters. Still warn as it is
    21834       // a possible code smell.
    21835       if (pastDefault) {
    21836         if (state.tokens.next.id !== "=") {
    21837           error("W138", state.tokens.current);
    21838         }
    21839       }
    21840       if (state.tokens.next.id === "=") {
    21841         if (!state.inES6()) {
    21842           warning("W119", state.tokens.next, "default parameters", "6");
    21843         }
    21844         advance("=");
    21845         pastDefault = true;
    21846         expression(10);
    21847       }
    21848 
    21849       // now we have evaluated the default expression, add the variable to the param scope
    21850       currentParams.forEach(addParam);
    21851 
    21852       if (state.tokens.next.id === ",") {
    21853         if (pastRest) {
    21854           warning("W131", state.tokens.next);
    21855         }
    21856         parseComma();
    21857       } else {
    21858         advance(")", next);
    21859         return { arity: arity, params: paramsIds };
    21860       }
    21861     }
    21862   }
    21863 
    21864   function functor(name, token, overwrites) {
    21865     var funct = {
    21866       "(name)"      : name,
    21867       "(breakage)"  : 0,
    21868       "(loopage)"   : 0,
    21869       "(tokens)"    : {},
    21870       "(properties)": {},
    21871 
    21872       "(catch)"     : false,
    21873       "(global)"    : false,
    21874 
    21875       "(line)"      : null,
    21876       "(character)" : null,
    21877       "(metrics)"   : null,
    21878       "(statement)" : null,
    21879       "(context)"   : null,
    21880       "(scope)"     : null,
    21881       "(comparray)" : null,
    21882       "(generator)" : null,
    21883       "(arrow)"     : null,
    21884       "(params)"    : null
    21885     };
    21886 
    21887     if (token) {
    21888       _.extend(funct, {
    21889         "(line)"     : token.line,
    21890         "(character)": token.character,
    21891         "(metrics)"  : createMetrics(token)
    21892       });
    21893     }
    21894 
    21895     _.extend(funct, overwrites);
    21896 
    21897     if (funct["(context)"]) {
    21898       funct["(scope)"] = funct["(context)"]["(scope)"];
    21899       funct["(comparray)"]  = funct["(context)"]["(comparray)"];
    21900     }
    21901 
    21902     return funct;
    21903   }
    21904 
    21905   function isFunctor(token) {
    21906     return "(scope)" in token;
    21907   }
    21908 
    21909   /**
    21910    * Determine if the parser has begun parsing executable code.
    21911    *
    21912    * @param {Token} funct - The current "functor" token
    21913    *
    21914    * @returns {boolean}
    21915    */
    21916   function hasParsedCode(funct) {
    21917     return funct["(global)"] && !funct["(verb)"];
    21918   }
    21919 
    21920   /**
    21921    * This function is used as both a null-denotation method *and* a
    21922    * left-denotation method, meaning the first parameter is overloaded.
    21923    */
    21924   function doTemplateLiteral(leftOrRbp) {
    21925     // ASSERT: this.type === "(template)"
    21926     // jshint validthis: true
    21927     var ctx = this.context;
    21928     var noSubst = this.noSubst;
    21929     var depth = this.depth;
    21930     var left = typeof leftOrRbp === "number" ? null : leftOrRbp;
    21931 
    21932     if (!noSubst) {
    21933       while (!end()) {
    21934         if (!state.tokens.next.template || state.tokens.next.depth > depth) {
    21935           expression(0); // should probably have different rbp?
    21936         } else {
    21937           // skip template start / middle
    21938           advance();
    21939         }
    21940       }
    21941     }
    21942 
    21943     return {
    21944       id: "(template)",
    21945       type: "(template)",
    21946       tag: left
    21947     };
    21948 
    21949     function end() {
    21950       if (state.tokens.curr.template && state.tokens.curr.tail &&
    21951           state.tokens.curr.context === ctx) return true;
    21952       var complete = (state.tokens.next.template && state.tokens.next.tail &&
    21953                       state.tokens.next.context === ctx);
    21954       if (complete) advance();
    21955       return complete || state.tokens.next.isUnclosed;
    21956     }
    21957   }
    21958 
    21959   /**
    21960    * @param {Object} [options]
    21961    * @param {token} [options.name] The identifier belonging to the function (if
    21962    *                               any)
    21963    * @param {boolean} [options.statement] The statement that triggered creation
    21964    *                                      of the current function.
    21965    * @param {string} [options.type] If specified, either "generator" or "arrow"
    21966    * @param {token} [options.loneArg] The argument to the function in cases
    21967    *                                  where it was defined using the
    21968    *                                  single-argument shorthand
    21969    * @param {bool} [options.parsedOpening] Whether the opening parenthesis has
    21970    *                                       already been parsed
    21971    * @param {token} [options.classExprBinding] Define a function with this
    21972    *                                           identifier in the new function's
    21973    *                                           scope, mimicking the bahavior of
    21974    *                                           class expression names within
    21975    *                                           the body of member functions.
    21976    */
    21977   function doFunction(options) {
    21978     var f, token, name, statement, classExprBinding, isGenerator, isArrow, ignoreLoopFunc;
    21979     var oldOption = state.option;
    21980     var oldIgnored = state.ignored;
    21981 
    21982     if (options) {
    21983       name = options.name;
    21984       statement = options.statement;
    21985       classExprBinding = options.classExprBinding;
    21986       isGenerator = options.type === "generator";
    21987       isArrow = options.type === "arrow";
    21988       ignoreLoopFunc = options.ignoreLoopFunc;
    21989     }
    21990 
    21991     state.option = Object.create(state.option);
    21992     state.ignored = Object.create(state.ignored);
    21993 
    21994     state.funct = functor(name || state.nameStack.infer(), state.tokens.next, {
    21995       "(statement)": statement,
    21996       "(context)":   state.funct,
    21997       "(arrow)":     isArrow,
    21998       "(generator)": isGenerator
    21999     });
    22000 
    22001     f = state.funct;
    22002     token = state.tokens.curr;
    22003     token.funct = state.funct;
    22004 
    22005     functions.push(state.funct);
    22006 
    22007     // So that the function is available to itself and referencing itself is not
    22008     // seen as a closure, add the function name to a new scope, but do not
    22009     // test for unused (unused: false)
    22010     // it is a new block scope so that params can override it, it can be block scoped
    22011     // but declarations inside the function don't cause already declared error
    22012     state.funct["(scope)"].stack("functionouter");
    22013     var internallyAccessibleName = name || classExprBinding;
    22014     if (internallyAccessibleName) {
    22015       state.funct["(scope)"].block.add(internallyAccessibleName,
    22016         classExprBinding ? "class" : "function", state.tokens.curr, false);
    22017     }
    22018 
    22019     // create the param scope (params added in functionparams)
    22020     state.funct["(scope)"].stack("functionparams");
    22021 
    22022     var paramsInfo = functionparams(options);
    22023 
    22024     if (paramsInfo) {
    22025       state.funct["(params)"] = paramsInfo.params;
    22026       state.funct["(metrics)"].arity = paramsInfo.arity;
    22027       state.funct["(metrics)"].verifyMaxParametersPerFunction();
    22028     } else {
    22029       state.funct["(metrics)"].arity = 0;
    22030     }
    22031 
    22032     if (isArrow) {
    22033       if (!state.inES6(true)) {
    22034         warning("W119", state.tokens.curr, "arrow function syntax (=>)", "6");
    22035       }
    22036 
    22037       if (!options.loneArg) {
    22038         advance("=>");
    22039       }
    22040     }
    22041 
    22042     block(false, true, true, isArrow);
    22043 
    22044     if (!state.option.noyield && isGenerator &&
    22045         state.funct["(generator)"] !== "yielded") {
    22046       warning("W124", state.tokens.curr);
    22047     }
    22048 
    22049     state.funct["(metrics)"].verifyMaxStatementsPerFunction();
    22050     state.funct["(metrics)"].verifyMaxComplexityPerFunction();
    22051     state.funct["(unusedOption)"] = state.option.unused;
    22052     state.option = oldOption;
    22053     state.ignored = oldIgnored;
    22054     state.funct["(last)"] = state.tokens.curr.line;
    22055     state.funct["(lastcharacter)"] = state.tokens.curr.character;
    22056 
    22057     // unstack the params scope
    22058     state.funct["(scope)"].unstack(); // also does usage and label checks
    22059 
    22060     // unstack the function outer stack
    22061     state.funct["(scope)"].unstack();
    22062 
    22063     state.funct = state.funct["(context)"];
    22064 
    22065     if (!ignoreLoopFunc && !state.option.loopfunc && state.funct["(loopage)"]) {
    22066       // If the function we just parsed accesses any non-local variables
    22067       // trigger a warning. Otherwise, the function is safe even within
    22068       // a loop.
    22069       if (f["(isCapturing)"]) {
    22070         warning("W083", token);
    22071       }
    22072     }
    22073 
    22074     return f;
    22075   }
    22076 
    22077   function createMetrics(functionStartToken) {
    22078     return {
    22079       statementCount: 0,
    22080       nestedBlockDepth: -1,
    22081       ComplexityCount: 1,
    22082       arity: 0,
    22083 
    22084       verifyMaxStatementsPerFunction: function() {
    22085         if (state.option.maxstatements &&
    22086           this.statementCount > state.option.maxstatements) {
    22087           warning("W071", functionStartToken, this.statementCount);
    22088         }
    22089       },
    22090 
    22091       verifyMaxParametersPerFunction: function() {
    22092         if (_.isNumber(state.option.maxparams) &&
    22093           this.arity > state.option.maxparams) {
    22094           warning("W072", functionStartToken, this.arity);
    22095         }
    22096       },
    22097 
    22098       verifyMaxNestedBlockDepthPerFunction: function() {
    22099         if (state.option.maxdepth &&
    22100           this.nestedBlockDepth > 0 &&
    22101           this.nestedBlockDepth === state.option.maxdepth + 1) {
    22102           warning("W073", null, this.nestedBlockDepth);
    22103         }
    22104       },
    22105 
    22106       verifyMaxComplexityPerFunction: function() {
    22107         var max = state.option.maxcomplexity;
    22108         var cc = this.ComplexityCount;
    22109         if (max && cc > max) {
    22110           warning("W074", functionStartToken, cc);
    22111         }
    22112       }
    22113     };
    22114   }
    22115 
    22116   function increaseComplexityCount() {
    22117     state.funct["(metrics)"].ComplexityCount += 1;
    22118   }
    22119 
    22120   // Parse assignments that were found instead of conditionals.
    22121   // For example: if (a = 1) { ... }
    22122 
    22123   function checkCondAssignment(expr) {
    22124     var id, paren;
    22125     if (expr) {
    22126       id = expr.id;
    22127       paren = expr.paren;
    22128       if (id === "," && (expr = expr.exprs[expr.exprs.length - 1])) {
    22129         id = expr.id;
    22130         paren = paren || expr.paren;
    22131       }
    22132     }
    22133     switch (id) {
    22134     case "=":
    22135     case "+=":
    22136     case "-=":
    22137     case "*=":
    22138     case "%=":
    22139     case "&=":
    22140     case "|=":
    22141     case "^=":
    22142     case "/=":
    22143       if (!paren && !state.option.boss) {
    22144         warning("W084");
    22145       }
    22146     }
    22147   }
    22148 
    22149   /**
    22150    * @param {object} props Collection of property descriptors for a given
    22151    *                       object.
    22152    */
    22153   function checkProperties(props) {
    22154     // Check for lonely setters if in the ES5 mode.
    22155     if (state.inES5()) {
    22156       for (var name in props) {
    22157         if (props[name] && props[name].setterToken && !props[name].getterToken) {
    22158           warning("W078", props[name].setterToken);
    22159         }
    22160       }
    22161     }
    22162   }
    22163 
    22164   function metaProperty(name, c) {
    22165     if (checkPunctuator(state.tokens.next, ".")) {
    22166       var left = state.tokens.curr.id;
    22167       advance(".");
    22168       var id = identifier();
    22169       state.tokens.curr.isMetaProperty = true;
    22170       if (name !== id) {
    22171         error("E057", state.tokens.prev, left, id);
    22172       } else {
    22173         c();
    22174       }
    22175       return state.tokens.curr;
    22176     }
    22177   }
    22178 
    22179   (function(x) {
    22180     x.nud = function() {
    22181       var b, f, i, p, t, isGeneratorMethod = false, nextVal;
    22182       var props = Object.create(null); // All properties, including accessors
    22183 
    22184       b = state.tokens.curr.line !== startLine(state.tokens.next);
    22185       if (b) {
    22186         indent += state.option.indent;
    22187         if (state.tokens.next.from === indent + state.option.indent) {
    22188           indent += state.option.indent;
    22189         }
    22190       }
    22191 
    22192       var blocktype = lookupBlockType();
    22193       if (blocktype.isDestAssign) {
    22194         this.destructAssign = destructuringPattern({ openingParsed: true, assignment: true });
    22195         return this;
    22196       }
    22197 
    22198       for (;;) {
    22199         if (state.tokens.next.id === "}") {
    22200           break;
    22201         }
    22202 
    22203         nextVal = state.tokens.next.value;
    22204         if (state.tokens.next.identifier &&
    22205             (peekIgnoreEOL().id === "," || peekIgnoreEOL().id === "}")) {
    22206           if (!state.inES6()) {
    22207             warning("W104", state.tokens.next, "object short notation", "6");
    22208           }
    22209           i = propertyName(true);
    22210           saveProperty(props, i, state.tokens.next);
    22211 
    22212           expression(10);
    22213 
    22214         } else if (peek().id !== ":" && (nextVal === "get" || nextVal === "set")) {
    22215           advance(nextVal);
    22216 
    22217           if (!state.inES5()) {
    22218             error("E034");
    22219           }
    22220 
    22221           i = propertyName();
    22222 
    22223           // ES6 allows for get() {...} and set() {...} method
    22224           // definition shorthand syntax, so we don't produce an error
    22225           // if linting ECMAScript 6 code.
    22226           if (!i && !state.inES6()) {
    22227             error("E035");
    22228           }
    22229 
    22230           // We don't want to save this getter unless it's an actual getter
    22231           // and not an ES6 concise method
    22232           if (i) {
    22233             saveAccessor(nextVal, props, i, state.tokens.curr);
    22234           }
    22235 
    22236           t = state.tokens.next;
    22237           f = doFunction();
    22238           p = f["(params)"];
    22239 
    22240           // Don't warn about getter/setter pairs if this is an ES6 concise method
    22241           if (nextVal === "get" && i && p) {
    22242             warning("W076", t, p[0], i);
    22243           } else if (nextVal === "set" && i && f["(metrics)"].arity !== 1) {
    22244             warning("W077", t, i);
    22245           }
    22246         } else {
    22247           if (state.tokens.next.value === "*" && state.tokens.next.type === "(punctuator)") {
    22248             if (!state.inES6()) {
    22249               warning("W104", state.tokens.next, "generator functions", "6");
    22250             }
    22251             advance("*");
    22252             isGeneratorMethod = true;
    22253           } else {
    22254             isGeneratorMethod = false;
    22255           }
    22256 
    22257           if (state.tokens.next.id === "[") {
    22258             i = computedPropertyName();
    22259             state.nameStack.set(i);
    22260           } else {
    22261             state.nameStack.set(state.tokens.next);
    22262             i = propertyName();
    22263             saveProperty(props, i, state.tokens.next);
    22264 
    22265             if (typeof i !== "string") {
    22266               break;
    22267             }
    22268           }
    22269 
    22270           if (state.tokens.next.value === "(") {
    22271             if (!state.inES6()) {
    22272               warning("W104", state.tokens.curr, "concise methods", "6");
    22273             }
    22274             doFunction({ type: isGeneratorMethod ? "generator" : null });
    22275           } else {
    22276             advance(":");
    22277             expression(10);
    22278           }
    22279         }
    22280 
    22281         countMember(i);
    22282 
    22283         if (state.tokens.next.id === ",") {
    22284           parseComma({ allowTrailing: true, property: true });
    22285           if (state.tokens.next.id === ",") {
    22286             warning("W070", state.tokens.curr);
    22287           } else if (state.tokens.next.id === "}" && !state.inES5()) {
    22288             warning("W070", state.tokens.curr);
    22289           }
    22290         } else {
    22291           if (state.option.trailingcomma && state.inES5()) {
    22292             warningAt("W140", state.tokens.curr.line, state.tokens.curr.character);
    22293           }
    22294           break;
    22295         }
    22296       }
    22297       if (b) {
    22298         indent -= state.option.indent;
    22299       }
    22300       advance("}", this);
    22301 
    22302       checkProperties(props);
    22303 
    22304       return this;
    22305     };
    22306     x.fud = function() {
    22307       error("E036", state.tokens.curr);
    22308     };
    22309   }(delim("{")));
    22310 
    22311   function destructuringPattern(options) {
    22312     var isAssignment = options && options.assignment;
    22313 
    22314     if (!state.inES6()) {
    22315       warning("W104", state.tokens.curr,
    22316         isAssignment ? "destructuring assignment" : "destructuring binding", "6");
    22317     }
    22318 
    22319     return destructuringPatternRecursive(options);
    22320   }
    22321 
    22322   function destructuringPatternRecursive(options) {
    22323     var ids;
    22324     var identifiers = [];
    22325     var openingParsed = options && options.openingParsed;
    22326     var isAssignment = options && options.assignment;
    22327     var recursiveOptions = isAssignment ? { assignment: isAssignment } : null;
    22328     var firstToken = openingParsed ? state.tokens.curr : state.tokens.next;
    22329 
    22330     var nextInnerDE = function() {
    22331       var ident;
    22332       if (checkPunctuators(state.tokens.next, ["[", "{"])) {
    22333         ids = destructuringPatternRecursive(recursiveOptions);
    22334         for (var id in ids) {
    22335           id = ids[id];
    22336           identifiers.push({ id: id.id, token: id.token });
    22337         }
    22338       } else if (checkPunctuator(state.tokens.next, ",")) {
    22339         identifiers.push({ id: null, token: state.tokens.curr });
    22340       } else if (checkPunctuator(state.tokens.next, "(")) {
    22341         advance("(");
    22342         nextInnerDE();
    22343         advance(")");
    22344       } else {
    22345         var is_rest = checkPunctuator(state.tokens.next, "...");
    22346 
    22347         if (isAssignment) {
    22348           var assignTarget = expression(20);
    22349           if (assignTarget) {
    22350             checkLeftSideAssign(assignTarget);
    22351 
    22352             // if the target was a simple identifier, add it to the list to return
    22353             if (assignTarget.identifier) {
    22354               ident = assignTarget.value;
    22355             }
    22356           }
    22357         } else {
    22358           ident = identifier();
    22359         }
    22360         if (ident) {
    22361           identifiers.push({ id: ident, token: state.tokens.curr });
    22362         }