//     Underscore.js 1.5.2

//     http://underscorejs.org

//     (c) 2009-2013 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._;

  // Establish the object that gets returned to break out of a loop iteration.

  var breaker = {};

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

    concat           = ArrayProto.concat,

    toString         = ObjProto.toString,

    hasOwnProperty   = ObjProto.hasOwnProperty;

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

  // are declared here.

  var

    nativeForEach      = ArrayProto.forEach,

    nativeMap          = ArrayProto.map,

    nativeReduce       = ArrayProto.reduce,

    nativeReduceRight  = ArrayProto.reduceRight,

    nativeFilter       = ArrayProto.filter,

    nativeEvery        = ArrayProto.every,

    nativeSome         = ArrayProto.some,

    nativeIndexOf      = ArrayProto.indexOf,

    nativeLastIndexOf  = ArrayProto.lastIndexOf,

    nativeIsArray      = Array.isArray,

    nativeKeys         = Object.keys,

    nativeBind         = FuncProto.bind;

  // 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 via a string identifier,

  // for Closure Compiler "advanced" mode.

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

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

      exports = module.exports = _;

    }

    exports._ = _;

  } else {

    root._ = _;

  }

  // Current version.

  _.VERSION = '1.5.2';

  // Collection Functions

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

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

  // Handles objects with the built-in `forEach`, arrays, and raw objects.

  // Delegates to **ECMAScript 5**'s native `forEach` if available.

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

    if (obj == null) return;

    if (nativeForEach && obj.forEach === nativeForEach) {

      obj.forEach(iterator, context);

    } else if (obj.length === +obj.length) {

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

        if (iterator.call(context, obj[i], i, obj) === breaker) return;

      }

    } else {

      var keys = _.keys(obj);

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

        if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;

      }

    }

  };

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

  // Delegates to **ECMAScript 5**'s native `map` if available.

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

    var results = [];

    if (obj == null) return results;

    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);

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

      results.push(iterator.call(context, value, index, list));

    });

    return results;

  };

  var reduceError = 'Reduce of empty array with no initial value';

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

  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.

  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {

    var initial = arguments.length > 2;

    if (obj == null) obj = [];

    if (nativeReduce && obj.reduce === nativeReduce) {

      if (context) iterator = _.bind(iterator, context);

      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);

    }

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

      if (!initial) {

        memo = value;

        initial = true;

      } else {

        memo = iterator.call(context, memo, value, index, list);

      }

    });

    if (!initial) throw new TypeError(reduceError);

    return memo;

  };

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

  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.

  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {

    var initial = arguments.length > 2;

    if (obj == null) obj = [];

    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {

      if (context) iterator = _.bind(iterator, context);

      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);

    }

    var length = obj.length;

    if (length !== +length) {

      var keys = _.keys(obj);

      length = keys.length;

    }

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

      index = keys ? keys[--length] : --length;

      if (!initial) {

        memo = obj[index];

        initial = true;

      } else {

        memo = iterator.call(context, memo, obj[index], index, list);

      }

    });

    if (!initial) throw new TypeError(reduceError);

    return memo;

  };

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

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

    var result;

    any(obj, function(value, index, list) {

      if (iterator.call(context, value, index, list)) {

        result = value;

        return true;

      }

    });

    return result;

  };

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

  // Delegates to **ECMAScript 5**'s native `filter` if available.

  // Aliased as `select`.

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

    var results = [];

    if (obj == null) return results;

    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);

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

      if (iterator.call(context, value, index, list)) results.push(value);

    });

    return results;

  };

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

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

    return _.filter(obj, function(value, index, list) {

      return !iterator.call(context, value, index, list);

    }, context);

  };

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

  // Delegates to **ECMAScript 5**'s native `every` if available.

  // Aliased as `all`.

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

    iterator || (iterator = _.identity);

    var result = true;

    if (obj == null) return result;

    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);

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

      if (!(result = result && iterator.call(context, value, index, list))) return breaker;

    });

    return !!result;

  };

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

  // Delegates to **ECMAScript 5**'s native `some` if available.

  // Aliased as `any`.

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

    iterator || (iterator = _.identity);

    var result = false;

    if (obj == null) return result;

    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);

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

      if (result || (result = iterator.call(context, value, index, list))) return breaker;

    });

    return !!result;

  };

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

  // Aliased as `include`.

  _.contains = _.include = function(obj, target) {

    if (obj == null) return false;

    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;

    return any(obj, function(value) {

      return value === target;

    });

  };

  // 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) {

      return (isFunc ? method : value[method]).apply(value, args);

    });

  };

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

  _.pluck = function(obj, key) {

    return _.map(obj, function(value){ return value[key]; });

  };

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

  // containing specific `key:value` pairs.

  _.where = function(obj, attrs, first) {

    if (_.isEmpty(attrs)) return first ? void 0 : [];

    return _[first ? 'find' : 'filter'](obj, function(value) {

      for (var key in attrs) {

        if (attrs[key] !== value[key]) return false;

      }

      return true;

    });

  };

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

  // containing specific `key:value` pairs.

  _.findWhere = function(obj, attrs) {

    return _.where(obj, attrs, true);

  };

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

  // Can't optimize arrays of integers longer than 65,535 elements.

  // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)

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

    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {

      return Math.max.apply(Math, obj);

    }

    if (!iterator && _.isEmpty(obj)) return -Infinity;

    var result = {computed : -Infinity, value: -Infinity};

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

      var computed = iterator ? iterator.call(context, value, index, list) : value;

      computed > result.computed && (result = {value : value, computed : computed});

    });

    return result.value;

  };

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

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

    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {

      return Math.min.apply(Math, obj);

    }

    if (!iterator && _.isEmpty(obj)) return Infinity;

    var result = {computed : Infinity, value: Infinity};

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

      var computed = iterator ? iterator.call(context, value, index, list) : value;

      computed < result.computed && (result = {value : value, computed : computed});

    });

    return result.value;

  };

  // Shuffle an array, using the modern version of the 

  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).

  _.shuffle = function(obj) {

    var rand;

    var index = 0;

    var shuffled = [];

    each(obj, function(value) {

      rand = _.random(index++);

      shuffled[index - 1] = shuffled[rand];

      shuffled[rand] = value;

    });

    return shuffled;

  };

  // Sample **n** random values from an array.

  // If **n** is not specified, returns a single random element from the array.

  // The internal `guard` argument allows it to work with `map`.

  _.sample = function(obj, n, guard) {

    if (arguments.length < 2 || guard) {

      return obj[_.random(obj.length - 1)];

    }

    return _.shuffle(obj).slice(0, Math.max(0, n));

  };

  // An internal function to generate lookup iterators.

  var lookupIterator = function(value) {

    return _.isFunction(value) ? value : function(obj){ return obj[value]; };

  };

  // Sort the object's values by a criterion produced by an iterator.

  _.sortBy = function(obj, value, context) {

    var iterator = lookupIterator(value);

    return _.pluck(_.map(obj, function(value, index, list) {

      return {

        value: value,

        index: index,

        criteria: iterator.call(context, value, index, list)

      };