/**

 * @license

 * Build: `lodash modern -o ./dist/lodash.js`

 * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>

 * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>

 * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

 */

;(function() {

  /** Used as a safe reference for `undefined` in pre ES5 environments */

  var undefined;

  /** Used to pool arrays and objects used internally */

  var arrayPool = [],

      objectPool = [];

  /** Used to generate unique IDs */

  var idCounter = 0;

  /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */

  var keyPrefix = +new Date + '';

  /** Used as the size when optimizations are enabled for large arrays */

  var largeArraySize = 75;

  /** Used as the max size of the `arrayPool` and `objectPool` */

  var maxPoolSize = 40;

  /** Used to detect and test whitespace */

  var whitespace = (

    // whitespace

    ' \t\x0B\f\xA0\ufeff' +

    // line terminators

    '\n\r\u2028\u2029' +

    // unicode category "Zs" space separators

    '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'

  );

  /** Used to match empty string literals in compiled template source */

  var reEmptyStringLeading = /\b__p \+= '';/g,

      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,

      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

  /**

   * Used to match ES6 template delimiters

   * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals

   */

  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

  /** Used to match regexp flags from their coerced string values */

  var reFlags = /\w*$/;

  /** Used to detected named functions */

  var reFuncName = /^\s*function[ \n\r\t]+\w/;

  /** Used to match "interpolate" template delimiters */

  var reInterpolate = /<%=([\s\S]+?)%>/g;

  /** Used to match leading whitespace and zeros to be removed */

  var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');

  /** Used to ensure capturing order of template delimiters */

  var reNoMatch = /($^)/;

  /** Used to detect functions containing a `this` reference */

  var reThis = /\bthis\b/;

  /** Used to match unescaped characters in compiled string literals */

  var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;

  /** Used to assign default `context` object properties */

  var contextProps = [

    'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object',

    'RegExp', 'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN',

    'parseInt', 'setTimeout'

  ];

  /** Used to make template sourceURLs easier to identify */

  var templateCounter = 0;

  /** `Object#toString` result shortcuts */

  var argsClass = '[object Arguments]',

      arrayClass = '[object Array]',

      boolClass = '[object Boolean]',

      dateClass = '[object Date]',

      funcClass = '[object Function]',

      numberClass = '[object Number]',

      objectClass = '[object Object]',

      regexpClass = '[object RegExp]',

      stringClass = '[object String]';

  /** Used to identify object classifications that `_.clone` supports */

  var cloneableClasses = {};

  cloneableClasses[funcClass] = false;

  cloneableClasses[argsClass] = cloneableClasses[arrayClass] =

  cloneableClasses[boolClass] = cloneableClasses[dateClass] =

  cloneableClasses[numberClass] = cloneableClasses[objectClass] =

  cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;

  /** Used as an internal `_.debounce` options object */

  var debounceOptions = {

    'leading': false,

    'maxWait': 0,

    'trailing': false

  };

  /** Used as the property descriptor for `__bindData__` */

  var descriptor = {

    'configurable': false,

    'enumerable': false,

    'value': null,

    'writable': false

  };

  /** Used to determine if values are of the language type Object */

  var objectTypes = {

    'boolean': false,

    'function': true,

    'object': true,

    'number': false,

    'string': false,

    'undefined': false

  };

  /** Used to escape characters for inclusion in compiled string literals */

  var stringEscapes = {

    '\\': '\\',

    "'": "'",

    '\n': 'n',

    '\r': 'r',

    '\t': 't',

    '\u2028': 'u2028',

    '\u2029': 'u2029'

  };

  /** Used as a reference to the global object */

  var root = (objectTypes[typeof window] && window) || this;

  /** 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 the popular CommonJS extension `module.exports` */

  var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;

  /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */

  var freeGlobal = objectTypes[typeof global] && global;

  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {

    root = freeGlobal;

  }

  /*--------------------------------------------------------------------------*/

  /**

   * The base implementation of `_.indexOf` without support for binary searches

   * or `fromIndex` constraints.

   *

   * @private

   * @param {Array} array The array to search.

   * @param {*} value The value to search for.

   * @param {number} [fromIndex=0] The index to search from.

   * @returns {number} Returns the index of the matched value or `-1`.

   */

  function baseIndexOf(array, value, fromIndex) {

    var index = (fromIndex || 0) - 1,

        length = array ? array.length : 0;

    while (++index < length) {

      if (array[index] === value) {

        return index;

      }

    }

    return -1;

  }

  /**

   * An implementation of `_.contains` for cache objects that mimics the return

   * signature of `_.indexOf` by returning `0` if the value is found, else `-1`.

   *

   * @private

   * @param {Object} cache The cache object to inspect.

   * @param {*} value The value to search for.

   * @returns {number} Returns `0` if `value` is found, else `-1`.

   */

  function cacheIndexOf(cache, value) {

    var type = typeof value;

    cache = cache.cache;

    if (type == 'boolean' || value == null) {

      return cache[value] ? 0 : -1;

    }

    if (type != 'number' && type != 'string') {

      type = 'object';

    }

    var key = type == 'number' ? value : keyPrefix + value;

    cache = (cache = cache[type]) && cache[key];

    return type == 'object'

      ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)

      : (cache ? 0 : -1);

  }

  /**

   * Adds a given value to the corresponding cache object.

   *

   * @private

   * @param {*} value The value to add to the cache.

   */

  function cachePush(value) {

    var cache = this.cache,

        type = typeof value;

    if (type == 'boolean' || value == null) {

      cache[value] = true;

    } else {

      if (type != 'number' && type != 'string') {

        type = 'object';

      }

      var key = type == 'number' ? value : keyPrefix + value,

          typeCache = cache[type] || (cache[type] = {});

      if (type == 'object') {

        (typeCache[key] || (typeCache[key] = [])).push(value);

      } else {

        typeCache[key] = true;

      }

    }

  }

  /**

   * Used by `_.max` and `_.min` as the default callback when a given

   * collection is a string value.

   *

   * @private

   * @param {string} value The character to inspect.

   * @returns {number} Returns the code unit of given character.

   */

  function charAtCallback(value) {

    return value.charCodeAt(0);

  }

  /**

   * Used by `sortBy` to compare transformed `collection` elements, stable sorting

   * them in ascending order.

   *

   * @private

   * @param {Object} a The object to compare to `b`.

   * @param {Object} b The object to compare to `a`.

   * @returns {number} Returns the sort order indicator of `1` or `-1`.

   */

  function compareAscending(a, b) {

    var ac = a.criteria,

        bc = b.criteria,

        index = -1,

        length = ac.length;

    while (++index < length) {

      var value = ac[index],

          other = bc[index];

      if (value !== other) {

        if (value > other || typeof value == 'undefined') {

          return 1;

        }

        if (value < other || typeof other == 'undefined') {

          return -1;

        }

      }

    }

    // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications

    // that causes it, under certain circumstances, to return the same value for

    // `a` and `b`. See https://github.com/jashkenas/underscore/pull/1247

    //

    // This also ensures a stable sort in V8 and other engines.

    // See http://code.google.com/p/v8/issues/detail?id=90

    return a.index - b.index;

  }

  /**

   * Creates a cache object to optimize linear searches of large arrays.

   *

   * @private

   * @param {Array} [array=[]] The array to search.

   * @returns {null|Object} Returns the cache object or `null` if caching should not be used.

   */

  function createCache(array) {

    var index = -1,

        length = array.length,

        first = array[0],

        mid = array[(length / 2) | 0],

        last = array[length - 1];

    if (first && typeof first == 'object' &&

        mid && typeof mid == 'object' && last && typeof last == 'object') {

      return false;

    }

    var cache = getObject();

    cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;

    var result = getObject();

    result.array = array;

    result.cache = cache;

    result.push = cachePush;

    while (++index < length) {

      result.push(array[index]);

    }

    return result;

  }

  /**

   * Used by `template` to escape characters for inclusion in compiled

   * string literals.

   *

   * @private

   * @param {string} match The matched character to escape.

   * @returns {string} Returns the escaped character.

   */

  function escapeStringChar(match) {

    return '\\' + stringEscapes[match];

  }

  /**

   * Gets an array from the array pool or creates a new one if the pool is empty.

   *

   * @private

   * @returns {Array} The array from the pool.

   */

  function getArray() {

    return arrayPool.pop() || [];

  }

  /**

   * Gets an object from the object pool or creates a new one if the pool is empty.

   *

   * @private

   * @returns {Object} The object from the pool.

   */

  function getObject() {

    return objectPool.pop() || {

      'array': null,

      'cache': null,

      'criteria': null,

      'false': false,

      'index': 0,

      'null': false,

      'number': null,

      'object': null,

      'push': null,

      'string': null,

      'true': false,

      'undefined': false,

      'value': null

    };

  }

  /**

   * Releases the given array back to the array pool.

   *

   * @private

   * @param {Array} [array] The array to release.

   */

  function releaseArray(array) {

    array.length = 0;

    if (arrayPool.length < maxPoolSize) {

      arrayPool.push(array);

    }

  }

  /**

   * Releases the given object back to the object pool.

   *

   * @private

   * @param {Object} [object] The object to release.

   */

  function releaseObject(object) {

    var cache = object.cache;

    if (cache) {

      releaseObject(cache);

    }

    object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;

    if (objectPool.length < maxPoolSize) {

      objectPool.push(object);

    }

  }

  /**

   * Slices the `collection` from the `start` index up to, but not including,

   * the `end` index.

   *

   * Note: This function is used instead of `Array#slice` to support node lists

   * in IE < 9 and to ensure dense arrays are returned.

   *

   * @private

   * @param {Array|Object|string} collection The collection to slice.

   * @param {number} start The start index.

   * @param {number} end The end index.

   * @returns {Array} Returns the new array.

   */

  function slice(array, start, end) {

    start || (start = 0);

    if (typeof end == 'undefined') {

      end = array ? array.length : 0;

    }

    var index = -1,

        length = end - start || 0,

        result = Array(length < 0 ? 0 : length);

    while (++index < length) {

      result[index] = array[start + index];

    }

    return result;

  }

  /*--------------------------------------------------------------------------*/

  /**

   * Create a new `lodash` function using the given context object.

   *

   * @static

   * @memberOf _

   * @category Utilities

   * @param {Object} [context=root] The context object.

   * @returns {Function} Returns the `lodash` function.

   */

  function runInContext(context) {

    // 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,

        Boolean = context.Boolean,

        Date = context.Date,

        Function = context.Function,

        Math = context.Math,

        Number = context.Number,

        Object = context.Object,

        RegExp = context.RegExp,

        String = context.String,

        TypeError = context.TypeError;

    /**

     * Used for `Array` method references.

     *

     * Normally `Array.prototype` would suffice, however, using an array literal

     * avoids issues in Narwhal.

     */

    var arrayRef = [];

    /** Used for native method references */

    var objectProto = Object.prototype;

    /** Used to restore the original `_` reference in `noConflict` */

    var oldDash = context._;

    /** Used to resolve the internal [[Class]] of values */

    var toString = objectProto.toString;

    /** Used to detect if a method is native */

    var reNative = RegExp('^' +

      String(toString)

        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')

        .replace(/toString| for [^\]]+/g, '.*?') + '$'

    );

    /** Native method shortcuts */

    var ceil = Math.ceil,

        clearTimeout = context.clearTimeout,

        floor = Math.floor,

        fnToString = Function.prototype.toString,

        getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,

        hasOwnProperty = objectProto.hasOwnProperty,

        push = arrayRef.push,

        setTimeout = context.setTimeout,

        splice = arrayRef.splice,

        unshift = arrayRef.unshift;

    /** Used to set meta data on functions */

    var defineProperty = (function() {

      // IE 8 only accepts DOM elements

      try {

        var o = {},

            func = isNative(func = Object.defineProperty) && func,

            result = func(o, o, o) && func;

      } catch(e) { }

      return result;

    }());

    /* Native method shortcuts for methods with the same name as other `lodash` methods */

    var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate,

        nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray,

        nativeIsFinite = context.isFinite,

        nativeIsNaN = context.isNaN,

        nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys,

        nativeMax = Math.max,

        nativeMin = Math.min,

        nativeParseInt = context.parseInt,

        nativeRandom = Math.random;

    /** Used to lookup a built-in constructor by [[Class]] */

    var ctorByClass = {};

    ctorByClass[arrayClass] = Array;

    ctorByClass[boolClass] = Boolean;

    ctorByClass[dateClass] = Date;

    ctorByClass[funcClass] = Function;

    ctorByClass[objectClass] = Object;

    ctorByClass[numberClass] = Number;

    ctorByClass[regexpClass] = RegExp;

    ctorByClass[stringClass] = String;

    /*--------------------------------------------------------------------------*/

    /**

     * Creates a `lodash` object which wraps the given value to enable intuitive

     * method chaining.

     *

     * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:

     * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,

     * and `unshift`