/**

 * @license

 * lodash 3.10.1 (Custom Build) <https://lodash.com/>

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

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

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

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

 * Available under MIT license <https://lodash.com/license>

 */

;(function() {

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

  var undefined;

  /** Used as the semantic version number. */

  var VERSION = '3.10.1';

  /** Used to compose bitmasks for wrapper metadata. */

  var BIND_FLAG = 1,

      BIND_KEY_FLAG = 2,

      CURRY_BOUND_FLAG = 4,

      CURRY_FLAG = 8,

      CURRY_RIGHT_FLAG = 16,

      PARTIAL_FLAG = 32,

      PARTIAL_RIGHT_FLAG = 64,

      ARY_FLAG = 128,

      REARG_FLAG = 256;

  /** Used as default options for `_.trunc`. */

  var DEFAULT_TRUNC_LENGTH = 30,

      DEFAULT_TRUNC_OMISSION = '...';

  /** Used to detect when a function becomes hot. */

  var HOT_COUNT = 150,

      HOT_SPAN = 16;

  /** Used as the size to enable large array optimizations. */

  var LARGE_ARRAY_SIZE = 200;

  /** Used to indicate the type of lazy iteratees. */

  var LAZY_FILTER_FLAG = 1,

      LAZY_MAP_FLAG = 2;

  /** Used as the `TypeError` message for "Functions" methods. */

  var FUNC_ERROR_TEXT = 'Expected a function';

  /** Used as the internal argument placeholder. */

  var PLACEHOLDER = '__lodash_placeholder__';

  /** `Object#toString` result references. */

  var argsTag = '[object Arguments]',

      arrayTag = '[object Array]',

      boolTag = '[object Boolean]',

      dateTag = '[object Date]',

      errorTag = '[object Error]',

      funcTag = '[object Function]',

      mapTag = '[object Map]',

      numberTag = '[object Number]',

      objectTag = '[object Object]',

      regexpTag = '[object RegExp]',

      setTag = '[object Set]',

      stringTag = '[object String]',

      weakMapTag = '[object WeakMap]';

  var arrayBufferTag = '[object ArrayBuffer]',

      float32Tag = '[object Float32Array]',

      float64Tag = '[object Float64Array]',

      int8Tag = '[object Int8Array]',

      int16Tag = '[object Int16Array]',

      int32Tag = '[object Int32Array]',

      uint8Tag = '[object Uint8Array]',

      uint8ClampedTag = '[object Uint8ClampedArray]',

      uint16Tag = '[object Uint16Array]',

      uint32Tag = '[object Uint32Array]';

  /** 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 HTML entities and HTML characters. */

  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39|#96);/g,

      reUnescapedHtml = /[&<>"'`]/g,

      reHasEscapedHtml = RegExp(reEscapedHtml.source),

      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

  /** Used to match template delimiters. */

  var reEscape = /<%-([\s\S]+?)%>/g,

      reEvaluate = /<%([\s\S]+?)%>/g,

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

  /** Used to match property names within property paths. */

  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,

      reIsPlainProp = /^\w*$/,

      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g;

  /**

   * Used to match `RegExp` [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns)

   * and those outlined by [`EscapeRegExpPattern`](http://ecma-international.org/ecma-262/6.0/#sec-escaperegexppattern).

   */

  var reRegExpChars = /^[:!,]|[\\^$.*+?()[\]{}|\/]|(^[0-9a-fA-Fnrtuvx])|([\n\r\u2028\u2029])/g,

      reHasRegExpChars = RegExp(reRegExpChars.source);

  /** Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). */

  var reComboMark = /[\u0300-\u036f\ufe20-\ufe23]/g;

  /** Used to match backslashes in property paths. */

  var reEscapeChar = /\\(\\)?/g;

  /** Used to match [ES template delimiters](http://ecma-international.org/ecma-262/6.0/#sec-template-literal-lexical-components). */

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

  /** Used to match `RegExp` flags from their coerced string values. */

  var reFlags = /\w*$/;

  /** Used to detect hexadecimal string values. */

  var reHasHexPrefix = /^0[xX]/;

  /** Used to detect host constructors (Safari > 5). */

  var reIsHostCtor = /^\[object .+?Constructor\]$/;

  /** Used to detect unsigned integer values. */

  var reIsUint = /^\d+$/;

  /** Used to match latin-1 supplementary letters (excluding mathematical operators). */

  var reLatin1 = /[\xc0-\xd6\xd8-\xde\xdf-\xf6\xf8-\xff]/g;

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

  var reNoMatch = /($^)/;

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

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

  /** Used to match words to create compound words. */

  var reWords = (function() {

    var upper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]',

        lower = '[a-z\\xdf-\\xf6\\xf8-\\xff]+';

    return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g');

  }());

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

  var contextProps = [

    'Array', 'ArrayBuffer', 'Date', 'Error', 'Float32Array', 'Float64Array',

    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Math', 'Number',

    'Object', 'RegExp', 'Set', 'String', '_', 'clearTimeout', 'isFinite',

    'parseFloat', 'parseInt', 'setTimeout', 'TypeError', 'Uint8Array',

    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap'

  ];

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

  var templateCounter = -1;

  /** Used to identify `toStringTag` values of typed arrays. */

  var typedArrayTags = {};

  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =

  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =

  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =

  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =

  typedArrayTags[uint32Tag] = true;

  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =

  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =

  typedArrayTags[dateTag] = typedArrayTags[errorTag] =

  typedArrayTags[funcTag] = typedArrayTags[mapTag] =

  typedArrayTags[numberTag] = typedArrayTags[objectTag] =

  typedArrayTags[regexpTag] = typedArrayTags[setTag] =

  typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

  /** Used to identify `toStringTag` values supported by `_.clone`. */

  var cloneableTags = {};

  cloneableTags[argsTag] = cloneableTags[arrayTag] =

  cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =

  cloneableTags[dateTag] = cloneableTags[float32Tag] =

  cloneableTags[float64Tag] = cloneableTags[int8Tag] =

  cloneableTags[int16Tag] = cloneableTags[int32Tag] =

  cloneableTags[numberTag] = cloneableTags[objectTag] =

  cloneableTags[regexpTag] = cloneableTags[stringTag] =

  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =

  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;

  cloneableTags[errorTag] = cloneableTags[funcTag] =

  cloneableTags[mapTag] = cloneableTags[setTag] =

  cloneableTags[weakMapTag] = false;

  /** Used to map latin-1 supplementary letters to basic latin letters. */

  var deburredLetters = {

    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',

    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',

    '\xc7': 'C',  '\xe7': 'c',

    '\xd0': 'D',  '\xf0': 'd',

    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',

    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',

    '\xcC': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',

    '\xeC': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',

    '\xd1': 'N',  '\xf1': 'n',

    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',

    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',

    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',

    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',

    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',

    '\xc6': 'Ae', '\xe6': 'ae',

    '\xde': 'Th', '\xfe': 'th',

    '\xdf': 'ss'

  };

  /** Used to map characters to HTML entities. */

  var htmlEscapes = {

    '&': '&',

    '<': '&lt;',

    '>': '>',

    '"': '"',

    "'": ''',

    '`': '`'

  };

  /** Used to map HTML entities to characters. */

  var htmlUnescapes = {

    '&': '&',

    '&lt;': '<',

    '>': '>',

    '"': '"',

    ''': "'",

    '`': '`'

  };

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

  var objectTypes = {

    'function': true,

    'object': true

  };

  /** Used to escape characters for inclusion in compiled regexes. */

  var regexpEscapes = {

    '0': 'x30', '1': 'x31', '2': 'x32', '3': 'x33', '4': 'x34',

    '5': 'x35', '6': 'x36', '7': 'x37', '8': 'x38', '9': 'x39',

    'A': 'x41', 'B': 'x42', 'C': 'x43', 'D': 'x44', 'E': 'x45', 'F': 'x46',

    'a': 'x61', 'b': 'x62', 'c': 'x63', 'd': 'x64', 'e': 'x65', 'f': 'x66',

    'n': 'x6e', 'r': 'x72', 't': 'x74', 'u': 'x75', 'v': 'x76', 'x': 'x78'

  };

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

  var stringEscapes = {

    '\\': '\\',

    "'": "'",

    '\n': 'n',

    '\r': 'r',

    '\u2028': 'u2028',

    '\u2029': 'u2029'

  };

  /** 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. */

  var freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global;

  /** Detect free variable `self`. */

  var freeSelf = objectTypes[typeof self] && self && self.Object && self;

  /** Detect free variable `window`. */

  var freeWindow = objectTypes[typeof window] && window && window.Object && window;

  /** Detect the popular CommonJS extension `module.exports`. */

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

  /**

   * Used as a reference to the global object.

   *

   * The `this` value is used if it's the global object to avoid Greasemonkey's

   * restricted `window` object, otherwise the `window` object is used.

   */

  var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;

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

  /**

   * The base implementation of `compareAscending` which compares values and

   * sorts them in ascending order without guaranteeing a stable sort.

   *

   * @private

   * @param {*} value The value to compare.

   * @param {*} other The other value to compare.

   * @returns {number} Returns the sort order indicator for `value`.

   */

  function baseCompareAscending(value, other) {

    if (value !== other) {

      var valIsNull = value === null,

          valIsUndef = value === undefined,

          valIsReflexive = value === value;

      var othIsNull = other === null,

          othIsUndef = other === undefined,

          othIsReflexive = other === other;

      if ((value > other && !othIsNull) || !valIsReflexive ||

          (valIsNull && !othIsUndef && othIsReflexive) ||

          (valIsUndef && othIsReflexive)) {

        return 1;

      }

      if ((value < other && !valIsNull) || !othIsReflexive ||

          (othIsNull && !valIsUndef && valIsReflexive) ||

          (othIsUndef && valIsReflexive)) {

        return -1;

      }

    }

    return 0;

  }

  /**

   * The base implementation of `_.findIndex` and `_.findLastIndex` without

   * support for callback shorthands and `this` binding.

   *

   * @private

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

   * @param {Function} predicate The function invoked per iteration.

   * @param {boolean} [fromRight] Specify iterating from right to left.

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

   */

  function baseFindIndex(array, predicate, fromRight) {

    var length = array.length,

        index = fromRight ? length : -1;

    while ((fromRight ? index-- : ++index < length)) {

      if (predicate(array[index], index, array)) {

        return index;

      }

    }

    return -1;

  }

  /**

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

   *

   * @private

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

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

   * @param {number} fromIndex The index to search from.

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

   */

  function baseIndexOf(array, value, fromIndex) {

    if (value !== value) {

      return indexOfNaN(array, fromIndex);

    }

    var index = fromIndex - 1,

        length = array.length;

    while (++index < length) {

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

        return index;

      }

    }

    return -1;

  }

  /**

   * The base implementation of `_.isFunction` without support for environments

   * with incorrect `typeof` results.

   *

   * @private

   * @param {*} value The value to check.

   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.

   */

  function baseIsFunction(value) {

    // Avoid a Chakra JIT bug in compatibility modes of IE 11.

    // See https://github.com/jashkenas/underscore/issues/1621 for more details.

    return typeof value == 'function' || false;

  }

  /**

   * Converts `value` to a string if it's not one. An empty string is returned

   * for `null` or `undefined` values.

   *

   * @private

   * @param {*} value The value to process.

   * @returns {string} Returns the string.

   */

  function baseToString(value) {

    return value == null ? '' : (value + '');

  }

  /**

   * Used by `_.trim` and `_.trimLeft` to get the index of the first character

   * of `string` that is not found in `chars`.

   *

   * @private

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

   * @param {string} chars The characters to find.

   * @returns {number} Returns the index of the first character not found in `chars`.

   */

  function charsLeftIndex(string, chars) {

    var index = -1,

        length = string.length;

    while (++index < length && chars.indexOf(string.charAt(index)) > -1) {}

    return index;

  }

  /**

   * Used by `_.trim` and `_.trimRight` to get the index of the last character

   * of `string` that is not found in `chars`.

   *

   * @private

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

   * @param {string} chars The characters to find.

   * @returns {number} Returns the index of the last character not found in `chars`.

   */

  function charsRightIndex(string, chars) {

    var index = string.length;

    while (index-- && chars.indexOf(string.charAt(index)) > -1) {}

    return index;

  }

  /**

   * Used by `_.sortBy` to compare transformed elements of a collection and stable

   * sort them in ascending order.

   *

   * @private

   * @param {Object} object The object to compare.

   * @param {Object} other The other object to compare.

   * @returns {number} Returns the sort order indicator for `object`.

   */

  function compareAscending(object, other) {

    return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);

  }

  /**

   * Used by `_.sortByOrder` to compare multiple properties of a value to another

   * and stable sort them.

   *

   * If `orders` is unspecified, all valuess are sorted in ascending order. Otherwise,

   * a value is sorted in ascending order if its corresponding order is "asc", and

   * descending if "desc".

   *

   * @private

   * @param {Object} object The object to compare.

   * @param {Object} other The other object to compare.

   * @param {boolean[]} orders The order to sort by for each property.

   * @returns {number} Returns the sort order indicator for `object`.

   */

  function compareMultiple(object, other, orders) {

    var index = -1,

        objCriteria = object.criteria,

        othCriteria = other.criteria,

        length = objCriteria.length,

        ordersLength = orders.length;

    while (++index < length) {

      var result = baseCompareAscending(objCriteria[index], othCriteria[index]);

      if (result) {

        if (index >= ordersLength) {

          return result;

        }

        var order = orders[index];

        return result * ((order === 'asc' || order === true) ? 1 : -1);

      }

    }

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

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

    // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247

    // for more details.

    //

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

    // See https://code.google.com/p/v8/issues/detail?id=90 for more details.

    return object.index - other.index;

  }

  /**

   * Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters.

   *

   * @private

   * @param {string} letter The matched letter to deburr.

   * @returns {string} Returns the deburred letter.

   */

  function deburrLetter(letter) {

    return deburredLetters[letter];

  }

  /**

   * Used by `_.escape` to convert characters to HTML entities.

   *

   * @private

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

   * @returns {string} Returns the escaped character.

   */

  function escapeHtmlChar(chr) {

    return htmlEscapes[chr];

  }

  /**

   * Used by `_.escapeRegExp` to escape characters for inclusion in compiled regexes.

   *

   * @private

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

   * @param {string} leadingChar The capture group for a leading character.