;(function() {

 

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

  var undefined;

 

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

  var VERSION = '4.17.5';

 

  /** Error message constants. */

  var FUNC_ERROR_TEXT = 'Expected a function';

 

  /** Used to stand-in for `undefined` hash values. */

  var HASH_UNDEFINED = '__lodash_hash_undefined__';

 

  /** Used as the maximum memoize cache size. */

  var MAX_MEMOIZE_SIZE = 500;

 

  /** Used as references for various `Number` constants. */

  var INFINITY = 1 / 0;

 

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

  var asyncTag = '[object AsyncFunction]',

      funcTag = '[object Function]',

      genTag = '[object GeneratorFunction]',

      nullTag = '[object Null]',

      proxyTag = '[object Proxy]',

      symbolTag = '[object Symbol]',

      undefinedTag = '[object Undefined]';

 

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

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

      reIsPlainProp = /^\w*$/,

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

 

  /**

  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

 

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

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

 

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

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

 

  /** Detect free variable `global` from Node.js. */

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

 

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

  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

 

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

  var root = freeGlobal || freeSelf || Function('return this')();

 

  /** Detect free variable `exports`. */

  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

 

  /** Detect free variable `module`. */

  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

 

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

 

  /**

  function arrayMap(array, iteratee) {

    var index = -1,

        length = array == null ? 0 : array.length,

        result = Array(length);

 

    while (++index < length) {

      result[index] = iteratee(array[index], index, array);

    }

    return result;

  }

 

  /**

  function getValue(object, key) {

    return object == null ? undefined : object[key];

  }

 

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

 

  /** Used for built-in method references. */

  var arrayProto = Array.prototype,

      funcProto = Function.prototype,

      objectProto = Object.prototype;

 

  /** Used to detect overreaching core-js shims. */

  var coreJsData = root['__core-js_shared__'];

 

  /** Used to resolve the decompiled source of functions. */

  var funcToString = funcProto.toString;

 

  /** Used to check objects for own properties. */

  var hasOwnProperty = objectProto.hasOwnProperty;

 

  /** Used to detect methods masquerading as native. */

  var maskSrcKey = (function() {

    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');

    return uid ? ('Symbol(src)_1.' + uid) : '';

  }());

 

  /**

  var nativeObjectToString = objectProto.toString;

 

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

  var reIsNative = RegExp('^' +

    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')

    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'

  );

 

  /** Built-in value references. */

  var Symbol = root.Symbol,

      splice = arrayProto.splice,

      symToStringTag = Symbol ? Symbol.toStringTag : undefined;

 

  /* Built-in method references that are verified to be native. */

  var Map = getNative(root, 'Map'),

      nativeCreate = getNative(Object, 'create');

 

  /** Used to lookup unminified function names. */

  var realNames = {};

 

  /** Used to convert symbols to primitives and strings. */

  var symbolProto = Symbol ? Symbol.prototype : undefined,

      symbolToString = symbolProto ? symbolProto.toString : undefined;

 

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

 

  /**

  function lodash() {

    // No operation performed.

  }

 

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

 

  /**

  function Hash(entries) {

    var index = -1,

        length = entries == null ? 0 : entries.length;

 

    this.clear();

    while (++index < length) {

      var entry = entries[index];

      this.set(entry[0], entry[1]);

    }

  }

 

  /**

  function hashClear() {

    this.__data__ = nativeCreate ? nativeCreate(null) : {};

    this.size = 0;

  }

 

  /**

  function hashDelete(key) {

    var result = this.has(key) && delete this.__data__[key];

    this.size -= result ? 1 : 0;

    return result;

  }

 

  /**

  function hashGet(key) {

    var data = this.__data__;

    if (nativeCreate) {

      var result = data[key];

      return result === HASH_UNDEFINED ? undefined : result;

    }

    return hasOwnProperty.call(data, key) ? data[key] : undefined;

  }

 

  /**

  function hashHas(key) {

    var data = this.__data__;

    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);

  }

 

  /**

  function hashSet(key, value) {

    var data = this.__data__;

    this.size += this.has(key) ? 0 : 1;

    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;

    return this;

  }

 

  // Add methods to `Hash`.

  Hash.prototype.clear = hashClear;

  Hash.prototype['delete'] = hashDelete;

  Hash.prototype.get = hashGet;

  Hash.prototype.has = hashHas;

  Hash.prototype.set = hashSet;

 

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

 

  /**

  function ListCache(entries) {

    var index = -1,

        length = entries == null ? 0 : entries.length;

 

    this.clear();

    while (++index < length) {

      var entry = entries[index];

      this.set(entry[0], entry[1]);

    }

  }

 

  /**

  function listCacheClear() {

    this.__data__ = [];

    this.size = 0;

  }

 

  /**

  function listCacheDelete(key) {

    var data = this.__data__,

        index = assocIndexOf(data, key);

 

    if (index < 0) {

      return false;

    }

    var lastIndex = data.length - 1;

    if (index == lastIndex) {

      data.pop();

    } else {

      splice.call(data, index, 1);

    }

    --this.size;

    return true;

  }

 

  /**

  function listCacheGet(key) {

    var data = this.__data__,

        index = assocIndexOf(data, key);

 

    return index < 0 ? undefined : data[index][1];

  }

 

  /**

  function listCacheHas(key) {

    return assocIndexOf(this.__data__, key) > -1;

  }

 

  /**

  function listCacheSet(key, value) {

    var data = this.__data__,

        index = assocIndexOf(data, key);

 

    if (index < 0) {

      ++this.size;

      data.push([key, value]);

    } else {

      data[index][1] = value;

    }

    return this;

  }

 

  // Add methods to `ListCache`.

  ListCache.prototype.clear = listCacheClear;

  ListCache.prototype['delete'] = listCacheDelete;

  ListCache.prototype.get = listCacheGet;

  ListCache.prototype.has = listCacheHas;

  ListCache.prototype.set = listCacheSet;

 

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

 

  /**

  function MapCache(entries) {

    var index = -1,

        length = entries == null ? 0 : entries.length;

 

    this.clear();

    while (++index < length) {

      var entry = entries[index];

      this.set(entry[0], entry[1]);

    }

  }

 

  /**

  function mapCacheClear() {

    this.size = 0;

    this.__data__ = {

      'hash': new Hash,

      'map': new (Map || ListCache),

      'string': new Hash

    };

  }

 

  /**

  function mapCacheDelete(key) {

    var result = getMapData(this, key)['delete'](key);

    this.size -= result ? 1 : 0;

    return result;

  }

 

  /**

  function mapCacheGet(key) {

    return getMapData(this, key).get(key);

  }

 

  /**

  function mapCacheHas(key) {

    return getMapData(this, key).has(key);

  }

 

  /**

  function mapCacheSet(key, value) {

    var data = getMapData(this, key),

        size = data.size;

 

    data.set(key, value);

    this.size += data.size == size ? 0 : 1;

    return this;

  }

 

  // Add methods to `MapCache`.

  MapCache.prototype.clear = mapCacheClear;

  MapCache.prototype['delete'] = mapCacheDelete;

  MapCache.prototype.get = mapCacheGet;

  MapCache.prototype.has = mapCacheHas;

  MapCache.prototype.set = mapCacheSet;

 

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

 

  /**

  function assocIndexOf(array, key) {

    var length = array.length;

    while (length--) {

      if (eq(array[length][0], key)) {

        return length;

      }

    }

    return -1;

  }

 

  /**

  function baseGet(object, path) {

    path = castPath(path, object);

 

    var index = 0,

        length = path.length;

 

    while (object != null && index < length) {

      object = object[toKey(path[index++])];

    }

    return (index && index == length) ? object : undefined;

  }

 

  /**

  function baseGetTag(value) {

    if (value == null) {

      return value === undefined ? undefinedTag : nullTag;

    }

    return (symToStringTag && symToStringTag in Object(value))

      ? getRawTag(value)

      : objectToString(value);

  }

 

  /**

  function baseIsNative(value) {

    if (!isObject(value) || isMasked(value)) {

      return false;

    }

    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;

    return pattern.test(toSource(value));

  }

 

  /**

  function baseToString(value) {

    // Exit early for strings to avoid a performance hit in some environments.

    if (typeof value == 'string') {

      return value;

    }

    if (isArray(value)) {

      // Recursively convert values (susceptible to call stack limits).

      return arrayMap(value, baseToString) + '';

    }

    if (isSymbol(value)) {

      return symbolToString ? symbolToString.call(value) : '';

    }

    var result = (value + '');

    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;

  }

 

  /**

  function castPath(value, object) {

    if (isArray(value)) {

      return value;

    }

    return isKey(value, object) ? [value] : stringToPath(toString(value));

  }

 

  /**

  function getMapData(map, key) {

    var data = map.__data__;

    return isKeyable(key)

      ? data[typeof key == 'string' ? 'string' : 'hash']

      : data.map;

  }

 

  /**

  function getNative(object, key) {

    var value = getValue(object, key);

    return baseIsNative(value) ? value : undefined;

  }

 

  /**

  function getRawTag(value) {

    var isOwn = hasOwnProperty.call(value, symToStringTag),

        tag = value[symToStringTag];

 

    try {

      value[symToStringTag] = undefined;

      var unmasked = true;

    } catch (e) {}

 

    var result = nativeObjectToString.call(value);

    if (unmasked) {

      if (isOwn) {

        value[symToStringTag] = tag;

      } else {

        delete value[symToStringTag];

      }

    }

    return result;

  }

 

  /**

  function isKey(value, object) {

    if (isArray(value)) {

      return false;

    }

    var type = typeof value;

    if (type == 'number' || type == 'symbol' || type == 'boolean' ||

        value == null || isSymbol(value)) {

      return true;

    }

    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||

      (object != null && value in Object(object));

  }

 

  /**

  function isKeyable(value) {

    var type = typeof value;

    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')

      ? (value !== '__proto__')

      : (value === null);

  }

 

  /**

  function isMasked(func) {

    return !!maskSrcKey && (maskSrcKey in func);

  }

 

  /**

  function memoizeCapped(func) {

    var result = memoize(func, function(key) {

      if (cache.size === MAX_MEMOIZE_SIZE) {

        cache.clear();

      }

      return key;

    });

 

    var cache = result.cache;

    return result;

  }

 

  /**

  function objectToString(value) {

    return nativeObjectToString.call(value);

  }

 

  /**

  var stringToPath = memoizeCapped(function(string) {

    var result = [];

    if (string.charCodeAt(0) === 46 /* . */) {

      result.push('');

    }

    string.replace(rePropName, function(match, number, quote, subString) {

      result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));

    });

    return result;

  });

 

  /**

  function toKey(value) {

    if (typeof value == 'string' || isSymbol(value)) {

      return value;

    }

    var result = (value + '');

    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;

  }

 

  /**

  function toSource(func) {

    if (func != null) {

      try {

        return funcToString.call(func);

      } catch (e) {}

      try {

        return (func + '');

      } catch (e) {}

    }

    return '';

  }

 

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

 

  /**

  function memoize(func, resolver) {

    if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {

      throw new TypeError(FUNC_ERROR_TEXT);

    }

    var memoized = function() {

      var args = arguments,

          key = resolver ? resolver.apply(this, args) : args[0],

          cache = memoized.cache;

 

      if (cache.has(key)) {

        return cache.get(key);

      }

      var result = func.apply(this, args);

      memoized.cache = cache.set(key, result) || cache;

      return result;

    };

    memoized.cache = new (memoize.Cache || MapCache);

    return memoized;

  }

 

  // Expose `MapCache`.

  memoize.Cache = MapCache;

 

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

 

  /**

  function eq(value, other) {

    return value === other || (value !== value && other !== other);

  }

 

  /**

  var isArray = Array.isArray;

 

  /**

  function isFunction(value) {

    if (!isObject(value)) {

      return false;

    }

    // The use of `Object#toString` avoids issues with the `typeof` operator

    // in Safari 9 which returns 'object' for typed arrays and other constructors.

    var tag = baseGetTag(value);

    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;

  }

 

  /**

  function isObject(value) {

    var type = typeof value;

    return value != null && (type == 'object' || type == 'function');

  }

 

  /**

  function isObjectLike(value) {

    return value != null && typeof value == 'object';

  }

 

  /**

  function isSymbol(value) {

    return typeof value == 'symbol' ||

      (isObjectLike(value) && baseGetTag(value) == symbolTag);

  }

 

  /**

  function toString(value) {

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

  }

 

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

 

  /**

  function get(object, path, defaultValue) {

    var result = object == null ? undefined : baseGet(object, path);

    return result === undefined ? defaultValue : result;

  }

 

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

 

  // Add methods that return wrapped values in chain sequences.

  lodash.memoize = memoize;

 

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

 

  // Add methods that return unwrapped values in chain sequences.

  lodash.eq = eq;

  lodash.get = get;

  lodash.isArray = isArray;

  lodash.isFunction = isFunction;

  lodash.isObject = isObject;

  lodash.isObjectLike = isObjectLike;

  lodash.isSymbol = isSymbol;

  lodash.toString = toString;

 

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

 

  /**

  lodash.VERSION = VERSION;

 

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

 

  // Some AMD build optimizers, like r.js, check for condition patterns like:

  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {

    // Expose Lodash on the global object to prevent errors when Lodash is

    // loaded by a script tag in the presence of an AMD loader.

    // See http://requirejs.org/docs/errors.html#mismatch for more details.

    // Use `_.noConflict` to remove Lodash from the global object.

    root._ = lodash;

 

    // Define as an anonymous module so, through path mapping, it can be

    // referenced as the "underscore" module.

    define(function() {

      return lodash;

    });

  }

  // Check for `exports` after `define` in case a build optimizer adds it.

  else if (freeModule) {

    // Export for Node.js.

    (freeModule.exports = lodash)._ = lodash;

    // Export for CommonJS support.

    freeExports._ = lodash;

  }

  else {

    // Export to the global object.

    root._ = lodash;

  }

}.call(this));