//     Underscore.js 1.8.3

//     http://underscorejs.org

//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

//     Underscore may be freely distributed under the MIT license.

(function() {

  // Baseline setup

  // --------------

  // Establish the root object, `window` in the browser, or `exports` on the server.

  var root = this;

  // Save the previous value of the `_` variable.

  var previousUnderscore = root._;

  // Save bytes in the minified (but not gzipped) version:

  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;

  // Create quick reference variables for speed access to core prototypes.

  var

    push             = ArrayProto.push,

    slice            = ArrayProto.slice,

    toString         = ObjProto.toString,

    hasOwnProperty   = ObjProto.hasOwnProperty;

  // All **ECMAScript 5** native function implementations that we hope to use

  // are declared here.

  var

    nativeIsArray      = Array.isArray,

    nativeKeys         = Object.keys,

    nativeBind         = FuncProto.bind,

    nativeCreate       = Object.create;

  // Naked function reference for surrogate-prototype-swapping.

  var Ctor = function(){};

  // Create a safe reference to the Underscore object for use below.

  var _ = function(obj) {

    if (obj instanceof _) return obj;

    if (!(this instanceof _)) return new _(obj);

    this._wrapped = obj;

  };

  // Export the Underscore object for **Node.js**, with

  // backwards-compatibility for the old `require()` API. If we're in

  // the browser, add `_` as a global object.

  if (typeof exports !== 'undefined') {

    if (typeof module !== 'undefined' && module.exports) {

      exports = module.exports = _;

    }

    exports._ = _;

  } else {

    root._ = _;

  }

  // Current version.

  _.VERSION = '1.8.3';

  // Internal function that returns an efficient (for current engines) version

  // of the passed-in callback, to be repeatedly applied in other Underscore

  // functions.

  var optimizeCb = function(func, context, argCount) {

    if (context === void 0) return func;

    switch (argCount == null ? 3 : argCount) {

      case 1: return function(value) {

        return func.call(context, value);

      };

      case 2: return function(value, other) {

        return func.call(context, value, other);

      };

      case 3: return function(value, index, collection) {

        return func.call(context, value, index, collection);

      };

      case 4: return function(accumulator, value, index, collection) {

        return func.call(context, accumulator, value, index, collection);

      };

    }

    return function() {

      return func.apply(context, arguments);

    };

  };

  // A mostly-internal function to generate callbacks that can be applied

  // to each element in a collection, returning the desired result — either

  // identity, an arbitrary callback, a property matcher, or a property accessor.

  var cb = function(value, context, argCount) {

    if (value == null) return _.identity;

    if (_.isFunction(value)) return optimizeCb(value, context, argCount);

    if (_.isObject(value)) return _.matcher(value);

    return _.property(value);

  };

  _.iteratee = function(value, context) {

    return cb(value, context, Infinity);

  };

  // An internal function for creating assigner functions.

  var createAssigner = function(keysFunc, undefinedOnly) {

    return function(obj) {

      var length = arguments.length;

      if (length < 2 || obj == null) return obj;

      for (var index = 1; index < length; index++) {

        var source = arguments[index],

            keys = keysFunc(source),

            l = keys.length;

        for (var i = 0; i < l; i++) {

          var key = keys[i];

          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];

        }

      }

      return obj;

    };

  };

  // An internal function for creating a new object that inherits from another.

  var baseCreate = function(prototype) {

    if (!_.isObject(prototype)) return {};

    if (nativeCreate) return nativeCreate(prototype);

    Ctor.prototype = prototype;

    var result = new Ctor;

    Ctor.prototype = null;

    return result;

  };

  var property = function(key) {

    return function(obj) {

      return obj == null ? void 0 : obj[key];

    };

  };

  // Helper for collection methods to determine whether a collection

  // should be iterated as an array or as an object

  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength

  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094

  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

  var getLength = property('length');

  var isArrayLike = function(collection) {

    var length = getLength(collection);

    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;

  };

  // Collection Functions

  // --------------------

  // The cornerstone, an `each` implementation, aka `forEach`.

  // Handles raw objects in addition to array-likes. Treats all

  // sparse array-likes as if they were dense.

  _.each = _.forEach = function(obj, iteratee, context) {

    iteratee = optimizeCb(iteratee, context);

    var i, length;

    if (isArrayLike(obj)) {

      for (i = 0, length = obj.length; i < length; i++) {

        iteratee(obj[i], i, obj);

      }

    } else {

      var keys = _.keys(obj);

      for (i = 0, length = keys.length; i < length; i++) {

        iteratee(obj[keys[i]], keys[i], obj);

      }

    }

    return obj;

  };

  // Return the results of applying the iteratee to each element.

  _.map = _.collect = function(obj, iteratee, context) {

    iteratee = cb(iteratee, context);

    var keys = !isArrayLike(obj) && _.keys(obj),

        length = (keys || obj).length,

        results = Array(length);

    for (var index = 0; index < length; index++) {

      var currentKey = keys ? keys[index] : index;

      results[index] = iteratee(obj[currentKey], currentKey, obj);

    }

    return results;

  };

  // Create a reducing function iterating left or right.

  function createReduce(dir) {

    // Optimized iterator function as using arguments.length

    // in the main function will deoptimize the, see #1991.

    function iterator(obj, iteratee, memo, keys, index, length) {

      for (; index >= 0 && index < length; index += dir) {

        var currentKey = keys ? keys[index] : index;

        memo = iteratee(memo, obj[currentKey], currentKey, obj);

      }

      return memo;

    }

    return function(obj, iteratee, memo, context) {

      iteratee = optimizeCb(iteratee, context, 4);

      var keys = !isArrayLike(obj) && _.keys(obj),

          length = (keys || obj).length,

          index = dir > 0 ? 0 : length - 1;

      // Determine the initial value if none is provided.

      if (arguments.length < 3) {

        memo = obj[keys ? keys[index] : index];

        index += dir;

      }

      return iterator(obj, iteratee, memo, keys, index, length);

    };

  }

  // **Reduce** builds up a single result from a list of values, aka `inject`,

  // or `foldl`.

  _.reduce = _.foldl = _.inject = createReduce(1);

  // The right-associative version of reduce, also known as `foldr`.

  _.reduceRight = _.foldr = createReduce(-1);

  // Return the first value which passes a truth test. Aliased as `detect`.

  _.find = _.detect = function(obj, predicate, context) {

    var key;

    if (isArrayLike(obj)) {

      key = _.findIndex(obj, predicate, context);

    } else {

      key = _.findKey(obj, predicate, context);

    }

    if (key !== void 0 && key !== -1) return obj[key];

  };

  // Return all the elements that pass a truth test.

  // Aliased as `select`.

  _.filter = _.select = function(obj, predicate, context) {

    var results = [];

    predicate = cb(predicate, context);

    _.each(obj, function(value, index, list) {

      if (predicate(value, index, list)) results.push(value);

    });

    return results;

  };

  // Return all the elements for which a truth test fails.

  _.reject = function(obj, predicate, context) {

    return _.filter(obj, _.negate(cb(predicate)), context);

  };

  // Determine whether all of the elements match a truth test.

  // Aliased as `all`.

  _.every = _.all = function(obj, predicate, context) {

    predicate = cb(predicate, context);

    var keys = !isArrayLike(obj) && _.keys(obj),

        length = (keys || obj).length;

    for (var index = 0; index < length; index++) {

      var currentKey = keys ? keys[index] : index;

      if (!predicate(obj[currentKey], currentKey, obj)) return false;

    }

    return true;

  };

  // Determine if at least one element in the object matches a truth test.

  // Aliased as `any`.

  _.some = _.any = function(obj, predicate, context) {

    predicate = cb(predicate, context);

    var keys = !isArrayLike(obj) && _.keys(obj),

        length = (keys || obj).length;

    for (var index = 0; index < length; index++) {

      var currentKey = keys ? keys[index] : index;

      if (predicate(obj[currentKey], currentKey, obj)) return true;

    }

    return false;

  };

  // Determine if the array or object contains a given item (using `===`).

  // Aliased as `includes` and `include`.

  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {

    if (!isArrayLike(obj)) obj = _.values(obj);

    if (typeof fromIndex != 'number' || guard) fromIndex = 0;

    return _.indexOf(obj, item, fromIndex) >= 0;

  };

  // Invoke a method (with arguments) on every item in a collection.

  _.invoke = function(obj, method) {

    var args = slice.call(arguments, 2);

    var isFunc = _.isFunction(method);

    return _.map(obj, function(value) {

      var func = isFunc ? method : value[method];

      return func == null ? func : func.apply(value, args);

    });

  };

  // Convenience version of a common use case of `map`: fetching a property.

  _.pluck = function(obj, key) {

    return _.map(obj, _.property(key));

  };

  // Convenience version of a common use case of `filter`: selecting only objects

  // containing specific `key:value` pairs.

  _.where = function(obj, attrs) {

    return _.filter(obj, _.matcher(attrs));

  };

  // Convenience version of a common use case of `find`: getting the first object

  // containing specific `key:value` pairs.

  _.findWhere = function(obj, attrs) {

    return _.find(obj, _.matcher(attrs));

  };

  // Return the maximum element (or element-based computation).

  _.max = function(obj, iteratee, context) {

    var result = -Infinity, lastComputed = -Infinity,

        value, computed;

    if (iteratee == null && obj != null) {

      obj = isArrayLike(obj) ? obj : _.values(obj);

      for (var i = 0, length = obj.length; i < length; i++) {

        value = obj[i];

        if (value > result) {

          result = value;

        }

      }

    } else {

      iteratee = cb(iteratee, context);

      _.each(obj, function(value, index, list) {

        computed = iteratee(value, index, list);

        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {

          result = value;

          lastComputed = computed;

        }

      });

    }

    return result;

  };

  // Return the minimum element (or element-based computation).

  _.min = function(obj, iteratee, context) {

    var result = Infinity, lastComputed = Infinity,

        value, computed;

    if (iteratee == null && obj != null) {

      obj = isArrayLike(obj) ? obj : _.values(obj);

      for (var i = 0, length = obj.length; i < length; i++) {