{"version":3,"sources":["jsdelivr-header.js","/npm/frets@1.0.1/benchmarks/benchmark.js"],"names":[],"mappings":"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","file":"/npm/frets@1.0.1/benchmarks/benchmark.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/frets@1.0.1/benchmarks/benchmark.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*!\n * Benchmark.js <https://benchmarkjs.com/>\n * Copyright 2010-2016 Mathias Bynens <https://mths.be/>\n * Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>\n * Modified by John-David Dalton <http://allyoucanleet.com/>\n * Available under MIT license <https://mths.be/mit>\n */\n;(function() {\n  'use strict';\n\n  /** Used as a safe reference for `undefined` in pre ES5 environments. */\n  var undefined;\n\n  /** Used to determine if values are of the language type Object. */\n  var objectTypes = {\n    'function': true,\n    'object': true\n  };\n\n  /** Used as a reference to the global object. */\n  var root = (objectTypes[typeof window] && window) || this;\n\n  /** Detect free variable `define`. */\n  var freeDefine = typeof define == 'function' && typeof define.amd == 'object' && define.amd && define;\n\n  /** Detect free variable `exports`. */\n  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;\n\n  /** Detect free variable `global` from Node.js or Browserified code and use it as `root`. */\n  var freeGlobal = freeExports && freeModule && typeof global == 'object' && global;\n  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {\n    root = freeGlobal;\n  }\n\n  /** Detect free variable `require`. */\n  var freeRequire = typeof require == 'function' && require;\n\n  /** Used to assign each benchmark an incremented id. */\n  var counter = 0;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;\n\n  /** Used to detect primitive types. */\n  var rePrimitive = /^(?:boolean|number|string|undefined)$/;\n\n  /** Used to make every compiled test unique. */\n  var uidCounter = 0;\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'Date', 'Function', 'Math', 'Object', 'RegExp', 'String', '_',\n    'clearTimeout', 'chrome', 'chromium', 'document', 'navigator', 'phantom',\n    'platform', 'process', 'runtime', 'setTimeout'\n  ];\n\n  /** Used to avoid hz of Infinity. */\n  var divisors = {\n    '1': 4096,\n    '2': 512,\n    '3': 64,\n    '4': 8,\n    '5': 0\n  };\n\n  /**\n   * T-Distribution two-tailed critical values for 95% confidence.\n   * For more info see http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm.\n   */\n  var tTable = {\n    '1':  12.706, '2':  4.303, '3':  3.182, '4':  2.776, '5':  2.571, '6':  2.447,\n    '7':  2.365,  '8':  2.306, '9':  2.262, '10': 2.228, '11': 2.201, '12': 2.179,\n    '13': 2.16,   '14': 2.145, '15': 2.131, '16': 2.12,  '17': 2.11,  '18': 2.101,\n    '19': 2.093,  '20': 2.086, '21': 2.08,  '22': 2.074, '23': 2.069, '24': 2.064,\n    '25': 2.06,   '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,\n    'infinity': 1.96\n  };\n\n  /**\n   * Critical Mann-Whitney U-values for 95% confidence.\n   * For more info see http://www.saburchill.com/IBbiology/stats/003.html.\n   */\n  var uTable = {\n    '5':  [0, 1, 2],\n    '6':  [1, 2, 3, 5],\n    '7':  [1, 3, 5, 6, 8],\n    '8':  [2, 4, 6, 8, 10, 13],\n    '9':  [2, 4, 7, 10, 12, 15, 17],\n    '10': [3, 5, 8, 11, 14, 17, 20, 23],\n    '11': [3, 6, 9, 13, 16, 19, 23, 26, 30],\n    '12': [4, 7, 11, 14, 18, 22, 26, 29, 33, 37],\n    '13': [4, 8, 12, 16, 20, 24, 28, 33, 37, 41, 45],\n    '14': [5, 9, 13, 17, 22, 26, 31, 36, 40, 45, 50, 55],\n    '15': [5, 10, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64],\n    '16': [6, 11, 15, 21, 26, 31, 37, 42, 47, 53, 59, 64, 70, 75],\n    '17': [6, 11, 17, 22, 28, 34, 39, 45, 51, 57, 63, 67, 75, 81, 87],\n    '18': [7, 12, 18, 24, 30, 36, 42, 48, 55, 61, 67, 74, 80, 86, 93, 99],\n    '19': [7, 13, 19, 25, 32, 38, 45, 52, 58, 65, 72, 78, 85, 92, 99, 106, 113],\n    '20': [8, 14, 20, 27, 34, 41, 48, 55, 62, 69, 76, 83, 90, 98, 105, 112, 119, 127],\n    '21': [8, 15, 22, 29, 36, 43, 50, 58, 65, 73, 80, 88, 96, 103, 111, 119, 126, 134, 142],\n    '22': [9, 16, 23, 30, 38, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 141, 150, 158],\n    '23': [9, 17, 24, 32, 40, 48, 56, 64, 73, 81, 89, 98, 106, 115, 123, 132, 140, 149, 157, 166, 175],\n    '24': [10, 17, 25, 33, 42, 50, 59, 67, 76, 85, 94, 102, 111, 120, 129, 138, 147, 156, 165, 174, 183, 192],\n    '25': [10, 18, 27, 35, 44, 53, 62, 71, 80, 89, 98, 107, 117, 126, 135, 145, 154, 163, 173, 182, 192, 201, 211],\n    '26': [11, 19, 28, 37, 46, 55, 64, 74, 83, 93, 102, 112, 122, 132, 141, 151, 161, 171, 181, 191, 200, 210, 220, 230],\n    '27': [11, 20, 29, 38, 48, 57, 67, 77, 87, 97, 107, 118, 125, 138, 147, 158, 168, 178, 188, 199, 209, 219, 230, 240, 250],\n    '28': [12, 21, 30, 40, 50, 60, 70, 80, 90, 101, 111, 122, 132, 143, 154, 164, 175, 186, 196, 207, 218, 228, 239, 250, 261, 272],\n    '29': [13, 22, 32, 42, 52, 62, 73, 83, 94, 105, 116, 127, 138, 149, 160, 171, 182, 193, 204, 215, 226, 238, 249, 260, 271, 282, 294],\n    '30': [13, 23, 33, 43, 54, 65, 76, 87, 98, 109, 120, 131, 143, 154, 166, 177, 189, 200, 212, 223, 235, 247, 258, 270, 282, 293, 305, 317]\n  };\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new `Benchmark` function using the given `context` object.\n   *\n   * @static\n   * @memberOf Benchmark\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `Benchmark` function.\n   */\n  function runInContext(context) {\n    // Exit early if unable to acquire lodash.\n    var _ = context && context._ || require('lodash') || root._;\n    if (!_) {\n      Benchmark.runInContext = runInContext;\n      return Benchmark;\n    }\n    // Avoid issues with some ES3 environments that attempt to use values, named\n    // after built-in constructors like `Object`, for the creation of literals.\n    // ES5 clears this up by stating that literals must use built-in constructors.\n    // See http://es5.github.io/#x11.1.5.\n    context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;\n\n    /** Native constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Function = context.Function,\n        Math = context.Math,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String;\n\n    /** Used for `Array` and `Object` method references. */\n    var arrayRef = [],\n        objectProto = Object.prototype;\n\n    /** Native method shortcuts. */\n    var abs = Math.abs,\n        clearTimeout = context.clearTimeout,\n        floor = Math.floor,\n        log = Math.log,\n        max = Math.max,\n        min = Math.min,\n        pow = Math.pow,\n        push = arrayRef.push,\n        setTimeout = context.setTimeout,\n        shift = arrayRef.shift,\n        slice = arrayRef.slice,\n        sqrt = Math.sqrt,\n        toString = objectProto.toString,\n        unshift = arrayRef.unshift;\n\n    /** Used to avoid inclusion in Browserified bundles. */\n    var req = require;\n\n    /** Detect DOM document object. */\n    var doc = isHostType(context, 'document') && context.document;\n\n    /** Used to access Wade Simmons' Node.js `microtime` module. */\n    var microtimeObject = req('microtime');\n\n    /** Used to access Node.js's high resolution timer. */\n    var processObject = isHostType(context, 'process') && context.process;\n\n    /** Used to prevent a `removeChild` memory leak in IE < 9. */\n    var trash = doc && doc.createElement('div');\n\n    /** Used to integrity check compiled tests. */\n    var uid = 'uid' + _.now();\n\n    /** Used to avoid infinite recursion when methods call each other. */\n    var calledBy = {};\n\n    /**\n     * An object used to flag environments/features.\n     *\n     * @static\n     * @memberOf Benchmark\n     * @type Object\n     */\n    var support = {};\n\n    (function() {\n\n      /**\n       * Detect if running in a browser environment.\n       *\n       * @memberOf Benchmark.support\n       * @type boolean\n       */\n      support.browser = doc && isHostType(context, 'navigator') && !isHostType(context, 'phantom');\n\n      /**\n       * Detect if the Timers API exists.\n       *\n       * @memberOf Benchmark.support\n       * @type boolean\n       */\n      support.timeout = isHostType(context, 'setTimeout') && isHostType(context, 'clearTimeout');\n\n      /**\n       * Detect if function decompilation is support.\n       *\n       * @name decompilation\n       * @memberOf Benchmark.support\n       * @type boolean\n       */\n      try {\n        // Safari 2.x removes commas in object literals from `Function#toString` results.\n        // See http://webk.it/11609 for more details.\n        // Firefox 3.6 and Opera 9.25 strip grouping parentheses from `Function#toString` results.\n        // See http://bugzil.la/559438 for more details.\n        support.decompilation = Function(\n          ('return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')')\n          // Avoid issues with code added by Istanbul.\n          .replace(/__cov__[^;]+;/g, '')\n        )()(0).x === '1';\n      } catch(e) {\n        support.decompilation = false;\n      }\n    }());\n\n    /**\n     * Timer object used by `clock()` and `Deferred#resolve`.\n     *\n     * @private\n     * @type Object\n     */\n    var timer = {\n\n      /**\n       * The timer namespace object or constructor.\n       *\n       * @private\n       * @memberOf timer\n       * @type {Function|Object}\n       */\n      'ns': Date,\n\n      /**\n       * Starts the deferred timer.\n       *\n       * @private\n       * @memberOf timer\n       * @param {Object} deferred The deferred instance.\n       */\n      'start': null, // Lazy defined in `clock()`.\n\n      /**\n       * Stops the deferred timer.\n       *\n       * @private\n       * @memberOf timer\n       * @param {Object} deferred The deferred instance.\n       */\n      'stop': null // Lazy defined in `clock()`.\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The Benchmark constructor.\n     *\n     * Note: The Benchmark constructor exposes a handful of lodash methods to\n     * make working with arrays, collections, and objects easier. The lodash\n     * methods are:\n     * [`each/forEach`](https://lodash.com/docs#forEach), [`forOwn`](https://lodash.com/docs#forOwn),\n     * [`has`](https://lodash.com/docs#has), [`indexOf`](https://lodash.com/docs#indexOf),\n     * [`map`](https://lodash.com/docs#map), and [`reduce`](https://lodash.com/docs#reduce)\n     *\n     * @constructor\n     * @param {string} name A name to identify the benchmark.\n     * @param {Function|string} fn The test to benchmark.\n     * @param {Object} [options={}] Options object.\n     * @example\n     *\n     * // basic usage (the `new` operator is optional)\n     * var bench = new Benchmark(fn);\n     *\n     * // or using a name first\n     * var bench = new Benchmark('foo', fn);\n     *\n     * // or with options\n     * var bench = new Benchmark('foo', fn, {\n     *\n     *   // displayed by `Benchmark#toString` if `name` is not available\n     *   'id': 'xyz',\n     *\n     *   // called when the benchmark starts running\n     *   'onStart': onStart,\n     *\n     *   // called after each run cycle\n     *   'onCycle': onCycle,\n     *\n     *   // called when aborted\n     *   'onAbort': onAbort,\n     *\n     *   // called when a test errors\n     *   'onError': onError,\n     *\n     *   // called when reset\n     *   'onReset': onReset,\n     *\n     *   // called when the benchmark completes running\n     *   'onComplete': onComplete,\n     *\n     *   // compiled/called before the test loop\n     *   'setup': setup,\n     *\n     *   // compiled/called after the test loop\n     *   'teardown': teardown\n     * });\n     *\n     * // or name and options\n     * var bench = new Benchmark('foo', {\n     *\n     *   // a flag to indicate the benchmark is deferred\n     *   'defer': true,\n     *\n     *   // benchmark test function\n     *   'fn': function(deferred) {\n     *     // call `Deferred#resolve` when the deferred test is finished\n     *     deferred.resolve();\n     *   }\n     * });\n     *\n     * // or options only\n     * var bench = new Benchmark({\n     *\n     *   // benchmark name\n     *   'name': 'foo',\n     *\n     *   // benchmark test as a string\n     *   'fn': '[1,2,3,4].sort()'\n     * });\n     *\n     * // a test's `this` binding is set to the benchmark instance\n     * var bench = new Benchmark('foo', function() {\n     *   'My name is '.concat(this.name); // \"My name is foo\"\n     * });\n     */\n    function Benchmark(name, fn, options) {\n      var bench = this;\n\n      // Allow instance creation without the `new` operator.\n      if (!(bench instanceof Benchmark)) {\n        return new Benchmark(name, fn, options);\n      }\n      // Juggle arguments.\n      if (_.isPlainObject(name)) {\n        // 1 argument (options).\n        options = name;\n      }\n      else if (_.isFunction(name)) {\n        // 2 arguments (fn, options).\n        options = fn;\n        fn = name;\n      }\n      else if (_.isPlainObject(fn)) {\n        // 2 arguments (name, options).\n        options = fn;\n        fn = null;\n        bench.name = name;\n      }\n      else {\n        // 3 arguments (name, fn [, options]).\n        bench.name = name;\n      }\n      setOptions(bench, options);\n\n      bench.id || (bench.id = ++counter);\n      bench.fn == null && (bench.fn = fn);\n\n      bench.stats = cloneDeep(bench.stats);\n      bench.times = cloneDeep(bench.times);\n    }\n\n    /**\n     * The Deferred constructor.\n     *\n     * @constructor\n     * @memberOf Benchmark\n     * @param {Object} clone The cloned benchmark instance.\n     */\n    function Deferred(clone) {\n      var deferred = this;\n      if (!(deferred instanceof Deferred)) {\n        return new Deferred(clone);\n      }\n      deferred.benchmark = clone;\n      clock(deferred);\n    }\n\n    /**\n     * The Event constructor.\n     *\n     * @constructor\n     * @memberOf Benchmark\n     * @param {Object|string} type The event type.\n     */\n    function Event(type) {\n      var event = this;\n      if (type instanceof Event) {\n        return type;\n      }\n      return (event instanceof Event)\n        ? _.assign(event, { 'timeStamp': _.now() }, typeof type == 'string' ? { 'type': type } : type)\n        : new Event(type);\n    }\n\n    /**\n     * The Suite constructor.\n     *\n     * Note: Each Suite instance has a handful of wrapped lodash methods to\n     * make working with Suites easier. The wrapped lodash methods are:\n     * [`each/forEach`](https://lodash.com/docs#forEach), [`indexOf`](https://lodash.com/docs#indexOf),\n     * [`map`](https://lodash.com/docs#map), and [`reduce`](https://lodash.com/docs#reduce)\n     *\n     * @constructor\n     * @memberOf Benchmark\n     * @param {string} name A name to identify the suite.\n     * @param {Object} [options={}] Options object.\n     * @example\n     *\n     * // basic usage (the `new` operator is optional)\n     * var suite = new Benchmark.Suite;\n     *\n     * // or using a name first\n     * var suite = new Benchmark.Suite('foo');\n     *\n     * // or with options\n     * var suite = new Benchmark.Suite('foo', {\n     *\n     *   // called when the suite starts running\n     *   'onStart': onStart,\n     *\n     *   // called between running benchmarks\n     *   'onCycle': onCycle,\n     *\n     *   // called when aborted\n     *   'onAbort': onAbort,\n     *\n     *   // called when a test errors\n     *   'onError': onError,\n     *\n     *   // called when reset\n     *   'onReset': onReset,\n     *\n     *   // called when the suite completes running\n     *   'onComplete': onComplete\n     * });\n     */\n    function Suite(name, options) {\n      var suite = this;\n\n      // Allow instance creation without the `new` operator.\n      if (!(suite instanceof Suite)) {\n        return new Suite(name, options);\n      }\n      // Juggle arguments.\n      if (_.isPlainObject(name)) {\n        // 1 argument (options).\n        options = name;\n      } else {\n        // 2 arguments (name [, options]).\n        suite.name = name;\n      }\n      setOptions(suite, options);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * A specialized version of `_.cloneDeep` which only clones arrays and plain\n     * objects assigning all other values by reference.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @returns {*} The cloned value.\n     */\n    var cloneDeep = _.partial(_.cloneDeepWith, _, function(value) {\n      // Only clone primitives, arrays, and plain objects.\n      if (!_.isArray(value) && !_.isPlainObject(value)) {\n        return value;\n      }\n    });\n\n    /**\n     * Creates a function from the given arguments string and body.\n     *\n     * @private\n     * @param {string} args The comma separated function arguments.\n     * @param {string} body The function body.\n     * @returns {Function} The new function.\n     */\n    function createFunction() {\n      // Lazy define.\n      createFunction = function(args, body) {\n        var result,\n            anchor = freeDefine ? freeDefine.amd : Benchmark,\n            prop = uid + 'createFunction';\n\n        runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');\n        result = anchor[prop];\n        delete anchor[prop];\n        return result;\n      };\n      // Fix JaegerMonkey bug.\n      // For more information see http://bugzil.la/639720.\n      createFunction = support.browser && (createFunction('', 'return\"' + uid + '\"') || _.noop)() == uid ? createFunction : Function;\n      return createFunction.apply(null, arguments);\n    }\n\n    /**\n     * Delay the execution of a function based on the benchmark's `delay` property.\n     *\n     * @private\n     * @param {Object} bench The benchmark instance.\n     * @param {Object} fn The function to execute.\n     */\n    function delay(bench, fn) {\n      bench._timerId = _.delay(fn, bench.delay * 1e3);\n    }\n\n    /**\n     * Destroys the given element.\n     *\n     * @private\n     * @param {Element} element The element to destroy.\n     */\n    function destroyElement(element) {\n      trash.appendChild(element);\n      trash.innerHTML = '';\n    }\n\n    /**\n     * Gets the name of the first argument from a function's source.\n     *\n     * @private\n     * @param {Function} fn The function.\n     * @returns {string} The argument name.\n     */\n    function getFirstArgument(fn) {\n      return (!_.has(fn, 'toString') &&\n        (/^[\\s(]*function[^(]*\\(([^\\s,)]+)/.exec(fn) || 0)[1]) || '';\n    }\n\n    /**\n     * Computes the arithmetic mean of a sample.\n     *\n     * @private\n     * @param {Array} sample The sample.\n     * @returns {number} The mean.\n     */\n    function getMean(sample) {\n      return (_.reduce(sample, function(sum, x) {\n        return sum + x;\n      }) / sample.length) || 0;\n    }\n\n    /**\n     * Gets the source code of a function.\n     *\n     * @private\n     * @param {Function} fn The function.\n     * @returns {string} The function's source code.\n     */\n    function getSource(fn) {\n      var result = '';\n      if (isStringable(fn)) {\n        result = String(fn);\n      } else if (support.decompilation) {\n        // Escape the `{` for Firefox 1.\n        result = _.result(/^[^{]+\\{([\\s\\S]*)\\}\\s*$/.exec(fn), 1);\n      }\n      // Trim string.\n      result = (result || '').replace(/^\\s+|\\s+$/g, '');\n\n      // Detect strings containing only the \"use strict\" directive.\n      return /^(?:\\/\\*+[\\w\\W]*?\\*\\/|\\/\\/.*?[\\n\\r\\u2028\\u2029]|\\s)*([\"'])use strict\\1;?$/.test(result)\n        ? ''\n        : result;\n    }\n\n    /**\n     * Checks if an object is of the specified class.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {string} name The name of the class.\n     * @returns {boolean} Returns `true` if the value is of the specified class, else `false`.\n     */\n    function isClassOf(value, name) {\n      return value != null && toString.call(value) == '[object ' + name + ']';\n    }\n\n    /**\n     * Host objects can return type values that are different from their actual\n     * data type. The objects we are concerned with usually return non-primitive\n     * types of \"object\", \"function\", or \"unknown\".\n     *\n     * @private\n     * @param {*} object The owner of the property.\n     * @param {string} property The property to check.\n     * @returns {boolean} Returns `true` if the property value is a non-primitive, else `false`.\n     */\n    function isHostType(object, property) {\n      if (object == null) {\n        return false;\n      }\n      var type = typeof object[property];\n      return !rePrimitive.test(type) && (type != 'object' || !!object[property]);\n    }\n\n    /**\n     * Checks if a value can be safely coerced to a string.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if the value can be coerced, else `false`.\n     */\n    function isStringable(value) {\n      return _.isString(value) || (_.has(value, 'toString') && _.isFunction(value.toString));\n    }\n\n    /**\n     * A wrapper around `require` to suppress `module missing` errors.\n     *\n     * @private\n     * @param {string} id The module id.\n     * @returns {*} The exported module or `null`.\n     */\n    function require(id) {\n      try {\n        var result = freeExports && freeRequire(id);\n      } catch(e) {}\n      return result || null;\n    }\n\n    /**\n     * Runs a snippet of JavaScript via script injection.\n     *\n     * @private\n     * @param {string} code The code to run.\n     */\n    function runScript(code) {\n      var anchor = freeDefine ? define.amd : Benchmark,\n          script = doc.createElement('script'),\n          sibling = doc.getElementsByTagName('script')[0],\n          parent = sibling.parentNode,\n          prop = uid + 'runScript',\n          prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';\n\n      // Firefox 2.0.0.2 cannot use script injection as intended because it executes\n      // asynchronously, but that's OK because script injection is only used to avoid\n      // the previously commented JaegerMonkey bug.\n      try {\n        // Remove the inserted script *before* running the code to avoid differences\n        // in the expected script element count/order of the document.\n        script.appendChild(doc.createTextNode(prefix + code));\n        anchor[prop] = function() { destroyElement(script); };\n      } catch(e) {\n        parent = parent.cloneNode(false);\n        sibling = null;\n        script.text = code;\n      }\n      parent.insertBefore(script, sibling);\n      delete anchor[prop];\n    }\n\n    /**\n     * A helper function for setting options/event handlers.\n     *\n     * @private\n     * @param {Object} object The benchmark or suite instance.\n     * @param {Object} [options={}] Options object.\n     */\n    function setOptions(object, options) {\n      options = object.options = _.assign({}, cloneDeep(object.constructor.options), cloneDeep(options));\n\n      _.forOwn(options, function(value, key) {\n        if (value != null) {\n          // Add event listeners.\n          if (/^on[A-Z]/.test(key)) {\n            _.each(key.split(' '), function(key) {\n              object.on(key.slice(2).toLowerCase(), value);\n            });\n          } else if (!_.has(object, key)) {\n            object[key] = cloneDeep(value);\n          }\n        }\n      });\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Handles cycling/completing the deferred benchmark.\n     *\n     * @memberOf Benchmark.Deferred\n     */\n    function resolve() {\n      var deferred = this,\n          clone = deferred.benchmark,\n          bench = clone._original;\n\n      if (bench.aborted) {\n        // cycle() -> clone cycle/complete event -> compute()'s invoked bench.run() cycle/complete.\n        deferred.teardown();\n        clone.running = false;\n        cycle(deferred);\n      }\n      else if (++deferred.cycles < clone.count) {\n        clone.compiled.call(deferred, context, timer);\n      }\n      else {\n        timer.stop(deferred);\n        deferred.teardown();\n        delay(clone, function() { cycle(deferred); });\n      }\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * A generic `Array#filter` like method.\n     *\n     * @static\n     * @memberOf Benchmark\n     * @param {Array} array The array to iterate over.\n     * @param {Function|string} callback The function/alias called per iteration.\n     * @returns {Array} A new array of values that passed callback filter.\n     * @example\n     *\n     * // get odd numbers\n     * Benchmark.filter([1, 2, 3, 4, 5], function(n) {\n     *   return n % 2;\n     * }); // -> [1, 3, 5];\n     *\n     * // get fastest benchmarks\n     * Benchmark.filter(benches, 'fastest');\n     *\n     * // get slowest benchmarks\n     * Benchmark.filter(benches, 'slowest');\n     *\n     * // get benchmarks that completed without erroring\n     * Benchmark.filter(benches, 'successful');\n     */\n    function filter(array, callback) {\n      if (callback === 'successful') {\n        // Callback to exclude those that are errored, unrun, or have hz of Infinity.\n        callback = function(bench) {\n          return bench.cycles && _.isFinite(bench.hz) && !bench.error;\n        };\n      }\n      else if (callback === 'fastest' || callback === 'slowest') {\n        // Get successful, sort by period + margin of error, and filter fastest/slowest.\n        var result = filter(array, 'successful').sort(function(a, b) {\n          a = a.stats; b = b.stats;\n          return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback === 'fastest' ? 1 : -1);\n        });\n\n        return _.filter(result, function(bench) {\n          return result[0].compare(bench) == 0;\n        });\n      }\n      return _.filter(array, callback);\n    }\n\n    /**\n     * Converts a number to a more readable comma-separated string representation.\n     *\n     * @static\n     * @memberOf Benchmark\n     * @param {number} number The number to convert.\n     * @returns {string} The more readable string representation.\n     */\n    function formatNumber(number) {\n      number = String(number).split('.');\n      return number[0].replace(/(?=(?:\\d{3})+$)(?!\\b)/g, ',') +\n        (number[1] ? '.' + number[1] : '');\n    }\n\n    /**\n     * Invokes a method on all items in an array.\n     *\n     * @static\n     * @memberOf Benchmark\n     * @param {Array} benches Array of benchmarks to iterate over.\n     * @param {Object|string} name The name of the method to invoke OR options object.\n     * @param {...*} [args] Arguments to invoke the method with.\n     * @returns {Array} A new array of values returned from each method invoked.\n     * @example\n     *\n     * // invoke `reset` on all benchmarks\n     * Benchmark.invoke(benches, 'reset');\n     *\n     * // invoke `emit` with arguments\n     * Benchmark.invoke(benches, 'emit', 'complete', listener);\n     *\n     * // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks\n     * Benchmark.invoke(benches, {\n     *\n     *   // invoke the `run` method\n     *   'name': 'run',\n     *\n     *   // pass a single argument\n     *   'args': true,\n     *\n     *   // treat as queue, removing benchmarks from front of `benches` until empty\n     *   'queued': true,\n     *\n     *   // called before any benchmarks have been invoked.\n     *   'onStart': onStart,\n     *\n     *   // called between invoking benchmarks\n     *   'onCycle': onCycle,\n     *\n     *   // called after all benchmarks have been invoked.\n     *   'onComplete': onComplete\n     * });\n     */\n    function invoke(benches, name) {\n      var args,\n          bench,\n          queued,\n          index = -1,\n          eventProps = { 'currentTarget': benches },\n          options = { 'onStart': _.noop, 'onCycle': _.noop, 'onComplete': _.noop },\n          result = _.toArray(benches);\n\n      /**\n       * Invokes the method of the current object and if synchronous, fetches the next.\n       */\n      function execute() {\n        var listeners,\n            async = isAsync(bench);\n\n        if (async) {\n          // Use `getNext` as the first listener.\n          bench.on('complete', getNext);\n          listeners = bench.events.complete;\n          listeners.splice(0, 0, listeners.pop());\n        }\n        // Execute method.\n        result[index] = _.isFunction(bench && bench[name]) ? bench[name].apply(bench, args) : undefined;\n        // If synchronous return `true` until finished.\n        return !async && getNext();\n      }\n\n      /**\n       * Fetches the next bench or executes `onComplete` callback.\n       */\n      function getNext(event) {\n        var cycleEvent,\n            last = bench,\n            async = isAsync(last);\n\n        if (async) {\n          last.off('complete', getNext);\n          last.emit('complete');\n        }\n        // Emit \"cycle\" event.\n        eventProps.type = 'cycle';\n        eventProps.target = last;\n        cycleEvent = Event(eventProps);\n        options.onCycle.call(benches, cycleEvent);\n\n        // Choose next benchmark if not exiting early.\n        if (!cycleEvent.aborted && raiseIndex() !== false) {\n          bench = queued ? benches[0] : result[index];\n          if (isAsync(bench)) {\n            delay(bench, execute);\n          }\n          else if (async) {\n            // Resume execution if previously asynchronous but now synchronous.\n            while (execute()) {}\n          }\n          else {\n            // Continue synchronous execution.\n            return true;\n          }\n        } else {\n          // Emit \"complete\" event.\n          eventProps.type = 'complete';\n          options.onComplete.call(benches, Event(eventProps));\n        }\n        // When used as a listener `event.aborted = true` will cancel the rest of\n        // the \"complete\" listeners because they were already called above and when\n        // used as part of `getNext` the `return false` will exit the execution while-loop.\n        if (event) {\n          event.aborted = true;\n        } else {\n          return false;\n        }\n      }\n\n      /**\n       * Checks if invoking `Benchmark#run` with asynchronous cycles.\n       */\n      function isAsync(object) {\n        // Avoid using `instanceof` here because of IE memory leak issues with host objects.\n        var async = args[0] && args[0].async;\n        return name == 'run' && (object instanceof Benchmark) &&\n          ((async == null ? object.options.async : async) && support.timeout || object.defer);\n      }\n\n      /**\n       * Raises `index` to the next defined index or returns `false`.\n       */\n      function raiseIndex() {\n        index++;\n\n        // If queued remove the previous bench.\n        if (queued && index > 0) {\n          shift.call(benches);\n        }\n        // If we reached the last index then return `false`.\n        return (queued ? benches.length : index < result.length)\n          ? index\n          : (index = false);\n      }\n      // Juggle arguments.\n      if (_.isString(name)) {\n        // 2 arguments (array, name).\n        args = slice.call(arguments, 2);\n      } else {\n        // 2 arguments (array, options).\n        options = _.assign(options, name);\n        name = options.name;\n        args = _.isArray(args = 'args' in options ? options.args : []) ? args : [args];\n        queued = options.queued;\n      }\n      // Start iterating over the array.\n      if (raiseIndex() !== false) {\n        // Emit \"start\" event.\n        bench = result[index];\n        eventProps.type = 'start';\n        eventProps.target = bench;\n        options.onStart.call(benches, Event(eventProps));\n\n        // End early if the suite was aborted in an \"onStart\" listener.\n        if (name == 'run' && (benches instanceof Suite) && benches.aborted) {\n          // Emit \"cycle\" event.\n          eventProps.type = 'cycle';\n          options.onCycle.call(benches, Event(eventProps));\n          // Emit \"complete\" event.\n          eventProps.type = 'complete';\n          options.onComplete.call(benches, Event(eventProps));\n        }\n        // Start method execution.\n        else {\n          if (isAsync(bench)) {\n            delay(bench, execute);\n          } else {\n            while (execute()) {}\n          }\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates a string of joined array values or object key-value pairs.\n     *\n     * @static\n     * @memberOf Benchmark\n     * @param {Array|Object} object The object to operate on.\n     * @param {string} [separator1=','] The separator used between key-value pairs.\n     * @param {string} [separator2=': '] The separator used between keys and values.\n     * @returns {string} The joined result.\n     */\n    function join(object, separator1, separator2) {\n      var result = [],\n          length = (object = Object(object)).length,\n          arrayLike = length === length >>> 0;\n\n      separator2 || (separator2 = ': ');\n      _.each(object, function(value, key) {\n        result.push(arrayLike ? value : key + separator2 + value);\n      });\n      return result.join(separator1 || ',');\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Aborts all benchmarks in the suite.\n     *\n     * @name abort\n     * @memberOf Benchmark.Suite\n     * @returns {Object} The suite instance.\n     */\n    function abortSuite() {\n      var event,\n          suite = this,\n          resetting = calledBy.resetSuite;\n\n      if (suite.running) {\n        event = Event('abort');\n        suite.emit(event);\n        if (!event.cancelled || resetting) {\n          // Avoid infinite recursion.\n          calledBy.abortSuite = true;\n          suite.reset();\n          delete calledBy.abortSuite;\n\n          if (!resetting) {\n            suite.aborted = true;\n            invoke(suite, 'abort');\n          }\n        }\n      }\n      return suite;\n    }\n\n    /**\n     * Adds a test to the benchmark suite.\n     *\n     * @memberOf Benchmark.Suite\n     * @param {string} name A name to identify the benchmark.\n     * @param {Function|string} fn The test to benchmark.\n     * @param {Object} [options={}] Options object.\n     * @returns {Object} The suite instance.\n     * @example\n     *\n     * // basic usage\n     * suite.add(fn);\n     *\n     * // or using a name first\n     * suite.add('foo', fn);\n     *\n     * // or with options\n     * suite.add('foo', fn, {\n     *   'onCycle': onCycle,\n     *   'onComplete': onComplete\n     * });\n     *\n     * // or name and options\n     * suite.add('foo', {\n     *   'fn': fn,\n     *   'onCycle': onCycle,\n     *   'onComplete': onComplete\n     * });\n     *\n     * // or options only\n     * suite.add({\n     *   'name': 'foo',\n     *   'fn': fn,\n     *   'onCycle': onCycle,\n     *   'onComplete': onComplete\n     * });\n     */\n    function add(name, fn, options) {\n      var suite = this,\n          bench = new Benchmark(name, fn, options),\n          event = Event({ 'type': 'add', 'target': bench });\n\n      if (suite.emit(event), !event.cancelled) {\n        suite.push(bench);\n      }\n      return suite;\n    }\n\n    /**\n     * Creates a new suite with cloned benchmarks.\n     *\n     * @name clone\n     * @memberOf Benchmark.Suite\n     * @param {Object} options Options object to overwrite cloned options.\n     * @returns {Object} The new suite instance.\n     */\n    function cloneSuite(options) {\n      var suite = this,\n          result = new suite.constructor(_.assign({}, suite.options, options));\n\n      // Copy own properties.\n      _.forOwn(suite, function(value, key) {\n        if (!_.has(result, key)) {\n          result[key] = _.isFunction(_.get(value, 'clone'))\n            ? value.clone()\n            : cloneDeep(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * An `Array#filter` like method.\n     *\n     * @name filter\n     * @memberOf Benchmark.Suite\n     * @param {Function|string} callback The function/alias called per iteration.\n     * @returns {Object} A new suite of benchmarks that passed callback filter.\n     */\n    function filterSuite(callback) {\n      var suite = this,\n          result = new suite.constructor(suite.options);\n\n      result.push.apply(result, filter(suite, callback));\n      return result;\n    }\n\n    /**\n     * Resets all benchmarks in the suite.\n     *\n     * @name reset\n     * @memberOf Benchmark.Suite\n     * @returns {Object} The suite instance.\n     */\n    function resetSuite() {\n      var event,\n          suite = this,\n          aborting = calledBy.abortSuite;\n\n      if (suite.running && !aborting) {\n        // No worries, `resetSuite()` is called within `abortSuite()`.\n        calledBy.resetSuite = true;\n        suite.abort();\n        delete calledBy.resetSuite;\n      }\n      // Reset if the state has changed.\n      else if ((suite.aborted || suite.running) &&\n          (suite.emit(event = Event('reset')), !event.cancelled)) {\n        suite.aborted = suite.running = false;\n        if (!aborting) {\n          invoke(suite, 'reset');\n        }\n      }\n      return suite;\n    }\n\n    /**\n     * Runs the suite.\n     *\n     * @name run\n     * @memberOf Benchmark.Suite\n     * @param {Object} [options={}] Options object.\n     * @returns {Object} The suite instance.\n     * @example\n     *\n     * // basic usage\n     * suite.run();\n     *\n     * // or with options\n     * suite.run({ 'async': true, 'queued': true });\n     */\n    function runSuite(options) {\n      var suite = this;\n\n      suite.reset();\n      suite.running = true;\n      options || (options = {});\n\n      invoke(suite, {\n        'name': 'run',\n        'args': options,\n        'queued': options.queued,\n        'onStart': function(event) {\n          suite.emit(event);\n        },\n        'onCycle': function(event) {\n          var bench = event.target;\n          if (bench.error) {\n            suite.emit({ 'type': 'error', 'target': bench });\n          }\n          suite.emit(event);\n          event.aborted = suite.aborted;\n        },\n        'onComplete': function(event) {\n          suite.running = false;\n          suite.emit(event);\n        }\n      });\n      return suite;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Executes all registered listeners of the specified event type.\n     *\n     * @memberOf Benchmark, Benchmark.Suite\n     * @param {Object|string} type The event type or object.\n     * @param {...*} [args] Arguments to invoke the listener with.\n     * @returns {*} Returns the return value of the last listener executed.\n     */\n    function emit(type) {\n      var listeners,\n          object = this,\n          event = Event(type),\n          events = object.events,\n          args = (arguments[0] = event, arguments);\n\n      event.currentTarget || (event.currentTarget = object);\n      event.target || (event.target = object);\n      delete event.result;\n\n      if (events && (listeners = _.has(events, event.type) && events[event.type])) {\n        _.each(listeners.slice(), function(listener) {\n          if ((event.result = listener.apply(object, args)) === false) {\n            event.cancelled = true;\n          }\n          return !event.aborted;\n        });\n      }\n      return event.result;\n    }\n\n    /**\n     * Returns an array of event listeners for a given type that can be manipulated\n     * to add or remove listeners.\n     *\n     * @memberOf Benchmark, Benchmark.Suite\n     * @param {string} type The event type.\n     * @returns {Array} The listeners array.\n     */\n    function listeners(type) {\n      var object = this,\n          events = object.events || (object.events = {});\n\n      return _.has(events, type) ? events[type] : (events[type] = []);\n    }\n\n    /**\n     * Unregisters a listener for the specified event type(s),\n     * or unregisters all listeners for the specified event type(s),\n     * or unregisters all listeners for all event types.\n     *\n     * @memberOf Benchmark, Benchmark.Suite\n     * @param {string} [type] The event type.\n     * @param {Function} [listener] The function to unregister.\n     * @returns {Object} The current instance.\n     * @example\n     *\n     * // unregister a listener for an event type\n     * bench.off('cycle', listener);\n     *\n     * // unregister a listener for multiple event types\n     * bench.off('start cycle', listener);\n     *\n     * // unregister all listeners for an event type\n     * bench.off('cycle');\n     *\n     * // unregister all listeners for multiple event types\n     * bench.off('start cycle complete');\n     *\n     * // unregister all listeners for all event types\n     * bench.off();\n     */\n    function off(type, listener) {\n      var object = this,\n          events = object.events;\n\n      if (!events) {\n        return object;\n      }\n      _.each(type ? type.split(' ') : events, function(listeners, type) {\n        var index;\n        if (typeof listeners == 'string') {\n          type = listeners;\n          listeners = _.has(events, type) && events[type];\n        }\n        if (listeners) {\n          if (listener) {\n            index = _.indexOf(listeners, listener);\n            if (index > -1) {\n              listeners.splice(index, 1);\n            }\n          } else {\n            listeners.length = 0;\n          }\n        }\n      });\n      return object;\n    }\n\n    /**\n     * Registers a listener for the specified event type(s).\n     *\n     * @memberOf Benchmark, Benchmark.Suite\n     * @param {string} type The event type.\n     * @param {Function} listener The function to register.\n     * @returns {Object} The current instance.\n     * @example\n     *\n     * // register a listener for an event type\n     * bench.on('cycle', listener);\n     *\n     * // register a listener for multiple event types\n     * bench.on('start cycle', listener);\n     */\n    function on(type, listener) {\n      var object = this,\n          events = object.events || (object.events = {});\n\n      _.each(type.split(' '), function(type) {\n        (_.has(events, type)\n          ? events[type]\n          : (events[type] = [])\n        ).push(listener);\n      });\n      return object;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Aborts the benchmark without recording times.\n     *\n     * @memberOf Benchmark\n     * @returns {Object} The benchmark instance.\n     */\n    function abort() {\n      var event,\n          bench = this,\n          resetting = calledBy.reset;\n\n      if (bench.running) {\n        event = Event('abort');\n        bench.emit(event);\n        if (!event.cancelled || resetting) {\n          // Avoid infinite recursion.\n          calledBy.abort = true;\n          bench.reset();\n          delete calledBy.abort;\n\n          if (support.timeout) {\n            clearTimeout(bench._timerId);\n            delete bench._timerId;\n          }\n          if (!resetting) {\n            bench.aborted = true;\n            bench.running = false;\n          }\n        }\n      }\n      return bench;\n    }\n\n    /**\n     * Creates a new benchmark using the same test and options.\n     *\n     * @memberOf Benchmark\n     * @param {Object} options Options object to overwrite cloned options.\n     * @returns {Object} The new benchmark instance.\n     * @example\n     *\n     * var bizarro = bench.clone({\n     *   'name': 'doppelganger'\n     * });\n     */\n    function clone(options) {\n      var bench = this,\n          result = new bench.constructor(_.assign({}, bench, options));\n\n      // Correct the `options` object.\n      result.options = _.assign({}, cloneDeep(bench.options), cloneDeep(options));\n\n      // Copy own custom properties.\n      _.forOwn(bench, function(value, key) {\n        if (!_.has(result, key)) {\n          result[key] = cloneDeep(value);\n        }\n      });\n\n      return result;\n    }\n\n    /**\n     * Determines if a benchmark is faster than another.\n     *\n     * @memberOf Benchmark\n     * @param {Object} other The benchmark to compare.\n     * @returns {number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.\n     */\n    function compare(other) {\n      var bench = this;\n\n      // Exit early if comparing the same benchmark.\n      if (bench == other) {\n        return 0;\n      }\n      var critical,\n          zStat,\n          sample1 = bench.stats.sample,\n          sample2 = other.stats.sample,\n          size1 = sample1.length,\n          size2 = sample2.length,\n          maxSize = max(size1, size2),\n          minSize = min(size1, size2),\n          u1 = getU(sample1, sample2),\n          u2 = getU(sample2, sample1),\n          u = min(u1, u2);\n\n      function getScore(xA, sampleB) {\n        return _.reduce(sampleB, function(total, xB) {\n          return total + (xB > xA ? 0 : xB < xA ? 1 : 0.5);\n        }, 0);\n      }\n\n      function getU(sampleA, sampleB) {\n        return _.reduce(sampleA, function(total, xA) {\n          return total + getScore(xA, sampleB);\n        }, 0);\n      }\n\n      function getZ(u) {\n        return (u - ((size1 * size2) / 2)) / sqrt((size1 * size2 * (size1 + size2 + 1)) / 12);\n      }\n      // Reject the null hypothesis the two samples come from the\n      // same population (i.e. have the same median) if...\n      if (size1 + size2 > 30) {\n        // ...the z-stat is greater than 1.96 or less than -1.96\n        // http://www.statisticslectures.com/topics/mannwhitneyu/\n        zStat = getZ(u);\n        return abs(zStat) > 1.96 ? (u == u1 ? 1 : -1) : 0;\n      }\n      // ...the U value is less than or equal the critical U value.\n      critical = maxSize < 5 || minSize < 3 ? 0 : uTable[maxSize][minSize - 3];\n      return u <= critical ? (u == u1 ? 1 : -1) : 0;\n    }\n\n    /**\n     * Reset properties and abort if running.\n     *\n     * @memberOf Benchmark\n     * @returns {Object} The benchmark instance.\n     */\n    function reset() {\n      var bench = this;\n      if (bench.running && !calledBy.abort) {\n        // No worries, `reset()` is called within `abort()`.\n        calledBy.reset = true;\n        bench.abort();\n        delete calledBy.reset;\n        return bench;\n      }\n      var event,\n          index = 0,\n          changes = [],\n          queue = [];\n\n      // A non-recursive solution to check if properties have changed.\n      // For more information see http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4.\n      var data = {\n        'destination': bench,\n        'source': _.assign({}, cloneDeep(bench.constructor.prototype), cloneDeep(bench.options))\n      };\n\n      do {\n        _.forOwn(data.source, function(value, key) {\n          var changed,\n              destination = data.destination,\n              currValue = destination[key];\n\n          // Skip pseudo private properties and event listeners.\n          if (/^_|^events$|^on[A-Z]/.test(key)) {\n            return;\n          }\n          if (_.isObjectLike(value)) {\n            if (_.isArray(value)) {\n              // Check if an array value has changed to a non-array value.\n              if (!_.isArray(currValue)) {\n                changed = true;\n                currValue = [];\n              }\n              // Check if an array has changed its length.\n              if (currValue.length != value.length) {\n                changed = true;\n                currValue = currValue.slice(0, value.length);\n                currValue.length = value.length;\n              }\n            }\n            // Check if an object has changed to a non-object value.\n            else if (!_.isObjectLike(currValue)) {\n              changed = true;\n              currValue = {};\n            }\n            // Register a changed object.\n            if (changed) {\n              changes.push({ 'destination': destination, 'key': key, 'value': currValue });\n            }\n            queue.push({ 'destination': currValue, 'source': value });\n          }\n          // Register a changed primitive.\n          else if (!_.eq(currValue, value) && value !== undefined) {\n            changes.push({ 'destination': destination, 'key': key, 'value': value });\n          }\n        });\n      }\n      while ((data = queue[index++]));\n\n      // If changed emit the `reset` event and if it isn't cancelled reset the benchmark.\n      if (changes.length &&\n          (bench.emit(event = Event('reset')), !event.cancelled)) {\n        _.each(changes, function(data) {\n          data.destination[data.key] = data.value;\n        });\n      }\n      return bench;\n    }\n\n    /**\n     * Displays relevant benchmark information when coerced to a string.\n     *\n     * @name toString\n     * @memberOf Benchmark\n     * @returns {string} A string representation of the benchmark instance.\n     */\n    function toStringBench() {\n      var bench = this,\n          error = bench.error,\n          hz = bench.hz,\n          id = bench.id,\n          stats = bench.stats,\n          size = stats.sample.length,\n          pm = '\\xb1',\n          result = bench.name || (_.isNaN(id) ? id : '<Test #' + id + '>');\n\n      if (error) {\n        var errorStr;\n        if (!_.isObject(error)) {\n          errorStr = String(error);\n        } else if (!_.isError(Error)) {\n          errorStr = join(error);\n        } else {\n          // Error#name and Error#message properties are non-enumerable.\n          errorStr = join(_.assign({ 'name': error.name, 'message': error.message }, error));\n        }\n        result += ': ' + errorStr;\n      }\n      else {\n        result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +\n          stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';\n      }\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Clocks the time taken to execute a test per cycle (secs).\n     *\n     * @private\n     * @param {Object} bench The benchmark instance.\n     * @returns {number} The time taken.\n     */\n    function clock() {\n      var options = Benchmark.options,\n          templateData = {},\n          timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];\n\n      // Lazy define for hi-res timers.\n      clock = function(clone) {\n        var deferred;\n\n        if (clone instanceof Deferred) {\n          deferred = clone;\n          clone = deferred.benchmark;\n        }\n        var bench = clone._original,\n            stringable = isStringable(bench.fn),\n            count = bench.count = clone.count,\n            decompilable = stringable || (support.decompilation && (clone.setup !== _.noop || clone.teardown !== _.noop)),\n            id = bench.id,\n            name = bench.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),\n            result = 0;\n\n        // Init `minTime` if needed.\n        clone.minTime = bench.minTime || (bench.minTime = bench.options.minTime = options.minTime);\n\n        // Compile in setup/teardown functions and the test loop.\n        // Create a new compiled test, instead of using the cached `bench.compiled`,\n        // to avoid potential engine optimizations enabled over the life of the test.\n        var funcBody = deferred\n          ? 'var d#=this,${fnArg}=d#,m#=d#.benchmark._original,f#=m#.fn,su#=m#.setup,td#=m#.teardown;' +\n            // When `deferred.cycles` is `0` then...\n            'if(!d#.cycles){' +\n            // set `deferred.fn`,\n            'd#.fn=function(){var ${fnArg}=d#;if(typeof f#==\"function\"){try{${fn}\\n}catch(e#){f#(d#)}}else{${fn}\\n}};' +\n            // set `deferred.teardown`,\n            'd#.teardown=function(){d#.cycles=0;if(typeof td#==\"function\"){try{${teardown}\\n}catch(e#){td#()}}else{${teardown}\\n}};' +\n            // execute the benchmark's `setup`,\n            'if(typeof su#==\"function\"){try{${setup}\\n}catch(e#){su#()}}else{${setup}\\n};' +\n            // start timer,\n            't#.start(d#);' +\n            // and then execute `deferred.fn` and return a dummy object.\n            '}d#.fn();return{uid:\"${uid}\"}'\n\n          : 'var r#,s#,m#=this,f#=m#.fn,i#=m#.count,n#=t#.ns;${setup}\\n${begin};' +\n            'while(i#--){${fn}\\n}${end};${teardown}\\nreturn{elapsed:r#,uid:\"${uid}\"}';\n\n        var compiled = bench.compiled = clone.compiled = createCompiled(bench, decompilable, deferred, funcBody),\n            isEmpty = !(templateData.fn || stringable);\n\n        try {\n          if (isEmpty) {\n            // Firefox may remove dead code from `Function#toString` results.\n            // For more information see http://bugzil.la/536085.\n            throw new Error('The test \"' + name + '\" is empty. This may be the result of dead code removal.');\n          }\n          else if (!deferred) {\n            // Pretest to determine if compiled code exits early, usually by a\n            // rogue `return` statement, by checking for a return object with the uid.\n            bench.count = 1;\n            compiled = decompilable && (compiled.call(bench, context, timer) || {}).uid == templateData.uid && compiled;\n            bench.count = count;\n          }\n        } catch(e) {\n          compiled = null;\n          clone.error = e || new Error(String(e));\n          bench.count = count;\n        }\n        // Fallback when a test exits early or errors during pretest.\n        if (!compiled && !deferred && !isEmpty) {\n          funcBody = (\n            stringable || (decompilable && !clone.error)\n              ? 'function f#(){${fn}\\n}var r#,s#,m#=this,i#=m#.count'\n              : 'var r#,s#,m#=this,f#=m#.fn,i#=m#.count'\n            ) +\n            ',n#=t#.ns;${setup}\\n${begin};m#.f#=f#;while(i#--){m#.f#()}${end};' +\n            'delete m#.f#;${teardown}\\nreturn{elapsed:r#}';\n\n          compiled = createCompiled(bench, decompilable, deferred, funcBody);\n\n          try {\n            // Pretest one more time to check for errors.\n            bench.count = 1;\n            compiled.call(bench, context, timer);\n            bench.count = count;\n            delete clone.error;\n          }\n          catch(e) {\n            bench.count = count;\n            if (!clone.error) {\n              clone.error = e || new Error(String(e));\n            }\n          }\n        }\n        // If no errors run the full test loop.\n        if (!clone.error) {\n          compiled = bench.compiled = clone.compiled = createCompiled(bench, decompilable, deferred, funcBody);\n          result = compiled.call(deferred || bench, context, timer).elapsed;\n        }\n        return result;\n      };\n\n      /*----------------------------------------------------------------------*/\n\n      /**\n       * Creates a compiled function from the given function `body`.\n       */\n      function createCompiled(bench, decompilable, deferred, body) {\n        var fn = bench.fn,\n            fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '';\n\n        templateData.uid = uid + uidCounter++;\n\n        _.assign(templateData, {\n          'setup': decompilable ? getSource(bench.setup) : interpolate('m#.setup()'),\n          'fn': decompilable ? getSource(fn) : interpolate('m#.fn(' + fnArg + ')'),\n          'fnArg': fnArg,\n          'teardown': decompilable ? getSource(bench.teardown) : interpolate('m#.teardown()')\n        });\n\n        // Use API of chosen timer.\n        if (timer.unit == 'ns') {\n          _.assign(templateData, {\n            'begin': interpolate('s#=n#()'),\n            'end': interpolate('r#=n#(s#);r#=r#[0]+(r#[1]/1e9)')\n          });\n        }\n        else if (timer.unit == 'us') {\n          if (timer.ns.stop) {\n            _.assign(templateData, {\n              'begin': interpolate('s#=n#.start()'),\n              'end': interpolate('r#=n#.microseconds()/1e6')\n            });\n          } else {\n            _.assign(templateData, {\n              'begin': interpolate('s#=n#()'),\n              'end': interpolate('r#=(n#()-s#)/1e6')\n            });\n          }\n        }\n        else if (timer.ns.now) {\n          _.assign(templateData, {\n            'begin': interpolate('s#=n#.now()'),\n            'end': interpolate('r#=(n#.now()-s#)/1e3')\n          });\n        }\n        else {\n          _.assign(templateData, {\n            'begin': interpolate('s#=new n#().getTime()'),\n            'end': interpolate('r#=(new n#().getTime()-s#)/1e3')\n          });\n        }\n        // Define `timer` methods.\n        timer.start = createFunction(\n          interpolate('o#'),\n          interpolate('var n#=this.ns,${begin};o#.elapsed=0;o#.timeStamp=s#')\n        );\n\n        timer.stop = createFunction(\n          interpolate('o#'),\n          interpolate('var n#=this.ns,s#=o#.timeStamp,${end};o#.elapsed=r#')\n        );\n\n        // Create compiled test.\n        return createFunction(\n          interpolate('window,t#'),\n          'var global = window, clearTimeout = global.clearTimeout, setTimeout = global.setTimeout;\\n' +\n          interpolate(body)\n        );\n      }\n\n      /**\n       * Gets the current timer's minimum resolution (secs).\n       */\n      function getRes(unit) {\n        var measured,\n            begin,\n            count = 30,\n            divisor = 1e3,\n            ns = timer.ns,\n            sample = [];\n\n        // Get average smallest measurable time.\n        while (count--) {\n          if (unit == 'us') {\n            divisor = 1e6;\n            if (ns.stop) {\n              ns.start();\n              while (!(measured = ns.microseconds())) {}\n            } else {\n              begin = ns();\n              while (!(measured = ns() - begin)) {}\n            }\n          }\n          else if (unit == 'ns') {\n            divisor = 1e9;\n            begin = (begin = ns())[0] + (begin[1] / divisor);\n            while (!(measured = ((measured = ns())[0] + (measured[1] / divisor)) - begin)) {}\n            divisor = 1;\n          }\n          else if (ns.now) {\n            begin = ns.now();\n            while (!(measured = ns.now() - begin)) {}\n          }\n          else {\n            begin = new ns().getTime();\n            while (!(measured = new ns().getTime() - begin)) {}\n          }\n          // Check for broken timers.\n          if (measured > 0) {\n            sample.push(measured);\n          } else {\n            sample.push(Infinity);\n            break;\n          }\n        }\n        // Convert to seconds.\n        return getMean(sample) / divisor;\n      }\n\n      /**\n       * Interpolates a given template string.\n       */\n      function interpolate(string) {\n        // Replaces all occurrences of `#` with a unique number and template tokens with content.\n        return _.template(string.replace(/\\#/g, /\\d+/.exec(templateData.uid)))(templateData);\n      }\n\n      /*----------------------------------------------------------------------*/\n\n      // Detect Chrome's microsecond timer:\n      // enable benchmarking via the --enable-benchmarking command\n      // line switch in at least Chrome 7 to use chrome.Interval\n      try {\n        if ((timer.ns = new (context.chrome || context.chromium).Interval)) {\n          timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });\n        }\n      } catch(e) {}\n\n      // Detect Node.js's nanosecond resolution timer available in Node.js >= 0.8.\n      if (processObject && typeof (timer.ns = processObject.hrtime) == 'function') {\n        timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });\n      }\n      // Detect Wade Simmons' Node.js `microtime` module.\n      if (microtimeObject && typeof (timer.ns = microtimeObject.now) == 'function') {\n        timers.push({ 'ns': timer.ns,  'res': getRes('us'), 'unit': 'us' });\n      }\n      // Pick timer with highest resolution.\n      timer = _.minBy(timers, 'res');\n\n      // Error if there are no working timers.\n      if (timer.res == Infinity) {\n        throw new Error('Benchmark.js was unable to find a working timer.');\n      }\n      // Resolve time span required to achieve a percent uncertainty of at most 1%.\n      // For more information see http://spiff.rit.edu/classes/phys273/uncert/uncert.html.\n      options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));\n      return clock.apply(null, arguments);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Computes stats on benchmark results.\n     *\n     * @private\n     * @param {Object} bench The benchmark instance.\n     * @param {Object} options The options object.\n     */\n    function compute(bench, options) {\n      options || (options = {});\n\n      var async = options.async,\n          elapsed = 0,\n          initCount = bench.initCount,\n          minSamples = bench.minSamples,\n          queue = [],\n          sample = bench.stats.sample;\n\n      /**\n       * Adds a clone to the queue.\n       */\n      function enqueue() {\n        queue.push(_.assign(bench.clone(), {\n          '_original': bench,\n          'events': {\n            'abort': [update],\n            'cycle': [update],\n            'error': [update],\n            'start': [update]\n          }\n        }));\n      }\n\n      /**\n       * Updates the clone/original benchmarks to keep their data in sync.\n       */\n      function update(event) {\n        var clone = this,\n            type = event.type;\n\n        if (bench.running) {\n          if (type == 'start') {\n            // Note: `clone.minTime` prop is inited in `clock()`.\n            clone.count = bench.initCount;\n          }\n          else {\n            if (type == 'error') {\n              bench.error = clone.error;\n            }\n            if (type == 'abort') {\n              bench.abort();\n              bench.emit('cycle');\n            } else {\n              event.currentTarget = event.target = bench;\n              bench.emit(event);\n            }\n          }\n        } else if (bench.aborted) {\n          // Clear abort listeners to avoid triggering bench's abort/cycle again.\n          clone.events.abort.length = 0;\n          clone.abort();\n        }\n      }\n\n      /**\n       * Determines if more clones should be queued or if cycling should stop.\n       */\n      function evaluate(event) {\n        var critical,\n            df,\n            mean,\n            moe,\n            rme,\n            sd,\n            sem,\n            variance,\n            clone = event.target,\n            done = bench.aborted,\n            now = _.now(),\n            size = sample.push(clone.times.period),\n            maxedOut = size >= minSamples && (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,\n            times = bench.times,\n            varOf = function(sum, x) { return sum + pow(x - mean, 2); };\n\n        // Exit early for aborted or unclockable tests.\n        if (done || clone.hz == Infinity) {\n          maxedOut = !(size = sample.length = queue.length = 0);\n        }\n\n        if (!done) {\n          // Compute the sample mean (estimate of the population mean).\n          mean = getMean(sample);\n          // Compute the sample variance (estimate of the population variance).\n          variance = _.reduce(sample, varOf, 0) / (size - 1) || 0;\n          // Compute the sample standard deviation (estimate of the population standard deviation).\n          sd = sqrt(variance);\n          // Compute the standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean).\n          sem = sd / sqrt(size);\n          // Compute the degrees of freedom.\n          df = size - 1;\n          // Compute the critical value.\n          critical = tTable[Math.round(df) || 1] || tTable.infinity;\n          // Compute the margin of error.\n          moe = sem * critical;\n          // Compute the relative margin of error.\n          rme = (moe / mean) * 100 || 0;\n\n          _.assign(bench.stats, {\n            'deviation': sd,\n            'mean': mean,\n            'moe': moe,\n            'rme': rme,\n            'sem': sem,\n            'variance': variance\n          });\n\n          // Abort the cycle loop when the minimum sample size has been collected\n          // and the elapsed time exceeds the maximum time allowed per benchmark.\n          // We don't count cycle delays toward the max time because delays may be\n          // increased by browsers that clamp timeouts for inactive tabs. For more\n          // information see https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs.\n          if (maxedOut) {\n            // Reset the `initCount` in case the benchmark is rerun.\n            bench.initCount = initCount;\n            bench.running = false;\n            done = true;\n            times.elapsed = (now - times.timeStamp) / 1e3;\n          }\n          if (bench.hz != Infinity) {\n            bench.hz = 1 / mean;\n            times.cycle = mean * bench.count;\n            times.period = mean;\n          }\n        }\n        // If time permits, increase sample size to reduce the margin of error.\n        if (queue.length < 2 && !maxedOut) {\n          enqueue();\n        }\n        // Abort the `invoke` cycle when done.\n        event.aborted = done;\n      }\n\n      // Init queue and begin.\n      enqueue();\n      invoke(queue, {\n        'name': 'run',\n        'args': { 'async': async },\n        'queued': true,\n        'onCycle': evaluate,\n        'onComplete': function() { bench.emit('complete'); }\n      });\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Cycles a benchmark until a run `count` can be established.\n     *\n     * @private\n     * @param {Object} clone The cloned benchmark instance.\n     * @param {Object} options The options object.\n     */\n    function cycle(clone, options) {\n      options || (options = {});\n\n      var deferred;\n      if (clone instanceof Deferred) {\n        deferred = clone;\n        clone = clone.benchmark;\n      }\n      var clocked,\n          cycles,\n          divisor,\n          event,\n          minTime,\n          period,\n          async = options.async,\n          bench = clone._original,\n          count = clone.count,\n          times = clone.times;\n\n      // Continue, if not aborted between cycles.\n      if (clone.running) {\n        // `minTime` is set to `Benchmark.options.minTime` in `clock()`.\n        cycles = ++clone.cycles;\n        clocked = deferred ? deferred.elapsed : clock(clone);\n        minTime = clone.minTime;\n\n        if (cycles > bench.cycles) {\n          bench.cycles = cycles;\n        }\n        if (clone.error) {\n          event = Event('error');\n          event.message = clone.error;\n          clone.emit(event);\n          if (!event.cancelled) {\n            clone.abort();\n          }\n        }\n      }\n      // Continue, if not errored.\n      if (clone.running) {\n        // Compute the time taken to complete last test cycle.\n        bench.times.cycle = times.cycle = clocked;\n        // Compute the seconds per operation.\n        period = bench.times.period = times.period = clocked / count;\n        // Compute the ops per second.\n        bench.hz = clone.hz = 1 / period;\n        // Avoid working our way up to this next time.\n        bench.initCount = clone.initCount = count;\n        // Do we need to do another cycle?\n        clone.running = clocked < minTime;\n\n        if (clone.running) {\n          // Tests may clock at `0` when `initCount` is a small number,\n          // to avoid that we set its count to something a bit higher.\n          if (!clocked && (divisor = divisors[clone.cycles]) != null) {\n            count = floor(4e6 / divisor);\n          }\n          // Calculate how many more iterations it will take to achieve the `minTime`.\n          if (count <= clone.count) {\n            count += Math.ceil((minTime - clocked) / period);\n          }\n          clone.running = count != Infinity;\n        }\n      }\n      // Should we exit early?\n      event = Event('cycle');\n      clone.emit(event);\n      if (event.aborted) {\n        clone.abort();\n      }\n      // Figure out what to do next.\n      if (clone.running) {\n        // Start a new cycle.\n        clone.count = count;\n        if (deferred) {\n          clone.compiled.call(deferred, context, timer);\n        } else if (async) {\n          delay(clone, function() { cycle(clone, options); });\n        } else {\n          cycle(clone);\n        }\n      }\n      else {\n        // Fix TraceMonkey bug associated with clock fallbacks.\n        // For more information see http://bugzil.la/509069.\n        if (support.browser) {\n          runScript(uid + '=1;delete ' + uid);\n        }\n        // We're done.\n        clone.emit('complete');\n      }\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Runs the benchmark.\n     *\n     * @memberOf Benchmark\n     * @param {Object} [options={}] Options object.\n     * @returns {Object} The benchmark instance.\n     * @example\n     *\n     * // basic usage\n     * bench.run();\n     *\n     * // or with options\n     * bench.run({ 'async': true });\n     */\n    function run(options) {\n      var bench = this,\n          event = Event('start');\n\n      // Set `running` to `false` so `reset()` won't call `abort()`.\n      bench.running = false;\n      bench.reset();\n      bench.running = true;\n\n      bench.count = bench.initCount;\n      bench.times.timeStamp = _.now();\n      bench.emit(event);\n\n      if (!event.cancelled) {\n        options = { 'async': ((options = options && options.async) == null ? bench.async : options) && support.timeout };\n\n        // For clones created within `compute()`.\n        if (bench._original) {\n          if (bench.defer) {\n            Deferred(bench);\n          } else {\n            cycle(bench, options);\n          }\n        }\n        // For original benchmarks.\n        else {\n          compute(bench, options);\n        }\n      }\n      return bench;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Firefox 1 erroneously defines variable and argument names of functions on\n    // the function itself as non-configurable properties with `undefined` values.\n    // The bugginess continues as the `Benchmark` constructor has an argument\n    // named `options` and Firefox 1 will not assign a value to `Benchmark.options`,\n    // making it non-writable in the process, unless it is the first property\n    // assigned by for-in loop of `_.assign()`.\n    _.assign(Benchmark, {\n\n      /**\n       * The default options copied by benchmark instances.\n       *\n       * @static\n       * @memberOf Benchmark\n       * @type Object\n       */\n      'options': {\n\n        /**\n         * A flag to indicate that benchmark cycles will execute asynchronously\n         * by default.\n         *\n         * @memberOf Benchmark.options\n         * @type boolean\n         */\n        'async': false,\n\n        /**\n         * A flag to indicate that the benchmark clock is deferred.\n         *\n         * @memberOf Benchmark.options\n         * @type boolean\n         */\n        'defer': false,\n\n        /**\n         * The delay between test cycles (secs).\n         * @memberOf Benchmark.options\n         * @type number\n         */\n        'delay': 0.005,\n\n        /**\n         * Displayed by `Benchmark#toString` when a `name` is not available\n         * (auto-generated if absent).\n         *\n         * @memberOf Benchmark.options\n         * @type string\n         */\n        'id': undefined,\n\n        /**\n         * The default number of times to execute a test on a benchmark's first cycle.\n         *\n         * @memberOf Benchmark.options\n         * @type number\n         */\n        'initCount': 1,\n\n        /**\n         * The maximum time a benchmark is allowed to run before finishing (secs).\n         *\n         * Note: Cycle delays aren't counted toward the maximum time.\n         *\n         * @memberOf Benchmark.options\n         * @type number\n         */\n        'maxTime': 5,\n\n        /**\n         * The minimum sample size required to perform statistical analysis.\n         *\n         * @memberOf Benchmark.options\n         * @type number\n         */\n        'minSamples': 5,\n\n        /**\n         * The time needed to reduce the percent uncertainty of measurement to 1% (secs).\n         *\n         * @memberOf Benchmark.options\n         * @type number\n         */\n        'minTime': 0,\n\n        /**\n         * The name of the benchmark.\n         *\n         * @memberOf Benchmark.options\n         * @type string\n         */\n        'name': undefined,\n\n        /**\n         * An event listener called when the benchmark is aborted.\n         *\n         * @memberOf Benchmark.options\n         * @type Function\n         */\n        'onAbort': undefined,\n\n        /**\n         * An event listener called when the benchmark completes running.\n         *\n         * @memberOf Benchmark.options\n         * @type Function\n         */\n        'onComplete': undefined,\n\n        /**\n         * An event listener called after each run cycle.\n         *\n         * @memberOf Benchmark.options\n         * @type Function\n         */\n        'onCycle': undefined,\n\n        /**\n         * An event listener called when a test errors.\n         *\n         * @memberOf Benchmark.options\n         * @type Function\n         */\n        'onError': undefined,\n\n        /**\n         * An event listener called when the benchmark is reset.\n         *\n         * @memberOf Benchmark.options\n         * @type Function\n         */\n        'onReset': undefined,\n\n        /**\n         * An event listener called when the benchmark starts running.\n         *\n         * @memberOf Benchmark.options\n         * @type Function\n         */\n        'onStart': undefined\n      },\n\n      /**\n       * Platform object with properties describing things like browser name,\n       * version, and operating system. See [`platform.js`](https://mths.be/platform).\n       *\n       * @static\n       * @memberOf Benchmark\n       * @type Object\n       */\n      'platform': context.platform || require('platform') || ({\n        'description': context.navigator && context.navigator.userAgent || null,\n        'layout': null,\n        'product': null,\n        'name': null,\n        'manufacturer': null,\n        'os': null,\n        'prerelease': null,\n        'version': null,\n        'toString': function() {\n          return this.description || '';\n        }\n      }),\n\n      /**\n       * The semantic version number.\n       *\n       * @static\n       * @memberOf Benchmark\n       * @type string\n       */\n      'version': '2.1.4'\n    });\n\n    _.assign(Benchmark, {\n      'filter': filter,\n      'formatNumber': formatNumber,\n      'invoke': invoke,\n      'join': join,\n      'runInContext': runInContext,\n      'support': support\n    });\n\n    // Add lodash methods to Benchmark.\n    _.each(['each', 'forEach', 'forOwn', 'has', 'indexOf', 'map', 'reduce'], function(methodName) {\n      Benchmark[methodName] = _[methodName];\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    _.assign(Benchmark.prototype, {\n\n      /**\n       * The number of times a test was executed.\n       *\n       * @memberOf Benchmark\n       * @type number\n       */\n      'count': 0,\n\n      /**\n       * The number of cycles performed while benchmarking.\n       *\n       * @memberOf Benchmark\n       * @type number\n       */\n      'cycles': 0,\n\n      /**\n       * The number of executions per second.\n       *\n       * @memberOf Benchmark\n       * @type number\n       */\n      'hz': 0,\n\n      /**\n       * The compiled test function.\n       *\n       * @memberOf Benchmark\n       * @type {Function|string}\n       */\n      'compiled': undefined,\n\n      /**\n       * The error object if the test failed.\n       *\n       * @memberOf Benchmark\n       * @type Object\n       */\n      'error': undefined,\n\n      /**\n       * The test to benchmark.\n       *\n       * @memberOf Benchmark\n       * @type {Function|string}\n       */\n      'fn': undefined,\n\n      /**\n       * A flag to indicate if the benchmark is aborted.\n       *\n       * @memberOf Benchmark\n       * @type boolean\n       */\n      'aborted': false,\n\n      /**\n       * A flag to indicate if the benchmark is running.\n       *\n       * @memberOf Benchmark\n       * @type boolean\n       */\n      'running': false,\n\n      /**\n       * Compiled into the test and executed immediately **before** the test loop.\n       *\n       * @memberOf Benchmark\n       * @type {Function|string}\n       * @example\n       *\n       * // basic usage\n       * var bench = Benchmark({\n       *   'setup': function() {\n       *     var c = this.count,\n       *         element = document.getElementById('container');\n       *     while (c--) {\n       *       element.appendChild(document.createElement('div'));\n       *     }\n       *   },\n       *   'fn': function() {\n       *     element.removeChild(element.lastChild);\n       *   }\n       * });\n       *\n       * // compiles to something like:\n       * var c = this.count,\n       *     element = document.getElementById('container');\n       * while (c--) {\n       *   element.appendChild(document.createElement('div'));\n       * }\n       * var start = new Date;\n       * while (count--) {\n       *   element.removeChild(element.lastChild);\n       * }\n       * var end = new Date - start;\n       *\n       * // or using strings\n       * var bench = Benchmark({\n       *   'setup': '\\\n       *     var a = 0;\\n\\\n       *     (function() {\\n\\\n       *       (function() {\\n\\\n       *         (function() {',\n       *   'fn': 'a += 1;',\n       *   'teardown': '\\\n       *          }())\\n\\\n       *        }())\\n\\\n       *      }())'\n       * });\n       *\n       * // compiles to something like:\n       * var a = 0;\n       * (function() {\n       *   (function() {\n       *     (function() {\n       *       var start = new Date;\n       *       while (count--) {\n       *         a += 1;\n       *       }\n       *       var end = new Date - start;\n       *     }())\n       *   }())\n       * }())\n       */\n      'setup': _.noop,\n\n      /**\n       * Compiled into the test and executed immediately **after** the test loop.\n       *\n       * @memberOf Benchmark\n       * @type {Function|string}\n       */\n      'teardown': _.noop,\n\n      /**\n       * An object of stats including mean, margin or error, and standard deviation.\n       *\n       * @memberOf Benchmark\n       * @type Object\n       */\n      'stats': {\n\n        /**\n         * The margin of error.\n         *\n         * @memberOf Benchmark#stats\n         * @type number\n         */\n        'moe': 0,\n\n        /**\n         * The relative margin of error (expressed as a percentage of the mean).\n         *\n         * @memberOf Benchmark#stats\n         * @type number\n         */\n        'rme': 0,\n\n        /**\n         * The standard error of the mean.\n         *\n         * @memberOf Benchmark#stats\n         * @type number\n         */\n        'sem': 0,\n\n        /**\n         * The sample standard deviation.\n         *\n         * @memberOf Benchmark#stats\n         * @type number\n         */\n        'deviation': 0,\n\n        /**\n         * The sample arithmetic mean (secs).\n         *\n         * @memberOf Benchmark#stats\n         * @type number\n         */\n        'mean': 0,\n\n        /**\n         * The array of sampled periods.\n         *\n         * @memberOf Benchmark#stats\n         * @type Array\n         */\n        'sample': [],\n\n        /**\n         * The sample variance.\n         *\n         * @memberOf Benchmark#stats\n         * @type number\n         */\n        'variance': 0\n      },\n\n      /**\n       * An object of timing data including cycle, elapsed, period, start, and stop.\n       *\n       * @memberOf Benchmark\n       * @type Object\n       */\n      'times': {\n\n        /**\n         * The time taken to complete the last cycle (secs).\n         *\n         * @memberOf Benchmark#times\n         * @type number\n         */\n        'cycle': 0,\n\n        /**\n         * The time taken to complete the benchmark (secs).\n         *\n         * @memberOf Benchmark#times\n         * @type number\n         */\n        'elapsed': 0,\n\n        /**\n         * The time taken to execute the test once (secs).\n         *\n         * @memberOf Benchmark#times\n         * @type number\n         */\n        'period': 0,\n\n        /**\n         * A timestamp of when the benchmark started (ms).\n         *\n         * @memberOf Benchmark#times\n         * @type number\n         */\n        'timeStamp': 0\n      }\n    });\n\n    _.assign(Benchmark.prototype, {\n      'abort': abort,\n      'clone': clone,\n      'compare': compare,\n      'emit': emit,\n      'listeners': listeners,\n      'off': off,\n      'on': on,\n      'reset': reset,\n      'run': run,\n      'toString': toStringBench\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    _.assign(Deferred.prototype, {\n\n      /**\n       * The deferred benchmark instance.\n       *\n       * @memberOf Benchmark.Deferred\n       * @type Object\n       */\n      'benchmark': null,\n\n      /**\n       * The number of deferred cycles performed while benchmarking.\n       *\n       * @memberOf Benchmark.Deferred\n       * @type number\n       */\n      'cycles': 0,\n\n      /**\n       * The time taken to complete the deferred benchmark (secs).\n       *\n       * @memberOf Benchmark.Deferred\n       * @type number\n       */\n      'elapsed': 0,\n\n      /**\n       * A timestamp of when the deferred benchmark started (ms).\n       *\n       * @memberOf Benchmark.Deferred\n       * @type number\n       */\n      'timeStamp': 0\n    });\n\n    _.assign(Deferred.prototype, {\n      'resolve': resolve\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    _.assign(Event.prototype, {\n\n      /**\n       * A flag to indicate if the emitters listener iteration is aborted.\n       *\n       * @memberOf Benchmark.Event\n       * @type boolean\n       */\n      'aborted': false,\n\n      /**\n       * A flag to indicate if the default action is cancelled.\n       *\n       * @memberOf Benchmark.Event\n       * @type boolean\n       */\n      'cancelled': false,\n\n      /**\n       * The object whose listeners are currently being processed.\n       *\n       * @memberOf Benchmark.Event\n       * @type Object\n       */\n      'currentTarget': undefined,\n\n      /**\n       * The return value of the last executed listener.\n       *\n       * @memberOf Benchmark.Event\n       * @type Mixed\n       */\n      'result': undefined,\n\n      /**\n       * The object to which the event was originally emitted.\n       *\n       * @memberOf Benchmark.Event\n       * @type Object\n       */\n      'target': undefined,\n\n      /**\n       * A timestamp of when the event was created (ms).\n       *\n       * @memberOf Benchmark.Event\n       * @type number\n       */\n      'timeStamp': 0,\n\n      /**\n       * The event type.\n       *\n       * @memberOf Benchmark.Event\n       * @type string\n       */\n      'type': ''\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The default options copied by suite instances.\n     *\n     * @static\n     * @memberOf Benchmark.Suite\n     * @type Object\n     */\n    Suite.options = {\n\n      /**\n       * The name of the suite.\n       *\n       * @memberOf Benchmark.Suite.options\n       * @type string\n       */\n      'name': undefined\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    _.assign(Suite.prototype, {\n\n      /**\n       * The number of benchmarks in the suite.\n       *\n       * @memberOf Benchmark.Suite\n       * @type number\n       */\n      'length': 0,\n\n      /**\n       * A flag to indicate if the suite is aborted.\n       *\n       * @memberOf Benchmark.Suite\n       * @type boolean\n       */\n      'aborted': false,\n\n      /**\n       * A flag to indicate if the suite is running.\n       *\n       * @memberOf Benchmark.Suite\n       * @type boolean\n       */\n      'running': false\n    });\n\n    _.assign(Suite.prototype, {\n      'abort': abortSuite,\n      'add': add,\n      'clone': cloneSuite,\n      'emit': emit,\n      'filter': filterSuite,\n      'join': arrayRef.join,\n      'listeners': listeners,\n      'off': off,\n      'on': on,\n      'pop': arrayRef.pop,\n      'push': push,\n      'reset': resetSuite,\n      'run': runSuite,\n      'reverse': arrayRef.reverse,\n      'shift': shift,\n      'slice': slice,\n      'sort': arrayRef.sort,\n      'splice': arrayRef.splice,\n      'unshift': unshift\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    // Expose Deferred, Event, and Suite.\n    _.assign(Benchmark, {\n      'Deferred': Deferred,\n      'Event': Event,\n      'Suite': Suite\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    // Add lodash methods as Suite methods.\n    _.each(['each', 'forEach', 'indexOf', 'map', 'reduce'], function(methodName) {\n      var func = _[methodName];\n      Suite.prototype[methodName] = function() {\n        var args = [this];\n        push.apply(args, arguments);\n        return func.apply(_, args);\n      };\n    });\n\n    // Avoid array-like object bugs with `Array#shift` and `Array#splice`\n    // in Firefox < 10 and IE < 9.\n    _.each(['pop', 'shift', 'splice'], function(methodName) {\n      var func = arrayRef[methodName];\n\n      Suite.prototype[methodName] = function() {\n        var value = this,\n            result = func.apply(value, arguments);\n\n        if (value.length === 0) {\n          delete value[0];\n        }\n        return result;\n      };\n    });\n\n    // Avoid buggy `Array#unshift` in IE < 8 which doesn't return the new\n    // length of the array.\n    Suite.prototype.unshift = function() {\n      var value = this;\n      unshift.apply(value, arguments);\n      return value.length;\n    };\n\n    return Benchmark;\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export Benchmark.\n  // Some AMD build optimizers, like r.js, check for condition patterns like the following:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Define as an anonymous module so, through path mapping, it can be aliased.\n    define(['lodash', 'platform'], function(_, platform) {\n      return runInContext({\n        '_': _,\n        'platform': platform\n      });\n    });\n  }\n  else {\n    var Benchmark = runInContext();\n\n    // Check for `exports` after `define` in case a build optimizer adds an `exports` object.\n    if (freeExports && freeModule) {\n      // Export for Node.js.\n      if (moduleExports) {\n        (freeModule.exports = Benchmark).Benchmark = Benchmark;\n      }\n      // Export for CommonJS support.\n      freeExports.Benchmark = Benchmark;\n    }\n    else {\n      // Export to the global object.\n      root.Benchmark = Benchmark;\n    }\n  }\n}.call(this));\n"]}