From db7debd3da15b32fc53015bf1260c87ed9f66b03 Mon Sep 17 00:00:00 2001
From: John-David Dalton <john.david.dalton@gmail.com>
Date: Tue, 2 Feb 2016 00:28:00 -0800
Subject: [PATCH] Move benchmark.js to a dev dep.

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